DELEGATE

Delegates are reference types which allow indirect calls to methods. A delegate instance holds references to some number of methods, and by invoking the delegate one causes all of these methods to be called. The usefulness of delegates lies in the fact that the functions which invoke them are blind to the underlying methods they thereby cause to run (see, for instance, the discussion of events, below).
From this brief description, it can be seen that delegates are functionally rather similar to C++'s 'function pointers'. However, it is important to bear in mind two main differences. Firstly, delegates are reference types rather than value types. Secondly, some single delegates can reference multiple methods

Delegate Declaration and Instantiation

Delegates can be specified on their own in a namespace, or else can be specified within another class (the examples below all show the latter). In each case, the declaration specifies a new class, which inherits from System.MulticastDelegate.
Each delegate is limited to referencing methods of a particular kind only. The type is indicated by the delegate declaration - the input parameters and return type given in the delegate declaration must be shared by the methods its delegate instances reference. To illustrate this: a delegate specified as below can be used to refer only to methods which have a single String input and no return value:

public delegate void Print (String s);

Suppose, for instance, that a class contains the following method:

1. public void realMethod (String myString) 2. { 3.     // method code 4. }

Another method in this class could then instantiate the 'Print' delegate in the following way, so that it holds a reference to 'realMethod':

Print delegateVariable = new Print(realMethod);

We can note two important points about this example. Firstly, the unqualified method passed to the delegate constructor is implicitly recognised as a method of the instance passing it. That is, the code is equivalent to:

Print delegateVariable = new Print(this.realMethod);

We can, however, in the same way pass to the delegate constructor the methods of other class instances, or even static class methods. In the case of the former, the instance must exist at the time the method reference is passed. In the case of the latter (exemplified below), the class need never be instantiated.

Print delegateVariable = new Print(ExampleClass.exampleMethod);

The second thing to note about the example is that all delegates can be constructed in this fashion, to create a delegate instance which refers to a single method. However, as we noted before, some delegates - termed 'multicast delegates' - can simultaneously reference multiple methods. These delegates must - like our Print delegate - specify a 'void' return type.
One manipulates the references of multicast delegates by using addition and subtraction operators (although delegates are in fact immutable reference types ) The following code gives some examples:

1. Print s = null; 2. s = s + new Print (realMethod); 3. s += new Print (otherRealMethod);

The - and -= operators are used in the same way to remove method references from a delegate.
The following code gives an example of the use of delegates. In the Main method, the Print delegate is instantiated twice, taking different methods. These Print delegates are then passed to the Display method, which by invoking the Print delegate causes the method it holds to run. As an exercise, you could try rewriting the code to make Print a multicast delegate.

1. using System; 2. using System.IO; 3. 4. public class DelegateTest 5. { 6.     public delegate void Print (String s); 7. 8.     public static void Main() 9.     { 10.         Print s = new Print (toConsole); 11.         Print v = new Print (toFile); 12.         Display (s); 13.         Display (v); 14.     } 15. 16.     public static void toConsole (String str) 17.     { 18.         Console.WriteLine(str); 19.     } 20. 21.     public static void toFile (String s) 22.     { 23.         StreamWriter fileOut = File.CreateText("fred.txt"); 24.         fileOut.WriteLine(s); 25.         fileOut.Flush(); 26.         fileOut.Close(); 27.     } 28. 29.     public static void Display(Print pMethod) 30.     { 31.         pMethod("This should be displayed in the console"); 32.     } 33. }