In this post, we will see what Delegates are and how to use them.
First of all, what is a Delegate?
From Microsoft web site:
“A delegate is a type that safely encapsulates a method, similar to a function pointer in C and C++. Unlike C function pointers, delegates are object-oriented, type safe, and secure. The type of a delegate is defined by the name of the delegate”
In a nutshell, when we define a variable as a “Delegate” we can use it in order to run some methods that have the same signature defined in our Delegate.
SINGLECAST DELEGATE
We define a class called “Operations” and we add two methods called “Sum” and “Subtraction”:
1 2 3 4 5 6 7 8 9 10 11 12 | internal class Operations { public static string Sum ( int val1, int val2) { return $ "The result of {val1} + {val2} is: {val1 + val2}" ; } public static string Subtraction ( int val1, int val2) { return $ "The result of {val1} - {val2} is: {val1 - val2}" ; } } |
Now, we will use a Delegate in order to run these two methods:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | // Definition of a delegate public delegate string DelegateOperations( int val1, int val2); static void Main( string [] args) { // set the delegate with the Sum operation DelegateOperations delOperations = Operations.Sum; // invoke the delegate Console.WriteLine(delOperations(5, 6)); // set the delegate with the Subtraction operation delOperations = Operations.Subtraction; // invoke the delegate Console.WriteLine(delOperations(15, 6)); } |
If we run the code, this will be the result:

Obviously, we can use a Delegate with a void methods:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // set the delegate with the PrintSum method DelegatePrintOperations delOperations = Operations2.PrintSum; // invoke the delegate delOperations(5, 6); // set the delegate with the PrintSubtraction method delOperations = Operations2.PrintSubtraction; // invoke the delegate delOperations(15, 6); } internal class Operations2 { public static void PrintSum( int val1, int val2) { Console.WriteLine($ "The result of {val1} + {val2} is: {val1 + val2}" ); } public static void PrintSubtraction( int val1, int val2) { Console.WriteLine($ "The result of {val1} - {val2} is: {val1 - val2}" ); } } |
and we can use a Delegate with no static methods:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // create an instance of the Operations3 class var ope3 = new Operations3(); // set the delegate with the PrintSum method DelegatePrintOperations delOperations = ope3.PrintSum; // invoke the delegate delOperations(5, 6); // set the delegate with the PrintSubtraction method delOperations = ope3.PrintSubtraction; // invoke the delegate delOperations(15, 6); } internal class Operations3 { public void PrintSum( int val1, int val2) { Console.WriteLine($ "The result of {val1} + {val2} is: {val1 + val2}" ); } public void PrintSubtraction( int val1, int val2) { Console.WriteLine($ "The result of {val1} - {val2} is: {val1 - val2}" ); } } |
If we try to use a method with a different signature, we will have a compile error:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // set delegate with the Sum operations DelegateOperations delOperations = Operations.Square; ... ... ... } internal class Operations { public static string Sum ( int val1, int val2) { return $ "The result of {val1} + {val2} is: {val1 + val2}" ; } public static string Subtraction ( int val1, int val2) { return $ "The result of {val1} - {val2} is: {val1 - val2}" ; } public static string Square( int val1) { return $ "The result of {val1} squared is: {val1*val1}" ; } } |

Finally, we can pass a delegate as an input parameter in a method:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // set the delegate with the Sum operation DelegatePrintOperations delOperations = Operations2.PrintSum; // call a method passing in input the delegate PrintResult(delOperations); // set the delegate with the Sum operation delOperations = Operations2.PrintSubtraction; // call a method passing in input the delegate PrintResult(delOperations); } static void PrintResult(DelegatePrintOperations delegateOperations) { delegateOperations(15, 6); } internal class Operations2 { public static void PrintSum( int val1, int val2) { Console.WriteLine($ "The result of {val1} + {val2} is: {val1 + val2}" ); } public static void PrintSubtraction( int val1, int val2) { Console.WriteLine($ "The result of {val1} - {val2} is: {val1 - val2}" ); } } |
MULTICAST DELEGATE
A delegate that points multiple methods, is called a multicast delegate.
The “+” or “+=” operator adds a function to the invocation list, and the “-” and “-=” operator removes it.
Let’s see some examples:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // definition of two delegates DelegatePrintOperations delOperations = Operations2.PrintSum; DelegatePrintOperations delOperations2 = Operations2.PrintSubtraction; // definition of a delegate that will use both the methods // we can define finalDelOperations in this way too: // DelegatePrintOperations finalDelOperations = delOperations + delOperations2; DelegatePrintOperations finalDelOperations = delOperations; finalDelOperations += delOperations2; finalDelOperations(10, 5); } ... ... ... |
If we run the code, this will be the result:

Now, we remove a method:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | // Definition of a delegate public delegate void DelegatePrintOperations( int val1, int val2); static void Main( string [] args) { // set delegate with the Sum operation DelegatePrintOperations delOperations = Operations2.PrintSum; DelegatePrintOperations delOperations2 = Operations2.PrintSubtraction; // we can define finalDelOperations in this way too: // DelegatePrintOperations finalDelOperations = delOperations + delOperations2; DelegatePrintOperations finalDelOperations = delOperations; finalDelOperations += delOperations2; finalDelOperations(10, 5); // we remove the delOperations (Operations2.PrintSum) finalDelOperations -= delOperations; Console.WriteLine(); finalDelOperations(10,5); } ... ... ... |
If we run the code, this will be the result:

ANONYMOUS DELEGATE
We can create a delegate without declaring a method associated with it and our delegate itself contains the method definition:
1 2 3 4 5 6 7 8 9 10 11 12 13 | // Definition of a delegate public delegate int DelegateAnonymous( int val1); static void Main( string [] args) { DelegateAnonymous objDeleAnonymous = delegate ( int val1) { return val1 * val1; }; Console.WriteLine(objDeleAnonymous(5)); objDeleAnonymous = delegate ( int val1) { return val1 * val1 * val1; }; Console.WriteLine(objDeleAnonymous(5)); } |
If we run the code, this will be the result:
