Delegates vs Interfaces in C#

Question

I would like to pose this question as long as I am trying currently to dig into the use and the purpose of delegates, although it is likely to have been asked in similar formulations.

I know that delegates serve as function pointers used in C++. The matter of the fact is if in C# they serve mostly as an alternative to interfaces and polymorphism. Since I can create subclasses of a specific class and supply them the appropriate methods to each one, what offer delegates additionally to that? Are there cases that stipulate their use or is merely the maintainability of the code improved when delegates used? Would you recommend their wide deployment over interfaces?

I am speaking solely about delegates and I want to distinguish their role from the events role.

Answer 1

Yes, delegates are in many ways like single-method interfaces. However:

• There is support built into the CLR for them
• There's support in the framework for them, including multi-cast abilities and asynchronous invocation
• There's additional C#/VB language support in the form of method group conversions, lambda expressions, anonymous methods
• They're mandated for events (i.e. events and delegates are a sort of matching pair)
• They mean you don't need to implement an interface in a separate class for each delegate instance you want to create.

The last point is the most important one - consider a LINQ expression of:

var query = collection.Where(x => x > 5)                       .Select(x => x * x); 

Now imagine if to express the logic of x > 5 and x * x you had to write a separate class for each expression, and implement an interface: the amount of cruft vs useful code would be ridiculous. Now of course the language could have been designed to allow conversions from lambda expressions into interface implementations via separate classes, but then you'd still lose the benefit of being able to simply write a separate method and create a delegate with that as the target. You'd also still lose the multi-cast abilities.

As a similar thought exercsise, consider looping statements such as while and for. Do we really need them when we've got goto? Nope. But life is much better with them. The same is true of delegates - and indeed properties, events, etc. They all make the development simpler.

Answer 2

The biggest practical difference is that you can provide different delegate instances for the same delegate from the same class, while you cannot do it with interfaces.

delegate void XYZ(int p);  interface IXyz {     void doit(int p); }  class One {     // All four methods below can be used to implement the XYZ delegate     void XYZ1(int p) {...}     void XYZ2(int p) {...}     void XYZ3(int p) {...}     void XYZ4(int p) {...} }  class Two : IXyz {     public void doit(int p) {         // Only this method could be used to call an implementation through an interface     } }