GetInvocationList of an event in VB.NET

Question

I am trying to learn some WCF principles by following an example of a WCF application (from Sacha Barber).

Now I would like to convert the following function into VB.NET

private void BroadcastMessage(ChatEventArgs e)
{

    ChatEventHandler temp = ChatEvent;

    if (temp != null)
    {
        foreach (ChatEventHandler handler in temp.GetInvocationList())
        {
            handler.BeginInvoke(this, e, new AsyncCallback(EndAsync), null);
        }
    }
}

but I have some problems, because the following code is not accepted by the compiler

Private Sub BroadcastMessage(ByVal e As ChatEventArgs)

    Dim handlers As EventHandler(Of ChatEventArgs) = ChatEvent

    If handlers IsNot Nothing Then

        For Each handler As EventHandler(Of ChatEventArgs) In handlers.GetInvocationList()

            handler.BeginInvoke(Me, e, New AsyncCallback(AddressOf EndAsync), Nothing)

        Next

    End If

End Sub

it says

Public Shared Event ChatEvent(sender As Object, e As ChatEventArgs)' is an event, and cannot be called directly

Coming to the point, is it then possible in VB.NET get the handlers linked to a certain event in some other way?

Answer 1

use ChatEventEvent (or EventNameEvent)

It won't show up in intellisense, but the members of it will.

VB.NET creates a variable behind the scenes, to hide the complexity from the coder...

This is only available in the class that declares the event (or perhaps its descendants)

Answer 2

You're likely trying to write this code in a class that is a descendant of the class that declares the ChatEvent event. This can't be done, as events can only be treated as variables (including invoking them) in the class that declares them. This is because the event keyword actually indicates to the compiler that it needs to perform some behind-the-scenes transformations.

What Happens

Consider this declaration:

Public Event MyEvent as EventHandler

Simple enough, right? What this actually does, however, is this (you just don't see it)

Private compilerGeneratedName as EventHandler

Public Event MyEvent as EventHandler
    AddHandler(ByVal value as EventHandler)
        compilerGeneratedName += value
    End AddHandler
    RemoveHandler(ByVal value as EventHandler)
        compilerGeneratedName -= value
    End RemoveHandler
    RaiseEvent(ByVal sender as Object, ByVal e as EventArgs)
        compilerGeneratedName.Invoke(sender, e)
    End RaiseEvent
End Event

And when you invoke the event:

RaiseEvent MyEvent(Me, EventArgs.Emtpy)

It actually calls the code in the RaiseEvent block.

Edit

If events in VB.NET can't be treated as variables anywhere (they can be treated as variables in the declaring class in C#, which is why your C# example compiles), then you'll have to explicitly implement the event yourself. See the MSDN page on the Event statement for more information on how to do that. To make a long story short, you're going to want some way to store multiple event handlers (or use a single event handler along with GetInvocationList, as you're trying to do now). In your AddHandler and RemoveHandler code blocks you'll add to and remove from the list of event handlers (respectively).

You could use something like this:

Private myEventList as New List(Of EventHandler)

Public Custom Event MyEvent as EventHandler
    AddHandler(ByVal value as EventHandler)
        myEventList.Add(value)
    End AddHandler
    RemoveHandler(ByVal value as EventHandler)
        myEventList.Remove(value)
    End RemoveHandler
    RaiseEvent(ByVal sender as Object, ByVal e as EventArgs)
        For Each evt in myEventList
           evt.BeginInvoke(sender, e, New AsyncCallback(AddressOf EndAsync), Nothing)
        Next
    EndRaiseEvent
End Event

So now, if you call

RaiseEvent MyEvent(Me, EventArgs.Emtpy)

It will raise the event in the fashion you're expecting.