Benefits of Delegate with example

Well, as you know, delegates are the basis of events, anonymous methods and lambda expressions which would be more than enough to justify their existence.

However, they are still useful on their own in two main scenarios:

1. For passing methods as parameters to other methods.

2. For calling more than one method at a time (multi-casting).

Here's a simple example which illustrates both usages:

using System;

delegate int Mutater (int i);

class Test

{

static int Square(int i)

{

return i * i;

}

static int Cube(int i)

{

return i * i * i;

}

static int SquareRoot(int i)

{

return (int)Math.Sqrt(i);

}

static int CubeRoot(int i)

{

return (int)Math.Round(Math.Pow(i, 1.0/3.0));

}

static void Main()

{

int[] values = {1, 2, 3, 4};

PrintResults("Original values (first set)", values);

Mutater m = Square;

Mutate(values, m);

PrintResults("Squared", values);

m += SquareRoot; // now multicast

Mutate(values, m);

PrintResults("Squared, then square-rooted", values);

int[] values2 = {5, 6, 7, 8};

PrintResults("Original values (second set)", values2);

Mutater m2 = Cube;

Mutate(values2, m2);

PrintResults("Cubed", values2);

m2 += CubeRoot; // now multicast

Mutate(values2, m2);

PrintResults("Cubed, then cube-rooted", values2);

Console.ReadKey();

}

static void Mutate(int[] values, Mutater m)

{

foreach(Mutater mm in m.GetInvocationList())

{

for(int i = 0; i < values.Length; i++) values[i] = mm(values[i]);

}

static void PrintResults(string message, int[] values)

{

Console.WriteLine(message);

foreach(int value in values) Console.WriteLine("{0} ", value);

Console.WriteLine();

}

}

The output should be:

Original values (first set)

Squared

Squared, then square-rooted

Original values (second set)

Cubed

125

216

343

512

Cubed, then cube-rooted

125

216

343

512

Clearly, the use of delegates does have some performance implication compared to calling methods directly. This is because the delegate is a wrapper both for the method and the object (if any) on which it's called and so, when you call a method via a delegate, there's an extra level of indirection.

Also delegates take up memory on the heap and need to be garbage collected when they're no longer needed.

However, Microsoft have done a lot of work to minimize the impact on both performance and heap usage, so unless you're creating thousands of delegates, I don't think you need to worry much about either of these in practice.

1 Reply

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Well, as you know, delegates are the basis of events, anonymous methods and lambda expressions which would be more than enough to justify their existence.

However, they are still useful on their own in two main scenarios:

1. For passing methods as parameters to other methods.

2. For calling more than one method at a time (multi-casting).

Here's a simple example which illustrates both usages:

using System;

delegate int Mutater (int i);

class Test
{
static int Square(int i)
{
return i * i;
}

static int Cube(int i)
{
return i * i * i;
}

static int SquareRoot(int i)
{
return (int)Math.Sqrt(i);
}

static int CubeRoot(int i)
{
return (int)Math.Round(Math.Pow(i, 1.0/3.0));
}

static void Main()
{
int[] values = {1, 2, 3, 4};
PrintResults("Original values (first set)", values);

Mutater m = Square;
Mutate(values, m);
PrintResults("Squared", values);

m += SquareRoot; // now multicast
Mutate(values, m);
PrintResults("Squared, then square-rooted", values);

int[] values2 = {5, 6, 7, 8};
PrintResults("Original values (second set)", values2);

Mutater m2 = Cube;
Mutate(values2, m2);
PrintResults("Cubed", values2);

m2 += CubeRoot; // now multicast
Mutate(values2, m2);
PrintResults("Cubed, then cube-rooted", values2);

Console.ReadKey();
}

static void Mutate(int[] values, Mutater m)
{
foreach(Mutater mm in m.GetInvocationList())
{
for(int i = 0; i < values.Length; i++) values[i] = mm(values[i]);
}
}

static void PrintResults(string message, int[] values)
{
Console.WriteLine(message);
foreach(int value in values) Console.WriteLine("{0} ", value);
Console.WriteLine();
}
}

The output should be:

Original values (first set)
1
2
3
4

Squared
1
4
9
16

Squared, then square-rooted
1
4
9
16

Original values (second set)
5
6
7
8

Cubed
125
216
343
512

Cubed, then cube-rooted
125
216
343
512

Clearly, the use of delegates does have some performance implication compared to calling methods directly. This is because the delegate is a wrapper both for the method and the object (if any) on which it's called and so, when you call a method via a delegate, there's an extra level of indirection.

Also delegates take up memory on the heap and need to be garbage collected when they're no longer needed.

However, Microsoft have done a lot of work to minimize the impact on both performance and heap usage, so unless you're creating thousands of delegates, I don't think you need to worry much about either of these in practice.
0