Delegates in C#

Delegates

A delegate dynamically wires up a method caller to its target method. There are two aspects to a delegate: type and instance. A delegate type defines a protocol to which the caller and target will conform, comprising a list of parameter types and a return type. A delegate instance is an object that refers to one (or more) target methods conforming to that protocol.

A delegate instance literally acts as a delegate for the caller: the caller invokes the delegate, and then the delegate calls the target method. This indirection decouples the caller from the target method.

A delegate type declaration is preceded by the keyword delegate, but otherwise it resembles an (abstract) method declaration.

delegate int Transformer (int x);

To create a delegate instance, you can assign a method to a delegate variable:

public class Test

{

static void Main()

{

Transformer t = Square; // Create delegate instance

int result = t(3); // Invoke delegate

Console.WriteLine (result); // 9

}

static int Square (int x) { return x * x; }

}

Invoking a delegate is just like invoking a method (since the delegate's purpose is merely to provide a level of indirection) :

t(3);

The statement:

Transformer t = Square;

is shorthand for:

Transformer t = new Transformer(Square);

and:

t(3);

is shorthand for:

t.Invoke (3);

Multicast Delegates

All delegate instances have multicast capability. This means that a delegate instance can reference not just a single target method, but also a list of target methods. The + and += operators combine delegate instances. For example:

SomeDelegate d = SomeMethod1;

d += SomeMethod2;

The last line is functionally the same as:

d = d + SomeMethod2;

Invoking d will now call both SomeMethod1 and SomeMethod2. Delegates are invoked

in the order they are added.

The - and -= operators remove the right delegate operand from the left delegate

operand. For example:

d -= SomeMethod1;

Invoking d will now cause only SomeMethod2 to be invoked.

Calling + or += on a delegate variable with a null value works, and it is equivalent to assigning the variable to a new value:

SomeDelegate d = null;

d += SomeMethod1; // Equivalent (when d is null) to d = SomeMethod1;

Similarly, calling -= on a delegate variable with a single target is equivalent to assigning

null to that variable.

If a multicast delegate has a nonvoid return type, the caller receives the return value from the last method to be invoked .