What are delegates for?

Question

Possible Duplicate:
What are the advantages of delegates?

I have created a sample application. I am really finding it difficult to understand why to use delegates because without delegates we can achieve everything .

class Program
{
    public delegate double Integrand(double x);
    static double MyFunc1(double x) { return x + 10; }
    static double MyFunc2(double x) { return x + 20; }

    public static double Gauss3DelMethod(Integrand f)
    {
        double a = f(1);
        return a;
    }

    public static double Gauss3SimpleMethod(double x)
    {
        double a = x;
        return a;
    }

    static void Main(string[] args)
    {
        //with delegates
        double res = Gauss3DelMethod(MyFunc1);
        double res1 = Gauss3DelMethod(MyFunc2);

        //without delegates
        double res2 = Gauss3SimpleMethod(MyFunc1(1));
        double res3 = Gauss3SimpleMethod(MyFunc2(1));

        int i = 0;
    }
}

So, why should I use delegates?

@Ian: I think the original title reflects the attitude of the question — John Saunders, Mar 03 '12 at 09:15

Jon Skeet · Accepted Answer · 2012-03-03T09:10:01.273

In your particular example, maybe it's not important. (It's not clear what it's trying to achieve.)

But suppose you wanted to make the method execute the same MyFunc1 or MyFunc2 for several different inputs. For example, suppose you were implementing the Newton-Raphson method, to operate over a general function. In that situation, you couldn't call the function once and pass that into the method - you want to pass the actual function into the method, so that the method can call it with whatever inputs it needs.

A similar example is sorting. For example, using LINQ you can write something like:

var sorted = people.OrderBy(x => x.Age).ToList();

There we're passing a function to project each source element to the ordering key. We don't have to execute that function ourselves - OrderBy will do it for us (lazily).

Of course, all of this can be done with single-method interfaces too - delegates and single-method interfaces have a lot in common. However, delegates have the following benefits over single-method interfaces:

Delegates are multi-cast - they can be combined/removed, usually for the sake of events
You can execute them asynchronously with BeginInvoke/EndInvoke
You can build them with anonymous methods and lambda expressions
You can represent logic as data via expression trees using lambda expresions; these can then be compiled into delegates
You can build a delegate from any method with the appropriate signature - so for example a single class can have multiple methods "implementing" the same delegate type, whereas you can't implement an interface multiple times in one class
Likewise delegate implementation methods can be private, whereas interface methods have to be public (or somewhat-public via explicit interface implementation)

All of these could have been addressed differently using single-method interfaces, of course, but delegates are a handy alternative.

In conclusion: delegates are very useful. Just because you've written some trivial code which doesn't particularly require them doesn't mean they're not useful. I would strongly suggest you look into LINQ, event handlers and the TPL, all of which use delegates heavily.

thanx for ur quick response. can u give me a very basic example? — Ulhas Tuscano, Mar 03 '12 at 09:09
@UlhasTuscano: I gave you an example, in words rather than in code - and then one in LINQ, in code. But maybe as an exercise you should try to implement Newton-Raphson yourself. You'll learn more by *doing* it than just by *reading* about it. — Jon Skeet, Mar 03 '12 at 09:10

score 4 · Answer 2 · answered Mar 03 '12 at 09:08

Delegates are a useful way to pass around functions.

Func and Action are also delegates. Without them you couldn't use almost every LINQ method and, beginning from C# 3.0, you can use Lambda Expressions to create them faster.

Imagine for example you have an enumerable of integers:

var numbers = Enumerable.Range(0, 100);

By using delegates you can create higher-order functions (http://en.wikipedia.org/wiki/Higher-order_function) that can help you to filter, for example, the numbers above in several ways. Where is one of the cases.

You may want to select just odd numbers:

var odd = numbers.Where(a => a % 2 == 0);

Or even ones:

var even = numbers.Where(a => a % 2 != 0);

Without them you would have to create a method for each filter (e.g. WhereOdd or WhereEven)

What are delegates for?

2 Answers2

Linked