发布：2021/10/23 10:39:05作者：管理员 来源：本站 浏览次数：807
前言
来说一说委托（delegate）和事件（event），本篇采取的形式是翻译微软Delegate的docs中的重要部分（不要问我为什么微软的docs有中文还要读英文，因为读中文感觉自己有阅读障碍- -）+ 自己理解总结，适合不会或没有使用过delegate的小白。
为什么要把委托和事件放在一起，因为委托Delegate是事件Event的基础，并且他们容易被混淆。
原docs中对委托进行了一个定位：委托在.Net中提供后期绑定（Late Binding）机制。
System.Delegate和delegate关键字
定义委托类型
我们从delegate关键字开始，因为它是你使用委托的主要方式。当你使用关键字delegate时，编译器生成的代码将映射到一些方法，这些方法调用了Delegate和MulticastDelegate类的成员。
定义委托的语法跟定义方法签名比较类似，你只需要在返回类型和访问权限之间加上关键字delegate。
继续使用List.Sort()方法（docs前面一直使用的例子）作为我们的例子，第一步是为Comparison委托创建一个类型：
public delegate int Comparison<in T>(T left, T right);
通过上述语句，编译器生成了一个Comparison类，该类派生自System.Delegate。该类包含一个方法，该方法返回1个int，有2个参数（即和签名相同）。
你可以在类内部、命名空间内、全局命名空间中定义委托。（当然，不建议在全局命名空间中定义委托）
编译器同时会为该类生成添加、删除程序，该类的使用者可以从1个实例的调用列表中添加、删除方法。编译器强制添加、删除的方法的签名与声明该方法时使用的签名匹配。
声明委托的实例
定义委托类型之后，你就可以创建委托的实例了。实例的创建和其他变量的创建没有区别。
public Comparison<T> comparator;
变量comparator的类型是我们之前定义的委托类型Comparison<T>。跟变量一样，我们可以声明局部委托变量，把委托变量当做方法参数等。
分配、添加和移除方法
每个委托实例包含1个调用列表，调用列表包含所有分配给委托实例的方法。
想要将方法分配给委托实例，首先需要定义签名与委托类型定义匹配的方法。可以看到下面这个CompareLength方法的签名与委托类型的定义相同，而其内部是个string 类的方法。
//这是一种用lambda表达式定义的方法
private static int CompareLength(string left, string right) =>
left.Length.CompareTo(right.Length);
通过将该方法传递给 List.Sort() 方法来创建该关系：
//使用上述定义的方法名。
phrases.Sort(CompareLength);
//这里不用纠结为什么是这样传入，它只是docs的一个例子，其内部肯定有
//comparator = CompareLength;
//这样的形式
这里 将方法名用作参数会告知编译器将方法引用 转换为可以用作委托调用目标的引用，并将该方法作为调用目标进行附加。其核心如下
//左边是委托变量，右边是方法名称
comparator = CompareLength;
声明Comparison类型的变量并进行分配的操作就是下面这样：
public Comparison<string> comparer = CompareLength;
private static int CompareLength(string left, string right) =>
left.Length.CompareTo(right.Length);
当然如果委托目标的方法是很短的方法 ，你也可以使用lambda
public Comparison<string> comparer = (left, right) =>
left.Length.CompareTo(right.Length);
这里看到的都是单个目标方法添加到委托变量，但委托支持将多个方法添加到委托变量的调用列表。
调用委托
通过下面这种委托变量名+参数的形式，我们调用了附加到委托的方法列表中的方法。
int result = comparator(left, right);
如果并没有任何附加到comparator变量的方法，上面代码将应发NullReferenceException 。
MulticastDelegate
System.MulticastDelegate是System.Delegate的单个直接子类。C#禁止从Delegate和MulticastDelegate。当使用delegate关键字定义、声明委托类型时，C#编译器会创建从MulticastDelegate派生的实例。为了类型安全的考虑，编译器创建了具体的委托类。
与委托实例一起使用的最多的方法时Invoke()和BeginInvoke()/EndInvoke()，Invoke()调用已附加到特定委托实例上的所有方法。
强类型委托
上一节中我们看到可以用delegate关键字创建特定的委托类型。
当你需要不同的方法签名时，你将创建新的委托类型。一段时间后这项工作可能会变得乏味，因为每个新功能都需要新的委托类型。
幸运的是，.NET Core框架包含几种类型，你可以在需要委托类型时重用它们。
这些类型中第一个是Action:
public delegate void Action();
public delegate void Action<in T>(T arg);
public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
Action委托有多种变体，最多包含16个参数。Action没有返回值。
第二个常用的是Func:
public delegate TResult Func<out TResult>();
public delegate TResult Func<in T1, out TResult>(T1 arg);
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
Func委托最多包含16个输入参数，结果类型始终是最后一个类型参数。Func有返回值。
还有一种是Predicate<T>：
public delegate bool Predicate<in T>(T obj);
那么你可以注意到，对于任何Predicate委托类型都有一个相等的Func委托类型：
Func<string, bool> TestForString;
Predicate<string> AnotherTestForString
现在你不需要为任何新功能定义新的委托类型，关于这些特殊的委托类型的用法我将在另外一篇博客中罗列，但现在我们可以想象到，Action的用法应该如下：
Action showMethod = SomeMethod();
showMethod();
委托的常用模式
委托提供了一种机制，它使软件设计涉及的组件之间的耦合最小。
LINQ是这种设计的一个很好的例子。LINQ查询表达式模式的所有功能都依赖于委托。考虑下面这样一个简单的例子：
var smallNumbers = numbers.Where(n => n < 10);
//括号中是Func的lambda写法，Action和Func的用法我将在另一篇博客中介绍，这里你只需要知道括号中传入的是一个已经赋值的委托实例。
上述例子将序列过滤为仅小于10的数字。Where方法使用委托来确定序列中哪些元素被过滤出来。
Where方法的原型是：
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> souce, Func<TSource, bool> predicate);
这个示例说明了委托是如何减少组件之间的耦合的，你可以无需创建派生自特定积累的类，你也不需要实现特定接口。你唯一要做的是提供实现手头任务的方法。
使用代理创建你自己的组件
（这里开始docs举了一个例子来说明如何在实际中使用委托）
让我们来定义一个可用于大型系统中的日志消息组件，该组件中有很多常用功能，它接收来自系统中任何地方的消息。这些消息将具有不同的优先级。
首次实现
原始的实现是这样的：我们接收一个message，然后使用委托将消息写到控制台。
public static class Logger
{
//Action委托实例
public static Action<string> WriteMessage;
//对外接口
public static void LogMessage(string msg)
{
//调用委托上的方法
WriteMessage(msg);
}
}
public static class LoggingMethods{
//将信息打印到控制台的方法
public static void LogToConsole(string message)
{
Console.Error.WriteLine(message);
}
}
//委托实例赋值，这句话一般发生在LoggingMethods的构造器中
Logger.WriteMessage += LoggingMethods.LogToConsole;
附加到委托实例上的方法，可以是实例方法，也可以具有任何访问权限。
格式化输出
向LogMessage方法中添加一些参数，以便日志类创建更多结构化消息。
public enum Severity{
Verbose,
Trace,
Information,
Warning,
Error,
Critical
}
利用Severity过滤打印的消息。
public static class Logger
{
public static Action<string> WriteMessage;
public static Severity LogLevel {get;set;} = Severity.Warning;
public static void LogMessage(Severity s, string component, string
msg)
{
//继续增加筛选功能
if (s < LogLevel)
return;
var outputMsg = $"{DateTime.Now}\t{s}\t{component}\t{msg}";
WriteMessage(outputMsg);
}
}
这里我们可以看到，Logger与任何输出类的耦合非常松散，当我们改变Logger的打印条件时，具体的委托实现完全不需要改动。在实际中，日志输出类可能位于不同的程序集中，利用委托进行耦合，它们完全不需要被重建。
第二个输出引擎
让我们在添加一个将消息记录到文件的输出引擎。这稍微有点复杂，这是一个封装文件操作的类，并要确保每次写入后始终关闭文件（这样可以确保在生成每条消息后将所有数据刷新到磁盘）。
public class FileLogger
{
private readonly string logPath;
public FileLogger(string path)
{
logPath = path;
Logger.WriteMessage += LogMessage;
}
public void DetachLog() => Logger.WriteMessage -= LogMessage;
// make sure this can't throw.
private void LogMessage(string msg)
{
try
{
using (var log = File.AppendText(logPath))
{
log.WriteLine(msg);
log.Flush();
}
}
catch (Exception)
{
// Hmm. We caught an exception while
// logging. We can't really log the
// problem (since it's the log that's failing).
// So, while normally, catching an exception
// and doing nothing isn't wise, it's really the
// only reasonable option here.
}
}
}
创建此类后，可将它进行实例化，然后它会将其LogMessage 方法附加到Logger中：
var file = new FileLogger("log.txt");
也就是说你可以同时附加这两种输出日志的方法（向控制台和文件输出）。
var fileOutput = new FileLogger("log.txt");
Logger.WriteMessage += LogToConsole;
以后，即使在同一个应用程序中，也可删除其中一个方法，而不会对系统造成任何其他问题：
Logger.WriteMessage -= LogToConsole;
再次提醒一下，你无需构建任何其他基础结构即可支持多种输出方法，这些被添加到委托实例的方法只是调用列表上的一种方法而已。
请注意，一定要确保委托方法不会引发任何异常，如果委托实例的调用列表中的任何一个方法抛出异常，则调用列表上其他方法都不会被调用。
Null 委托
当WriteMessage未附加方法时，调用其将引发NullReferenceException
最后，让我们更新LogMessage方法，以确保它在没有任何委托方法的时候具有鲁棒性。
public static void LogMessage(string msg)
{
WriteMessage?.Invoke(msg);
}
当左操作数（本例中为 WriteMessage ）为 null 时，null 条件运算符（ ?. ）会短路，这意味着不会尝试调用委托方法。
小结
通过在设计中使用委托，不同的组件可以非常松散地耦合在一起。 这样可提供多种优势。 可轻松创建新的输出机制并将它们附加到日志系统中。这些机制只需要一种方法：编写日志消息的方法。这种设计在添加新功能时有非常强的弹性。任何编写者只需要实现同一种参数和返回值的方法。该方法可以是静态方法或实例方法。可以是公共的，私有的或其他任何合法的访问权限。
下一篇我们讲讲事件
