C# Delegates - How Often Do You Use Them, And When?

Question

Delegates look like such a powerful language feature, but I've yet to find an opportunity to use them in anger (apart from in DALs I must say).

How often do you use them, and under what circumstances do you find them most useful?

Answer 1

I use them the most for callbacks. Instead of objects for callback methods (using interfaces), I can wrap a method in a delegate and pass that on.

Answer 2

I use them for event handlers, callbacks, and predicates to name a few. If you've programmed in C++, you can think of them as function pointers and I think some of their uses become immediately apparent.

Answer 3

I use C# Delegate the most of time with Event.

public delegate void MyDelegate(object sender, EventArgs e, string otherParameterIWant);
//...Inside the class
public event MyDelegate myEvent;
//...Inside a method
if (myEvent != null)
 myEvent(this, new EventArgs(), "Test for SO");

Answer 4

Events, Predicate Searches, Sometimes inline functionality.. they come in useful in a ton of scenarious..

List.ForEach(delegate...)

Answer 5

Well, with lambda expression added in C#3, they become much easier to use, as the messy parts are hidden.

myList.Sort(a=> a.LastName);

Answer 6

I especially like delegates when you have to change out one thing in the middle of boilerplate code:

public delegate bool ItemFilterDelegate(MyItem item);

public IEnumerable<MyItem> FilterItems(ItemFilterDelegate filter)
{
    var result = new List<MyItem>();

    foreach(MyItem item in AllItems)
    {
        if(filter(item))
            result.Add(item);
    }

    return item;
}    

public IEnumerable<MyItem> FilterByName(string name)
{
    return FilterItems(item => item.Name == name);
}

They are ALSO used heavily in this way with LINQ.

Answer 7

Funcs and Actions are newish "types" of delegates and I use them a lot with Linq and really other odd situations. For Linq they are nice because personally I'd rather have a descriptive name than a lambda expression:

someList.Select(item => item.Name);

Where with a Func I can:

Func<Item, String> itemName = item => item.Name;
...
someList.Select(itemName);

It might be a line more, but there are times where I find myself repeating a certain lambda expressions a couple times in a class, so personally I think Funcs work well for that.

Another situation is a, for lack of a better term, Method Factory. Basically it is a dictionary that holds a list of Actions as the value and say an Enum as the key:

Dictionary<UserType, Action<User>> showControls;
showControls = new Dictionary<UserType, Action<User>>();

showControls.Add(SomeEnum.Admin, setControlsForAdmin);
showControls.Add(SomeEnum.Normal, setControlsForNormalUser);
showControls.Add(SomeEnum.Unregistered, setControlsForUnregisteredUser);

And then I have the methods themselves written out somewhere else on the page. And use would be:

showControls[user.UserType]();

Or maybe you want to pass the method itself to another:

Action<User> neededMethod;

neededMethod = showControls[user.UserType];

SomeMethod(neededMethod);

I'm sure there are much better uses for delegates, but these are useful.

Answer 8

I used to use them all the time as Daok says for events, until I learned that you can use built-in handlers for most common events (common for what I do, at least). Now I usually use them as callback handlers for API interaction.

Answer 9

I have written this article, maybe that'll help : http://www.codeproject.com/KB/cs/Cs_delegates101_practical.aspx