How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)

How to: Publish Events that Conform...

Switch on low bandwidth view

Collapse All

Language Filter

This page is specific to

Microsoft Visual Studio 2008/.NET Framework 3.5

Other versions are also available for the following:

C# Programming Guide

How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)

The following procedure demonstrates how to add events that follow the standard .NET Framework pattern to your own classes and structs. All events in the .NET Framework class library are based on the EventHandler delegate, which is defined as follows:

public delegate void EventHandler(object sender, EventArgs e);

Note:
The .NET Framework 2.0 introduces a generic version of this delegate, EventHandler<(Of <(TEventArgs>)>). The following examples show how to use both versions.

Although events in classes that you define can be based on any valid delegate type, even delegates that return a value, it is generally recommended that you base your events on the .NET Framework pattern by using EventHandler, as shown in the following example.

To publish events based on the EventHandler pattern

(Skip this step and go to Step 3a if you do not have to send custom data with your event.) Declare your class at a scope visible to both your publisher and subscriber classes, and add the required members to hold your custom event data. In this example, a simple string is returned.
```
public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        msg = s;
    }
    private string msg;
    public string Message
    {
        get { return msg; }
    } 
}
```
(Skip this step if you are using the generic version of EventHandler<(Of <(TEventArgs>)>) .) Declare a delegate in your publishing class. Give it a name that ends with EventHandler. The second parameter specifies your custom EventArgs type.
```
public delegate void CustomEventHandler(object sender, CustomEventArgs a);
```
Declare the event in your publishing class by using one of the following steps.
1. If you have no custom EventArgs class, your Event type will be the non-generic EventHandler delegate. You do not have to declare it because it is already declared in the System namespace which is included when you create your C# project:
```
public event EventHandler RaiseCustomEvent;
```
2. If you are using the non-generic version of EventHandler and you have a custom class derived from EventArgs, declare your event inside your publishing class and use your delegate as the type:
```
class Publisher
{
    public event CustomEventHandler RaiseCustomEvent;
}
```
3. If you are using the generic version, you do not need a custom delegate. Instead, you specify your event type as EventHandler<CustomEventArgs>, substituting the name of your own class between the angle brackets.
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Example

The following example demonstrates the previous steps given by using a custom EventArgs class and EventHandler<(Of <(TEventArgs>)>) as the event type.

namespace DotNetEvents
{
    using System;
    using System.Collections.Generic;

    // Define a class to hold custom event info
    public class CustomEventArgs : EventArgs
    {
        public CustomEventArgs(string s)
        {
            message = s;
        }
        private string message;

        public string Message
        {
            get { return message; }
            set { message = value; }
        }
    }

    // Class that publishes an event
    class Publisher
    {

        // Declare the event using EventHandler<T>
        public event EventHandler<CustomEventArgs> RaiseCustomEvent;

        public void DoSomething()
        {
            // Write some code that does something useful here
            // then raise the event. You can also raise an event
            // before you execute a block of code.
            OnRaiseCustomEvent(new CustomEventArgs("Did something"));

        }

        // Wrap event invocations inside a protected virtual method
        // to allow derived classes to override the event invocation behavior
        protected virtual void OnRaiseCustomEvent(CustomEventArgs e)
        {
            // Make a temporary copy of the event to avoid possibility of
            // a race condition if the last subscriber unsubscribes
            // immediately after the null check and before the event is raised.
            EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

            // Event will be null if there are no subscribers
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += String.Format(" at {0}", DateTime.Now.ToString());

                // Use the () operator to raise the event.
                handler(this, e);
            }
        }
    }

    //Class that subscribes to an event
    class Subscriber
    {
        private string id;
        public Subscriber(string ID, Publisher pub)
        {
            id = ID;
            // Subscribe to the event using C# 2.0 syntax
            pub.RaiseCustomEvent += HandleCustomEvent;
        }

        // Define what actions to take when the event is raised.
        void HandleCustomEvent(object sender, CustomEventArgs e)
        {
            Console.WriteLine(id + " received this message: {0}", e.Message);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            Subscriber sub1 = new Subscriber("sub1", pub);
            Subscriber sub2 = new Subscriber("sub2", pub);

            // Call the method that raises the event.
            pub.DoSomething();

            // Keep the console window open
            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();

        }
    }
}

Concepts

C# Programming Guide

Event Design

Reference

Events (C# Programming Guide)

Delegates (C# Programming Guide)

Delegate