Article source code: event.zip

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

1. Declare a delegate, if definition is not provided the .NET Framework would provide a default delegate implementation
2. Declare the event signature using Event keyword and raise the event using RaiseEvent statement
3. Handle the event by declaring an event receiver, often called event handler, which is a subroutine that responds to the event.

Declare a delegate

Delegate is a class that can hold reference to a method. Delegate class has signature, and it can hold references only to methods that match its signature. Delegate can be declared as

Delegate Sub sampleDel(ByVal Cancel As Boolean)

Any method that has same signature can be attached to this delegate; procedure that would have the same signature can handle this event.

Declare Event and Raise It

Event can be declared in three ways:

evtSample As sampleDel - 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 explicitly declared delegate. The event is raised by making a call to evtSample.

Public Event evtSample as sampleDel - event handler can be registered by using AddHandler method in the Class that would provide the 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) - event handler procedure would be registered by using 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 mechanism to register event and raises events with intervals simulating 5, 10 and 30 units of the 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 mobjTimer.evtHour
        Console.WriteLine("Hour's Event")
    End Sub

    Public Shared Sub Main()
        Dim cc1 = New CClock()
    End Sub

End Class