Problem solve Get help with specific problems with your technologies, process and projects.

Working with events in VB.NET

Learn the three step procedure for implementing an event in VB.NET.

Let other users know how useful this tip is by rating it below. Got a tip or code of your own you'd like to share? Submit it here!

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 involved the following three-step procedure:

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

Now let's take each step one by one.

1. 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 DelegateSub 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.

2. Declare an event and raise it.

An event can be declared in mainly three ways:

1. evtSampleAs sampleDel
The mechanism to register the event handler for this type of declaration is 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.

2. PublicEvent 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.

3. PublicEvent evtSample(Cancel as Boolean)
The event handler procedure would be registered by using the Handle's 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.

3. Handle the event.

Declaring a sub and either attaching it to the delegate or registering with the event declaring class can handle the event.


The example shown below 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
  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)
  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
  Console.WriteLine("Hour's Event") 
 End Sub 

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


Dig Deeper on VB 6 to VB .NET Migration