The Evolution of Delegates from .Net 1.1 to .Net 3.5

In .Net 1.1, delegates were initialized by mapping them to explicit method names which are already defined. To more about delegates refer to the post Delegates in C#.

In .Net 2.0, Anonymous methods helped us to define the methods while initializing the delegates. To more about Anonymous Methods refer to the post Anonymous Methods.

In .Net 3.0 Lambda expressions further simplify delegate programming by adding expression based syntax. To more about Lambda Expressions refer to the post Lamba Expressions.

Let us understand Delegate programming in various versions of .net with an example.  

First let us declare a Delegate, this syntax remains the same in all the versions.

delegate int AddNumberDelegate(int Number1, int Number2);

Now let us initialize the delegate, and invoke the delegate

Delegates in .Net 1.1
In .Net 1.1 to initialize this delegate, we need to declare a function which will match the signature of the delegate, and later assign the function while initializing the delegate as follows.

To more about delegates refer to the post Delegates in C#.

First let us declare a function with the same signature of the Delegate.

private int AddNumber(int Number1, int Number2)

{

    return Number1 + Number2;

}

Now we shall initialize the delegate by mapping it to the above function.

// Delegates in .Net 1.1

// Delegate Initialization

AddNumberDelegate Delegate_v1 = new AddNumberDelegate(AddNumber);

// Delegate Call

Response.Write(".Net 1.1 Delegate: " + Delegate_v1(1, 2));

Delegates in .Net 2.0 (Anonymous Methods)

In .Net 2.0, we can define the delegate body along with the delegate initialization, using Anonymous methods. As you could see, there is no need to define an explicit method; the function body is in line with the delegate initialization.

To more about Anonymous Methods refer to the post Anonymous Methods.

// Delegates in .Net 2.0

AddNumberDelegate Delegate_v2 = delegate(int Number1, int Number2)

                                {

                                    return Number1 + Number2;

                                };

// Delegate Call

Response.Write(".Net 2.0 Delegate: " + Delegate_v2(1, 2));

Delegates in .Net 3.0 (Lambda Expressions)
.Net 3.0, further simplifies delegate initialization, it uses symbolic representation using the Lambda Expression =>.  To more about Lambda Expressions refer to the post Lamba Expressions.

//

// Delegates in .Net 3.0

AddNumberDelegate Delegate_v3 = (Number1, Number2) => Number1 + Number2;

// Delegate Call

Response.Write(".Net 3.0 Delegate : " + Delegate_v3(1, 2));

Response.Write("
");

As you could see, the number of lines of code requires to do delegate programming is coming down with the improvements in the .Net Framework versions

All the three versions produce the same output

.Net 1.1 Delegate: 3
.Net 2.0 Delegate: 3
.Net 3.0 Delegate: 3

That’s it, we have seen the evolution of Delegate programming across various version of the .Net Framework.

Anonymous Methods in .Net 2.0

As the name suggests Anonymous methods are the ones which do not have a specific name, but they do have a body, the body is in line with the method.

Anonymous methods can be seen as version 2.0 of Delegate, earlier in .Net 1.1, delegates were initialized by mapping them to explicit method names which are already defined, Anonymous methods helps us to define the methods while initializing the delegates.

Let us understand Anonymous methods with an example.

Anonymous Functions in .Net

As the name suggests Anonymous Functions are the ones which do not have a specific function name, but they do have a function body, the function body is in line with the function, the functions are not declared and called separately, instead they are created and used at a single stretch.

Anonymous functions can be seen as the next version of Delegate programming, earlier in .Net 1.1, delegates were initialized by mapping them to explicit method names which are already defined, the introduction of Anonymous functions helps us to define the method mapped to the delegate to be defined while initializing the delegate. We shall see how this is achieved in the posts and .