' This example demonstrates the EventHandler(Of T) delegate.
Imports System
Imports System.Collections.Generic

'---------------------------------------------------------
Public Class MyEventArgs
   Inherits EventArgs
   Private msg As String

   Public Sub New(messageData As String)
      msg = messageData
   End Sub 'New

   Public Property Message() As String
      Get
         Return msg
      End Get
      Set
         msg = value
      End Set
   End Property
End Class 'MyEventArgs 
'---------------------------------------------------------
Public Class HasEvent
   ' Declare an event of delegate type EventHandler of 
   ' MyEventArgs.
   Public Event SampleEvent As EventHandler(Of MyEventArgs)

   Public Sub DemoEvent(val As String)
      RaiseEvent SampleEvent(Me, New MyEventArgs(val))
   End Sub 'DemoEvent
End Class 'HasEvent 
'---------------------------------------------------------
Public Class Sample
   Public Shared Sub Main()
      Dim he As New HasEvent()
      AddHandler he.SampleEvent, AddressOf SampleEventHandler
      he.DemoEvent("Hey there, Bruce!")
      he.DemoEvent("How are you today?")
      he.DemoEvent("I'm pretty good.")
      he.DemoEvent("Thanks for asking!")
   End Sub 'Main

   Private Shared Sub SampleEventHandler(src As Object, _
                                         mea As MyEventArgs)
      Console.WriteLine(mea.Message)
   End Sub 'SampleEventHandler
End Class 'Sample
'---------------------------------------------------------
'
'This example produces the following results:
'
'Hey there, Bruce!
'How are you today?
'I'm pretty good.
'Thanks for asking!
'

// This example demonstrates the EventHandler<T> delegate.

using System;
using System.Collections.Generic;

//---------------------------------------------------------
public class MyEventArgs : EventArgs
{
    private string msg;

    public MyEventArgs( string messageData ) {
        msg = messageData;
    }
    public string Message { 
        get { return msg; } 
        set { msg = value; }
    }
}
//---------------------------------------------------------
public class HasEvent
{
// Declare an event of delegate type EventHandler of 
// MyEventArgs.

    public event EventHandler<MyEventArgs> SampleEvent;

    public void DemoEvent(string val)
    {
    // Copy to a temporary variable to be thread-safe.
        EventHandler<MyEventArgs> temp = SampleEvent;
        if (temp != null)
            temp(this, new MyEventArgs(val));
    }
}
//---------------------------------------------------------
public class Sample
{
    public static void Main()
    {
        HasEvent he = new HasEvent();
        he.SampleEvent += 
                   new EventHandler<MyEventArgs>(SampleEventHandler);
        he.DemoEvent("Hey there, Bruce!");
        he.DemoEvent("How are you today?");
        he.DemoEvent("I'm pretty good.");
        he.DemoEvent("Thanks for asking!");
    }
    private static void SampleEventHandler(object src, MyEventArgs mea)
    {
        Console.WriteLine(mea.Message);
    }
}
//---------------------------------------------------------
/*
This example produces the following results:

Hey there, Bruce!
How are you today?
I'm pretty good.
Thanks for asking!

*/

// This example demonstrates the EventHandler<T> delegate.

using namespace System;
using namespace System::Collections::Generic;

//---------------------------------------------------------
public ref class MyEventArgs: public EventArgs
{
private:
   String^ msg;

public:
   MyEventArgs( String^ messageData )
   { msg = messageData; }

   property String^ Message 
   {
      String^ get()
      { return msg; }

      void set( String^ value )
      { msg = value; }
   }
};

public ref class HasEvent
{
public:
   event EventHandler< MyEventArgs^ >^ SampleEvent;

   // Declare an event of delegate type EventHandler of MyEventArgs.
   void DemoEvent( String^ val )
   {
   //  The CPP compiler automatically provides threadsafe access,
   //  which allows you to raise the event directly:

       SampleEvent(this, gcnew MyEventArgs(val));
   }
};

public ref class Sample
{
public:
   static void TestHandler()
   {
      HasEvent^ he = gcnew HasEvent;
      he->SampleEvent += gcnew EventHandler< MyEventArgs^ >( SampleEventHandler );
      he->DemoEvent( L"Hey there, Bruce!" );
      he->DemoEvent( L"How are you today?" );
      he->DemoEvent( L"I'm pretty good." );
      he->DemoEvent( L"Thanks for asking!" );
   }
private:
   static void SampleEventHandler( Object^ src, MyEventArgs^ mea )
   {
      Console::WriteLine( mea->Message );
   }
};

int main() {
    Sample::TestHandler();
}

//---------------------------------------------------------
/*
This example produces the following results:

Hey there, Bruce!
How are you today?
I'm pretty good.
Thanks for asking!
*/