Please Explain .NET Delegates

Question

So I read MSDN and Stack Overflow. I understand what the Action Delegate does in general but it is not clicking no matter how many examples I do. In general, the same goes for the idea of delegates. So here is my question. When you have a function like this:

public GetCustomers(Action<IEnumerable<Customer>,Exception> callBack)
{
}

What is this, and what should I pass to it?

Answer 1

They confused the hell out of me until I read:

1. Andrew Troelsen's explanation of them in Pro C# 2008 and the .Net 3.5 Platform
2. The chapter on the Observer pattern in Head First Design Patterns

That second book is about java, and doesn't mention delegates, but it explains well a problem delegates help solve: communication between classes.

Answer 2

A delegate is a class that points to one or more functions. A delegate instance can be invoked, which will call the function(s) that it points to.

In your case, the GetCustomers function takes a second function as a parameter.

The second function must take two parameters of type IEnumerable<Customer> and Exception.

To call GetCustomers, you need to make a second function for it to call, then pass it a delegate containing the second function.

For example:

static void GetCustomersCallback(IEnumerable<Customer> customers, Exception ex) {
    //Do something...
}

//Elsewhere:
GetCustomers(new Action<IEnumerable<Customer>,Exception>(GetCustomersCallback));

This call creates a new delegate instance that points to the GetCustomersCallback function, and passes that delegate to the GetCustomers function. GetCustomers will presumably call the callback after the customers finish loading, and will pass the loaded customers as a parameter.
You can also leave out the delegate instantiation and pass the function directly:

GetCustomers(GetCustomersCallback);

Answer 3

it expects a function that takes IEnumerable and Exception and returns void.

void SendExceptionToCustomers(IEnumerable<Customer> customers, Exception ex) {
   foreach(var customer in customers)
      customer.SendMessage(ex.Message);
}

GetCustomers(SendExceptionToCustomers);

btw, GetCustomers seems like a terrible name for this function -- it's asking for an action, so its more like DoSomethingToCustomers

EDIT in response to comment

---

Ok Makes sense, So now why even bother with having a GetCustomer Function? Can't I do that same thing with your function if i Just rename it GetCustomer?

Well, what's happening here is the caller can specify some action. Suppose GetCustomers is implemented like this:

public void GetCustomers(Action<Enumerable<Customer>, Exception> handleError) {
    Customer[] customerlist =  GetCustomersFromDatabase();
    try {
        foreach(var c in customerList) 
            c.ProcessSomething()
    } catch (Exception e) {
        handleError(customerList, e);
    }
}

then you could call Getcustomers from somewhere on a commandline program, and pass it

GetCustomers((list, exception) => { 
    Console.WriteLine("Encountered error processing the following customers");
    foreach(var customer in list) Console.WriteLine(customer.Name);
    Console.WriteLine(exception.Message);
}); 

while you could call GetCustomers from a remote application, for example, and pass it

Getcustomers((list, exception) => { 
    // code that emails me the exception message and customer list
})

---

Also, Slak's comment suggests another reason for delegate parameter -- GetCustomers does retrieve the customers, but asynchronously. Whenever it is done retrieving the customers, it calls the function you give it with either the customerlist or an exception, if an exception occurred.

Answer 4

Simply? Function pointers

Answer 5

Refer link for details on DotNet delegates and events: http://www.codeproject.com/KB/cs/Delegate_To_Event_in_CS.aspx

Answer 6

You would pass it a void method that takes an IEnumerable and an Exception as parameters...

Say you have this method:

public void DoSomeStuffWithCustomers(
  IEnumerable<Customer> customers, Exception exception)
{     
}

You would call the GetCustomers method like this:

GetCustomers(DoSomeStuffWithCustomers);