Part 1 of this post can be read here.

We are now about to see the different syntaxes for invoking a delegate and some c# syntactic sugar which allows you to code faster. We have the following console application.

   1: public delegate double Operation(double x, double y);

   2:  

   3: public class Program

   4: {

   5:     [STAThread]

   6:     static void Main(string[] args)

   7:     {

   8:         Operation op1 = new Operation(Division);

   9:         double result = op1.Invoke(10, 5);

  10:         

  11:         Console.WriteLine(result);

  12:         Console.ReadLine();

  13:     }

  14:     

  15:     static double Division(double x, double y) {

  16:         return x / y;

  17:     }

  18: }

Line 1 defines a delegate type called Operation with input parameters (double x, double y) and a return type of double.
On Line 8, we create an instance of this delegate and set the target to be a static method called Division (Line 15)
On Line 9, we invoke the delegate (one entry in the invocation list).
The program outputs 5 when run.

The language provides shortcuts for creating a delegate and invoking it (see line 9 and 11). Line 9 is a syntactical shortcut for creating an instance of the Delegate. The C# compiler will infer on its own what the delegate type is and produces intermediate language that creates a new instance of that delegate. Line 11 uses a a syntactical shortcut for invoking the delegate by removing the Invoke method. The compiler sees the line and generates intermediate language which invokes the delegate. When this code is compiled, the generated IL will look exactly like the IL of the compiled code above.

   1: public delegate double Operation(double x, double y);

   2:  

   3: public class Program

   4: {

   5:     [STAThread]

   6:     static void Main(string[] args)

   7:     {

   8:         //shortcut constructor syntax

   9:         Operation op1 = Division;

  10:         //shortcut invoke syntax

  11:         double result = op1(10, 2);

  12:         

  13:         Console.WriteLine(result);

  14:         Console.ReadLine();

  15:     }

  16:     

  17:     static double Division(double x, double y) {

  18:         return x / y;

  19:     }

  20: }

C# 2.0 introduced Anonymous Methods. Anonymous methods avoid the need to create a separate method that contains the same signature as the delegate type. Instead you write the method body in-line.

There is an interesting fact about Anonymous methods and closures which won’t be covered here. Use your favorite search engine ;-)

We rewrite our code to use anonymous methods (see line 9):

   1: public delegate double Operation(double x, double y);

   2:  

   3: public class Program

   4: {

   5:     [STAThread]

   6:     static void Main(string[] args)

   7:     {

   8:         //Anonymous method

   9:         Operation op1 = delegate(double x, double y) {

  10:             return x / y;

  11:         };

  12:         double result = op1(10, 2);

  13:         

  14:         Console.WriteLine(result);

  15:         Console.ReadLine();

  16:     }

  17:     

  18:     static double Division(double x, double y) {

  19:         return x / y;

  20:     }

  21: }

We could rewrite our delegate to be of a generic type like so (see line 2 and line 9). You will see why soon.

   1: //Generic delegate

   2: public delegate T Operation<T>(T x, T y);

   3:  

   4: public class Program

   5: {

   6:     [STAThread]

   7:     static void Main(string[] args)

   8:     {

   9:         Operation<double> op1 = delegate(double x, double y) {

  10:             return x / y;

  11:         };

  12:         double result = op1(10, 2);

  13:         

  14:         Console.WriteLine(result);

  15:         Console.ReadLine();

  16:     }

  17:     

  18:     static double Division(double x, double y) {

  19:         return x / y;

  20:     }

  21: }

The .NET 3.5 framework introduced a whole set of predefined delegates for us including

public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);

Our code can be modified to use this delegate instead of the one we declared. Our delegate declaration has been removed and line 7 has been changed to use the Func delegate type.

   1: public class Program

   2: {

   3:     [STAThread]

   4:     static void Main(string[] args)

   5:     {

   6:         //Func is a delegate defined in the .NET 3.5 framework

   7:         Func<double, double, double> op1 = delegate (double x, double y) {

   8:             return x / y;

   9:         };

  10:         double result = op1(10, 2);

  11:         

  12:         Console.WriteLine(result);

  13:         Console.ReadLine();

  14:     }

  15:     

  16:     static double Division(double x, double y) {

  17:         return x / y;

  18:     }

  19: }

.NET 3.5 also introduced lambda expressions. A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types. We change our code to use lambda expressions.

   1: public class Program

   2: {

   3:     [STAThread]

   4:     static void Main(string[] args)

   5:     {

   6:         //lambda expression

   7:         Func<double, double, double> op1 = (x, y) => x / y;

   8:         double result = op1(10, 2);

   9:         

  10:         Console.WriteLine(result);

  11:         Console.ReadLine();

  12:     }

  13:     

  14:     static double Division(double x, double y) {

  15:         return x / y;

  16:     }

  17: }

C# 3.0 introduced the keyword var (implicitly typed local variable) where the type of the variable is inferred based on the type of the associated initializer expression. We can rewrite our code to use var as shown below (line 7).  The implicitly typed local variable op1 is inferred to be a delegate of type Func<double, double, double> at compile time.

   1: public class Program

   2: {

   3:     [STAThread]

   4:     static void Main(string[] args)

   5:     {

   6:         //implicitly typed local variable

   7:         var op1 = (x, y) => x / y;

   8:         double result = op1(10, 2);

   9:         

  10:         Console.WriteLine(result);

  11:         Console.ReadLine();

  12:     }

  13:     

  14:     static double Division(double x, double y) {

  15:         return x / y;

  16:     }

  17: }

You have seen how we can write code in fewer lines by using a combination of the Func delegate type, implicitly typed local variables and lambda expressions.