Creating custom events with Visual Basic .NET 2005
Events model in VB.NET
Events are defined as actions or occurances of interest. An interested object can subscribe to an event and be notified when it happens. For example, a button on a form can generate a click event and the form can subscribe and get notified when the event occurs. This click event is processed through the form code.
VB.NET 2005 provides a range of flexible event models to address simple or very complex events. Below is an example of a simple event using a Worker class with a DoWork method:
|
1 2 3 4 5 6 7 8 9 |
Public Class Worker Public Sub DoWork() For completedWork As Integer = 1 To 100 System.Threading.Thread.Sleep(1000) Console.WriteLine(completedWork) Next End Sub End Class |
The DoWork method has a For loop repeating 100 times, waiting one second between loops, and printing out the completed work to the console. But a client such as a form using the object of the above class, for example, should provide visual feedback on how much work has been completed when the DoWork method is called. Adding an event to the Worker class and altering the DoWork method to call the event can provide this information to the client.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Public Class Worker Public Event WorkDone(ByVal completedWork As Integer) Public Sub DoWork() For completedWork As Integer = 1 To 100 System.Threading.Thread.Sleep(1000) RaiseEvent WorkDone(completedWork) Console.WriteLine(completedWork) Next End Sub End Class |
An event called WorkDone has been identified with an integer argument through which the amount of work completed can be passed. And in the DoWork method, the event passing the actual amount of work completed is raised. Now the above class can be consumed by a client by declaring and creating a Worker class object with events and handling the WorkDone event to provide feedback on progress.
|
1 2 3 |
Private WithEvents mWorker As New Worker Private Sub work_WorkDone(ByVal completedWork As Integer) Handles mWorker.WorkDone End Sub |
In the above code, the work_WorkDone method will be called each time the WorkDone event is raised. The Handles clause after the method signature links the event-handling code with the actual event.
A method can also dynamically link to an event using the AddHandler method and be removed from handling an event using the RemoveHandler method as seen below. This enables more flexibility by relating a method to an event and removing the binding required at runtime. Even when the Handles keyword is used to bind a method to an event internally, a call to the AddHandler method is done to perform the actual binding.
‘We dont require to use WithEvents since we are binding to events dynamically
Private mWorker As New Worker
|
1 2 3 4 |
'Binds a method(handler) to an event AddHandler mWorker.WorkDone, AddressOf work_WorkDone 'Unbinds a method(handler) from an event RemoveHandler mWorker.WorkDone, AddressOf work_WorkDone |
Delegates in .NET events
VB.NET implements events through a construct called delegates. Delegates point to a method and can hold the address of a method, enabling a method to be invoked through an instance of its delegate. The Worker class can be implemented without events using a delegate as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Public Class Worker Public Delegate Sub WorkDone(ByVal completedWork As Integer ) Public Handler As WorkDone Public Sub DoWork() For completedWork As Integer = 1 To 10 System.Threading.Thread.Sleep(1000) If handler IsNot Nothing Then handler(completedWork * 10) End If Console.WriteLine(completedWork) Next End Sub End Class |
In the code above, a delegate named WorkDone that accepts an integer argument has been defined. This delegate can point to any method with a similar signature (a sub-procedure that accepts an integer). After the delegate is defined, a public variable delegate named Handler has been defined, and instead of raising the event in the DoWork method, the delegate instance is invoked.
In the Worker class client, the delegate instance is set to point to the method that will be called when reporting the amount of work done.
|
1 2 3 |
Private mWorker As new Worker 'Sets the delegate instance to the method implementation mWorker.Handler = AddressOf work_WorkDone |
The above code uses delegates directly, not the event construct, so neither the AddHandler nor RemoveHandler methods can be used. This exposes only one public variable, so there can be only one method to handle the invocation of the delegate.
Directly using the delegates method eliminates the setting of multiple event handlers for one event source, which would notify all handlers when the event occurs. But an event type can be set as a delegate and use the event-handling mechanism, resulting in cleaner code as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Public Class Worker Public Delegate Sub WorkDone(ByVal completedWork As Integer ) Public Handler As WorkDone Public Sub DoWork() For completedWork As Integer = 1 To 10 System.Threading.Thread.Sleep(1000) RaiseEvent WorkEvent(completedWork * 10) Console.WriteLine(completedWork) Next End Sub End Class |
Custom events in VB.NET 8.0
Custom events provide flexibility and control in creating and managing events. When using custom events, it is the responsibility of the developer to bind and unbind handlers, as well as to specify the actual calls to raise the events. Although this requires a bit more code than the earlier implementations, it provides more control over the handlers and the invocation.
A custom event is defined by using the Custom keyword in front of the event declaration, and by providing the delegate type for the event. The custom event has three sections: The AddHandler section, which is invoked whenever a handler is added using the Handles keyword or the AddHandler method; RemoveHandler section, which is called whenever a handler is removed using the RemoveHandler method; and the RaiseEvent section that will be invoked whenever an event is requested. The developer should write the necessary code in each of these sections to manage the handlers, as well as specify how handlers will be notified when an event is requested.
Below, the Worker class is implemented using the custom event construct in VB.NET 2005.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
Public Class Worker Public Delegate Sub WorkDone(ByVal completedWork As Integer ) Private handlers As New ArrayList() Public Custom Event WorkCompleted As WorkDone AddHandler (ByVal value As WorkDone) If handlers.Count <= 5 Then handlers.Add(value) End If End AddHandler RemoveHandler(ByVal value As WorkDone) handlers.Remove(value) End RemoveHandler RaiseEvent (ByVal completedWork >As Integer) If completedWork > 50 Then For Each handler As WorkDone In handlers handler.Invoke(completedWork) Next End If End RaiseEvent End Event Public Sub DoWork() For completedWork As Integer = 1 To 10 System.Threading.Thread.Sleep(1000) RaiseEvent WorkCompleted(completedWork * 10) Console.WriteLine(completedWork) Next End Sub End Class |
Using custom events enables more control over the handlers. In the above code, for example, there is a condition in the AddHandler section limiting the number of handlers for which events are provided. The RaiseEvent method has been changed to notify the handlers only when the completed Work is more than 50. Another advantage to using custom events is a central unit of code containing all of the handlers of the event within the event construct.
Using RaiseEvent twice, once in the DoWork method and then in the custom event construct, can lead to confusion. RaiseEvent in the DoWork method will raise the event, but the RaiseEvent section in the custom event construct specifies the code to be executed when the event is raised. In this case, all of the handlers are looped through and delegates are invoked.
Events and delegates are important parts of the .NET language. VB.NET 2005 gives developers control and flexibility in handling simple event models and custom events.
Load comments