Delegates in C#

Delegates are reference types, which allow indirect calls to methods. Delegates are similar to function pointers C++, but delegates are reference types rather than value types and some single delegates can reference multiple methods. Delegates can encapsulate both static methods of a class as well as instance methods. Delegates are called single-cast delegates when they encapsulate a single method, and are called multi-cast delegates when they encapsulate more than one method. Multi-cast delegates are useful as event-handlers.

Declaring delegates: use the delegate keyword. There is no difference in the manner of declaration between single-cast and multi-cast delegates.
public delegate String MyDelegate();

Delegate Constructor: The constructor takes two arguments, where the first argument is the object whose method we are binding to the delegate and the second argument is the address of the method. For static methods we don't need to pass the first argument.

For a single-cast delegate we use the default delegate constructor
MyDelegate oFirstDelegate = new MyDelegate (t1.TestAbc); //instance method
MyDelegate oSecondDelegate = new MyDelegate (Test.TestAbc); //static method

For multi-cast delegates + and += operators has been overloaded in C# and adding a delegate to another delegate is done simply by using the + operator on any number of delegates. Similiarly for removing C# is using - and -=
oFirstDelegate = oSecondDelegate + new MyDelegate (Test.TestAbc); //using the + operator
oFirstDelegate += new MyDelegate (Test.TestAbc); //using the += operator

Sample rogram #1
In this program we will declare a single cast delegate. Our delegated is void and takes a String as argument. We'll assign an instance method of an object to the delegate and then invoke the delegate. Then we'll assign a static method of a class to the same delegate object and again invoke the delegate.

using System;
namespace Delegates
{
public class DelegateTest
{
public DelegateTest(){}
public delegate void delgTest(string sText);
public static void StaticMethod(string sText)
{ Console.WriteLine(sText); }
public void InstanceMethod(string sText)
{ Console.WriteLine(sText); }
public static void Main()
{
delgTest oDelegate = new delgTest(StaticMethod);
ShowInConsole(oDelegate);
oDelegate = new delgTest(new DelegateTest().InstanceMethod);
ShowInConsole(oDelegate);
}
public static void ShowInConsole(delgTest oDelegate)
{ oDelegate("Displayed in the Console"); }
}
}

Sample Program #2

In the example we are using a multi-cast delegate. Our delegate takes zero arguments and returns void. We'll first create two single-cast delegates, one based on an instance method and the other one based on a static method. Then we'll create our multi-cast delegate by combining the two delegates and invoke our multi-cast delegate. Now we remove one of the delegates from our multi-cast delegate and again invoke it.

public class MultiCastDelegateTest
{
public MultiCastDelegateTest(){}
public delegate void delgTest();
public static void StaticMethod()
{ Console.WriteLine("Static Method"); }
public void InstanceMethod()
{ Console.WriteLine("Instance Method"); }
public static void Main()
{
delgTest oDelegate1 = new delgTest(StaticMethod);
delgTest oDelegate2 = new delgTest(new MultiCastDelegateTest().InstanceMethod);
oDelegate1 += oDelegate2;
oDelegate1(); // Invoking Delegate
oDelegate1 -= oDelegate2;
oDelegate1();
}
}