C# Delegates are Just Interfaces with one method
Functional patterns
I remember a decade ago when i was trying to understand why .net has delegates. A Delegate is just a function signature that has a Name. In this brief article i hope to help you intuitively be able to grasp that delegates are the same as interfaces with one method.
just for reference i will use the simple case of a strategy pattern. (i would use the wikipedia but is just lame). So lets say we have a OperationManager
record defintion that takes an IOperation<T, R>
as constructor argument and calls it inside the
the IOperation<T, R>
has only one method
now we can create a dummy concrete IOperation<T, R>
public class ConcreteOperation : IOperation<int, string>
{
public async Task<string> OperationAsync(int t) => t.ToString();
}
and we can use this to instantiate an OperationManager
var manager = new OperationManager<int,string>(new ConcreteOperation());var result = manager.ExecuteActivity(1);
Replacing Interface with a delegate
Now the following delegate is equivalent to the interface
public delegate Task<R> Operation<T, R>(T t);
we can refactor the whole thing as follows.
Using Build in Delegates
if you don’t even want to define a delegate you can use the Func<T,R>
and just refactor everything to this :
Summary
you can convince yourself that you can use delegate as interface in all possible situations. for example look at this extension method applied on the delegate as a decorator:
cool right, attaching behaviour to methods. C# has so many functional features.(hint:Also a tuple of delegates is equivalent to an object)