This documentation is archived and is not being maintained.

1.7.5 Events

Visual Studio .NET 2003

An event is a member that enables an object or class to provide notifications. A class defines an event by providing an event declaration (which resembles a field declaration) though with an added event keyword, and an optional set of event accessors. The type of this declaration must be a delegate type.

An instance of a delegate type encapsulates one or more callable entities. For instance methods, a callable entity consists of an instance and a method on that instance. For static methods, a callable entity consists of just a method. Invoking a delegate instance with an appropriate set of arguments causes each of the delegate instance's callable entities to be invoked with the given set of arguments. '

In the example

public delegate void EventHandler(object sender, System.EventArgs e);
public class Button 
{
   public event EventHandler Click;
   public void Reset() {
      Click = null;
   }
}

the Button class defines a Click event of type EventHandler. Inside the Button class, the Click member is exactly like a private field of type EventHandler. However, outside the Button class, the Click member can only be used on the left-hand side of the += and -= operators. The += operator adds a handler for the event, and the -= operator removes a handler for the event. The example

using System;
public class Form1 
{
   public Form1() {
      // Add Button1_Click as an event handler for Button1's Click event
      Button1.Click += new EventHandler(Button1_Click);
   }
   Button Button1 = new Button();
   void Button1_Click(object sender, EventArgs e) {
      Console.WriteLine("Button1 was clicked!");
   }
   public void Disconnect() {
      Button1.Click -= new EventHandler(Button1_Click);
   }
}

shows a Form1 class that adds Button1_Click as an event handler for Button1's Click event. In the Disconnect method, that event handler is removed.

For a simple event declaration such as

public event EventHandler Click;

the compiler automatically provides the implementation underlying the += and -= operators.

An implementer who wants more control can get it by explicitly providing add and remove accessors. For example, the Button class could be rewritten as follows:

public class Button 
{
      private EventHandler handler;
      public event EventHandler Click {
         add { handler += value; }
         remove { handler -= value; }
      }
}

This change has no effect on client code, but allows the Button class more implementation flexibility. For example, the event handler for Click need not be represented by a field.

Show: