委托：
当要把方法传递给其他方法时，就需要使用委托。也就是把方法作为参数来传递。
委托是一种特殊的类型对象，其特殊在于我们定义的所有对象都包含数据，而委托包含的只是一个或多个方法的地址。
委托的一个特征是它们类型是安全的，可以确保调用的方法的签名是正确的。既可以调用对象的实例方法，也可以调用静态方法，只要方法的签名和委托的签名一致就行。
自定义委托：
示例：
using System;
namespace ConsoleApp
{
// 声明一个委托 参数double 返回值double
delegate double DoubleOp(double x);
class Program
{
static void Main(string[] args)
{
// 1、使用new关键字
DoubleOp op = new DoubleOp(Action1);
Console.WriteLine(op(4)); // 8
// 2、直接复制 (称为委托推断)
DoubleOp op1 = Action2;
Console.WriteLine(op1.Invoke(4)); // 16
// 说明：
// op(4) 和 op1.Invoke(4)
// 直接使用()和使用委托类的Invoke()方法作用完全相同;
// 使用op1.Invoke(4)底层编译器也会转换为 op1();
Console.Read();
}
static double Action1(double val)
{
return val * 2;
}
static double Action2(double val)
{
return val * val;
}
}
}
泛型委托：
Action<T>和Func<T>
除了使用自定义的委托之外，还可以使用Action<T>和Func<T>泛型委托。
Action<T>：
引用一个无返回类型的方法，可以传递0到16种不同的参数类型。没有泛型参数的Action类可以调用没有参数的方法；
using System;
namespace ConsoleApp
{
class Program
{
static void Main(string[] args)
{
// Action 调用无参数的方法
// Action<T> 调用1个参数的方法
// Action<T1, T2> 调用2个参数的方法
// Action<T1, T2, ..., T16> 调用16个参数的方法
// 示例：
Action action = Action;
action();
Action<string> action1 = Action1;
action1("");
Action<string, string> action2 = Action2;
action2("", "");
Console.Read();
}
static void Action()
{
Console.WriteLine("Action");
}
static void Action1(string val)
{
Console.WriteLine("Action1");
}
static void Action2(string val1, string val2)
{
Console.WriteLine("Action2");
}
}
}
Func<T>:
允许调用带返回类型的方法，同样也支持0到16种参数类型。
using System;
namespace ConsoleApp
{
class Program
{
static void Main(string[] args)
{
// Func<out T>; 调用带返回类型的无参方法
// Func<in T1, in T2, out T>; 调用2个带参数方法
// Func<in T1, in T2,..., in T16, out T>; 调用16个带参数方法
// out T返回类型
// 示例：
Func<double, double> func1 = Action1;
Console.WriteLine(func1(4)); // 8
Func<int, double, double> func2 = Action2;
Console.WriteLine(func2(4, 2.2)); // 8.8
Console.Read();
}
static double Action1(double val)
{
return val * 2;
}
static double Action2(int val1, double val2)
{
return val1 * val2;
}
}
}
多播委托：
前面使用的委托都只包含一个方法的调用，调用委托的次数与调用方法的次数相同。如果要调用多个方法，就需要显示的调用多次委托。
委托也可以包含多个方法，这种委托就称为多播委托。多播委托按顺序连续调用多个方法，因此，委托的签名就必须返回void；否则，就只能得到最后一个方法的结果。
语法很简单，使用运算符+和+=(增加委托的方法调用) 或者 -和-= (删除委托的方法调用)；
using System;
namespace ConsoleApp
{
class Program
{
static void Main(string[] args)
{
// 增加委托的方法调用
Action<double> actions = Action1;
actions += Action2;
actions(4);
// 删除委托的方法调用
actions -= Action2;
Console.Read();
}
static void Action1(double val)
{
Console.WriteLine(val *2);
}
static void Action2(double val)
{
Console.WriteLine(val * val);
}
}
}
多番委托可能导致的问题，如果委托调用的其中一个方法抛出异常，结果会怎么样？
运行代码：
using System;
namespace ConsoleApp
{
class Program
{
static void Main(string[] args)
{
Action<double> actions = Action1;
actions += Action2;
try
{
actions(4);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Read();
}
static void Action1(double val)
{
Console.WriteLine(val * 2);
// 抛出异常
throw new Exception("Error in Actoin1");
}
static void Action2(double val)
{
Console.WriteLine(val * val);
}
}
}
结果：
8 Error in Actoin1
由此得知：其中一个方法抛出异常，则整个迭代就会停止。
在这种情况下，为了避免该问题，可以使用Delegate类定义的GetInvocationList()方法自己迭代方法列表。
匿名方法：
要想使委托正常工作，方法就必须存在，但还有另一种使用委托的方式，就是通过匿名方法。
用匿名方法定义委托与前面的定义其实并没有什么区别，只是简化了代码，运行速度并没有加快，底层编译器仍然定义了一个方法，只是该方法名称由编译器自动指定。
using System;
namespace ConsoleApp
{
class Program
{
static void Main(string[] args)
{
// 示例：
// 使用delegate关键字
Action<string> action1 = delegate (string param)
{
Console.WriteLine("Action1");
};
action1("");
// 简化 使用Lambda表达式
Action<string> action2 = (string param) =>
{
Console.WriteLine("Action2");
};
action2("");
Console.Read();
}
}
}
需要注意的是，使用匿名方法必须遵守两条规则：
1、在匿名方法中不能使用跳转语句(break、goto、continue)跳转到该匿名方法的外部，同样，方法外部的跳转语句也不能跳转到该匿名方法内部。
2、在匿名方法内部不能访问不安全的代码，也不能访问匿名方法外部使用的ref和out参数。
原文地址：https://www.cnblogs.com/sokarl/p/11788699.html