委托是个说烂了的话题，但是依旧有好多人不知道为什么要在C#中使用委托，最近有朋友也问到我这个问题，所以举例些场景，以供那些知道怎么声明委托、怎么调用却不知道为什么要用的朋友一些参考，当然也是希望验证下自己的理解是否正确。
如何声明一个委托
委托使用关键字delegate，从外形上看和一个没有方法体的方法一样，只不过是多了个关键字。
public delegate void MyDelegateHandler();//无返回值，无参数
public delegate int MyDelegateHandler1();//有返回值，无参数
public delegate object MyDelegateHandler2(string name);//有返回值，有参数
public delegate object MyDelegateHandler3(object first,ref int second,out float third, params object[] args);//有返回值，多个返回值
委托的声明可以放在类的外面，也可以在类的内部
public delegate object MyDelegateHandler2(string name);//有返回值，有参数
static class Program
{
public delegate void MyDelegateHandler();//无返回值，无参数
}
C#内置的委托类型
在.NET Framework中定义了大量的委托类型，像什么WaitCallback、ParameterizedThreadStart、EventHandler、...，为了兼容旧版本所以一直没去掉，从.NET Framework 3.5后你可以使用Action、和Func（带返回值）来更简单的使用委托，他们都定义了大量的重载版本
委托的使用
下面是流年写的一个计算器类（比较简陋），里面有各种运算方法，每个方法只干一件事，恩，满足了单一原则，棒棒的！
public class Calculator
{
public static int Add(int first, int second)
{
return first + second;
}
public static int Sub(int first, int second)
{
return first - second;
}
}
流年很简单的就使用了这个类里的方法，哇，毫无压力
var result = Calculator.Add(1, 6);
现在问题来了“在做运算前，需要去验证每个参数（假设这里希望使用的参数都是正整数）”，╮(╯▽╰)╭每个方法都需要去加一段代码
public static int Add(int first, int second)
{
if (first <= 0 || second <= 0)
{
throw new ArgumentException("参数错误");
}
return first + second;
}
一个方法一个方法的去改，很是麻烦，干脆我把计算直接写一个方法里，三下五除二，流年开始啪，啪，啪...
public static int Calc(int first, int second, string operater)
{
if (first <= 0 || second <= 0)
{
throw new ArgumentException("参数错误");
}
int result = 0;
if (operater.Equals("+"))
{
result = first + second;
}
if (operater.Equals("-"))
{
result = first - second;
}
return result;
}
OK,搞定，很简单嘛，但仔细一看，我靠Calc计算方法中干了那么多事情，又是加又是减的，如果计算器类还要添加对乘法的支持，还需要再修改这个方法，代码耦合度太高了，这不就违背了对扩展开放，对修改关闭的原则了嘛。就在这时，天空乌云密布，一道闪电击中了流年的脑袋...
首先我们来看，这段代码的变化点是什么？运算方法嘛
有什么办法可以隔离这种变化呢?委托嘛
public static int Calc(int first, int second, Func<int, int, int> handler)
{
if (first <= 0 || second <= 0)
{
throw new ArgumentException("参数错误");
}
return handler.Invoke(first, second);//更简单的写法handler(first, second)
}
Func<int, int, int> calcHandler = new Func<int, int, int>(Calculator.Add);
var result = Calculator.Calc(1, 6, calcHandler);
这样不用去改变原来的方法，Add还是Add，减法运算还是减法运算，就算再添加乘/除算法，直接添加加乘/除算法相关的方法就行，也不用去改动原来的代码了。而且算法选择逻辑也是交给的客户端，而不是方法内部。将变化隔离了出去。
更简单的使用委托
上面的委托实例声明好麻烦，那我们再改进改进，可以将方法直接赋值给委托实例
Func<int, int, int> calcHandler = Calculator.Add;
var result = Calculator.Calc(1, 6, calcHandler);
再改进改进,直接将方法当做实参传递
var result = Calculator.Calc(1, 6, Calculator.Add);
此刻，有没有一种想把委托按在床上的冲动。不要着急，这还只是前戏...
Lambda表达式
在上面我们提到可以将一个方法直接赋值给实例，那么是不是直接就可以将匿名方法直接赋值给委托实例呢？废话不说，直接试试就知道了
Func<int, int, int> calcHandler = delegate (int first, int second)
{
return first - second;
};
var result = Calculator.Calc(1, 6, calcHandler);
这就完了？当然没有，让我们继续挑逗匿名方法
既然说，calcHandler 实例的引用是指向匿名方法的，那么是不是可以直接将匿名方法直接渗入Calculator.Calc方法的参数中
var result = Calculator.Calc(1, 6,delegate (int x, int y){return x - y;});
基于匿名函数，从Visual Studio 2010开始，微软将匿名函数又升级成了Lambda表达式，代码是越来越简洁，连TMD方法都不用创建了，直接将算法写在调用上。
var result = Calculator.Calc(1, 6, (a, b) => a * b);
而且为了方便对集合类型的操作，微软还封装了大量的Linq扩展方法，这些都是基于委托实现的
int[] numbers = { 11, 4, 3, 89, 5, 10 };
//获取集合中大于10的数字
var query = numbers.Where(w => w > 10);
提供异步调用
还是回到原来的代码，Calculator类中委托调用的地方handler.Invoke(first, second)，如果说委托实例对应的方法是个耗时的操作，我想我们谁也不想直接同步调用，让程序傻傻的死在那里,至少给用户一些提示。为了处理这种问题，我们可以直接使用委托的异步调用
public class Calculator
{
public static int Add(int first, int second)
{
Console.WriteLine($"Add Thread Id {Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(500);//模拟耗时的操作
return first + second;
}
public static int Sub(int first, int second)
{
return first - second;
}
public static int Calc(int first, int second, Func<int, int, int> handler)
{
Console.WriteLine($"Calc Thread Id {Thread.CurrentThread.ManagedThreadId}");
if (first <= 0 || second <= 0)
{
throw new ArgumentException("参数错误");
}
var ir = handler.BeginInvoke(first, second, null, null);
Console.WriteLine("还在计算当中...");
//等待计算结果
return handler.EndInvoke(ir);
}
}
最后一行代码handler.EndInvoke(ir)，作用是等待异步调用返回结果。他会一直阻塞线程直到异步调用完成，然后返回计算的结果值。
委托异步调用方法的返回值为一个IAsyncResult接口，我们可以通过该接口的实例属性IsCompleted轮询判断异步是否调用完成。
在异步调用的方法参数中，有一个委托类型AsyncCallback，我们可以将一个函数传给他，异步方法执行完的时候会自动的去调用这个方法，这也就是所谓的回调函数。在回调函数中我们就可以干些别的事情，比如定义个事件将结果传递出去
//定义一个计算完成事件
public static event Action<int> OnCalcCompelted;
var ir = handler.BeginInvoke(first, second,
(o) =>
{
var result = handler.EndInvoke(o);
//通过事件通知注册用户计算已经完成，并将结果传递出去
if (OnCalcCompelted!=null)
{
OnCalcCompelted(result);
}
},
null);
Console.WriteLine("还在计算当中...");
结语：
方法与委托就好比普通类与接口（抽象类）的关系。
编码过程中委托并不一定是强制使用，他只不过是一种实现方式，在某些场景下比较合适，所以不要纠结于是要调用方法还是要通过委托调用，就像不懂设计模式也可以写代码完成功能，但是懂得这些套路之后你的代码会更加有条理，更具有扩展性，当然逼格也越高。但是，我觉得不用模式套路的代码逼格更高，谁都看不懂 O(∩_∩)O哈哈~
回到我们的Calculator类，如果需求是Calculator中只要实现加法运算，那TMD的谁还用委托，直接实现一个加法方法就行了，就这么简单。
涉及到委托的使用还不仅仅是这些，像什么事件、表达式树...每个都可以单独作为主题来讲，而且园子里也有很多讲解的文章。流年水平有限，就简单写到这里。