C# Delegates Real World Usage [duplicate]

Answer 1

I think you are referring to defining custom delegates?

EventHandler has minimised the requirement for custom delegate definitions but they are still useful if you want to add additional parameters to the method signature.

Answer 2

Whenever you're using a Strategy Pattern or an Observer Pattern, delegates make your work much easier than using interfaces.

Answer 3

Nobody mentioned this, but if you are using LINQ with Lambda you use anonymous methods all the time. Which are technically still delegates.

Lets say you have a class called Person

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

And you wanted to implement a find method where you would find the person based on their FirstName

public Person Where(List<Person> list, string firstName)
{
   //find the string
   foreach(Person item in list)
      if(item.FirstName.Equals(firstName))
        return item;
}

This is a very specific search and not very dynamic, meaning if you wanted to search by LastName you would have to change this method or write a new one.

Luckily LINQ provides an extension method called Where to which you need to pass a delegate, which you can create on the fly with the help of anonymous methods.

for instance

string searchString = "Stan";
list.Where( person => person.FirstName.Equals(searchString));

but if you wanted to change to search by LastName you would simply do this

string searchString = "R";
list.Where( person => person.LastName.Equals(searchString));

This example might be not what you were looking for, but I just wanted to show that sometimes we use delegates all the time without thinking about it or realizing it.

Answer 4

Assuming you're not talking about events - of course you can program around it. The point is to make it nicer and cleaner.

protected void Sort()
{
    foreach (string key in _dBase.Keys)
    {
      Array.Sort<Pair<string, Dictionary<string, T>>>(_dBase[key], 
            new Comparison<Pair<string, Dictionary<string, T>>>(
        delegate(Pair<string, Dictionary<string, T>> a, Pair<string, Dictionary<string, T>> b)
        {
            if (a == null && b != null)
                return 1;
            else if (a != null && b == null)
                return -1;
            else if (a == null && b == null)
                return 0;
            else
                return a.First.CompareTo(b.First);
        }));
    }
}

Could I do that without an inline delegate? Sure. Would I have a floppy private method in my class that would only be used for this one instance? Yup.

Edit: As mentioned in the comments, you can simplify:

Array.Sort<Pair<string, Dictionary<string, T>>>(_dBase[key], 
   new Comparison<Pair<string, Dictionary<string, T>>>(
   delegate(Pair<string, Dictionary<string, T>> a, Pair<string, Dictionary<string, T>> b)
   {

to

Array.Sort<Pair<string, Dictionary<string, T>>>(_dBase[key], (a,b) =>
   {

Answer 5

One example would be a pub/sub message dispatcher. You would need to register the events with the dispatcher and then call them appropriately. This allows you to connect disparate pieces of your code quite easily. I can't think of a way to do this without using delegates