Events in the .NET
Framework are based on the delegate model. Delegates are
type-safe Function Pointers or Callbacks. A delegate can
reference both static and instance methods.
Implementation of an event
is a three-step procedure.
- Declare a delegate, if
definition is not provided the .Net Framework would
provide a default delegate implementation.
- Declare the event
signature using the Event keyword and Raise the
event using the RaiseEvent statement.
- Handle the Event by
declaring an event receiver, often called an event
handler. Which is a subroutine that responds to an
event.
Lets now take each step on by
one.
Declare a delegate.
A delegate is a class that can
hold a reference to a method. A delegate class has a
signature, and it can hold references only to methods
that match its signature. A delegate can be defined as
Delegate Sub sampleDel(Cancel as Boolean).
Any method that has same signature can be attached to
this delegate; a procedure that would have the same
signature can handle this event.
Declare an Event and
Raise It.
An even can be declared in
mainly three ways.
evtSample As sampleDel-The
mechanism to register the event handler, for this type
of declaration is to be provided by the class declaring
the event. The event is implemented by using the
explicitly declared delegate.
The event is raised by making a
call to evtSample.
Public Event evtSample as
sampleDel-The event handler can be registered by using
AddHandler method in the Class that would provide a
Handler. The event is implemented by using the
above-declared delegate.
The event is raised by making a
call to RaiseEvent.
Public Event evtSample(Cancel
as Boolean)-The event handler procedure would be
registered by using the Handles keyword in the
declaration itself. The event is implemented by using
implicitly declared delegate by the framework.
The event is raised by making a
call to RaiseEvent.
Handle the Event.
Declaring a sub and either
attaching it to the delegate or registering with the
event declaring class can handle the event.
Example.
The example shown declares a
delegate in class CTimer and also declares three events
in the class using all the aforementioned declarations.
The class also provides a mechanism to register an
event. And raises events at intervals simulating 5, 10
and 30 units of interval. Another class CClock is
defined that has members to handle the RaisedEvents from
CTimer class.
To run the sample from command
line use-"vbc /out:Event.exe Event.vb".
Imports
System
Public
Class CTimer
Delegate
Sub SecondDel(ByVal
xintTime As
Integer)
Private evtSecond
As SecondDel
Public
Event evtMinute
As SecondDel
Public
Event evtHour(ByVal
xHour As
Integer)
Public
Shared lngSeconds
As
Long
Public Sub
Register(ByVal
objSecond As
SecondDel)
evtSecond = evtSecond.Combine(evtSecond, objSecond)
End
Sub
Public Sub
OnTimer()
lngSeconds = lngSeconds + 1
If lngSeconds
Mod 5 = 0
Then
evtSecond(lngSeconds)
End
If
If lngSeconds Mod
10 = 0 Then
RaiseEvent evtMinute(lngSeconds)
End
If
If lngSeconds Mod
30 = 0 Then
RaiseEvent evtHour(lngSeconds)
End
If
End Sub
End Class
Public Class
CClock
Private
WithEvents
mobjTimer As
CTimer
Sub
New()
mobjTimer = New
CTimer
mobjTimer.Register(New
CTimer.SecondDel(AddressOf
SecondEvent))
AddHandler
mobjTimer.evtMinute,
AddressOf MinuteEvent
While (mobjTimer.lngSeconds
< 60)
mobjTimer.OnTimer()
System.Threading.Thread.Sleep(100)
End
While
End Sub
Private Sub
SecondEvent(ByVal
xintTime As
Integer)
Console.WriteLine("Second's Event")
End
Sub
Private Sub
MinuteEvent(ByVal
xintTime As
Integer)
Console.WriteLine("Minute's Event")
End
Sub
Private Sub
mobjTimer_evtHour(ByVal
xintTime As
Integer)
Handles
objTimer.evtHour
Console.WriteLine("Hour's Event")
End
Sub
Public Shared
Sub Main()
Dim cc1 =
New CClock
End
Sub
End Class