C#基础–委托

C#基础–委托

简单说它就是一个能把方法当参数传递的对象，而且还知道怎么调用这个方法，同时也是粒度更小的“接口”（约束了指向方法的签名）

一、什么是委托，委托的本质是什么？

跟方法有点类似，有参数，返回值，访问修饰符+ delegate
```
public delegate void NoReturnNoPara();
```
委托的本质是一个类，继承自一个特殊类 MulticastDelegate，我们自己在定义类的时候是无法去继承MulticastDelegate 的
在类的内部生成一个类

二、委托的实例化，执行委托

ILSply反编译–委托的本质其实是一个类
委托本质是一个类，这个类的构造函数参数—Method–方法

委托可以通过New来实例化，要求传递一个和这个委托的参数和返回值完全匹配的方法【完全匹配】

委托有几个参数，方法参数数量也要对应；参数的类型在顺序上也要一一对应
委托 返回参数和 方法 返回的参数类型也需要对应

public delegate void NoReturnWithPara(int x, int y);
private static void NoReturnNoParaMehtod()
{Console.WriteLine("这是一个无参数无返回值的方法。。。");
}

委托的实例–可以直接指向一个和这个委托参数+返回值完全匹配的方法

-语法糖–编译器给我们提供额便捷功能–new WithReturnNoPara()；省略掉了

WithReturnNoPara withReturnNoPara1 = new WithReturnNoPara(WithReturnNoParaMehtod);
//可以省略
WithReturnNoPara withReturnNoPara2 = WithReturnNoParaMehtod;

执行委托实例的Invoke方法–去执行这个委托实例化的指向的这个方法—执行方法

//调用
NoReturnWithPara noReturnWithPara = new NoReturnWithPara(NoReturnNoParaMehtod);
noReturnWithPara.Invoke(55,68);

可以执行这个实例内部的三个方法：

//如果委托定义没有参数；在Inovke也没有参数 
withReturnNoPara.Invoke();	//开启一个新的线程去执行委托
withReturnNoPara.BeginInvoke(null, null);	//回调
withReturnNoPara.EndInvoke();

多种实例化：new、直接指向一个方法，指向一个Lambad表达式

//new
WithReturnNoPara withReturnNoPara1 = new WithReturnNoPara(WithReturnNoParaMehtod);//直接指向一个方法
WithReturnNoPara withReturnNoPara2 = WithReturnNoParaMehtod;//指向一个Lambad表达式
NoReturnWithPara noReturnWithPara3 = (x, y) => { };

三、框架内置委托 Func 和 Action

.NET Framework3.0时代就开始拥有的产物

1. Action

Action是来自于System.RunTime的一个声明好的可以带有一个或者多个参数的委托delegate，没有返回值的委托（最多支持16个入参）

private void NoreturnNopara()
{}Action action = new Action(NoreturnNopara);
action.Invoke();

private void DoNothingInt(int i)
{Console.WriteLine("This is DoNothing");
}Action<int> action1 = new Action<int>(DoNothingInt);
action.Invoke();

Action<int, List<string>, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object> action2 = null;

2. Func

是来自于System.RunTime的一个声明好的可以有返回值的委托delegate，可以有参数，也可以没有参数（最多支持16个入参）
```
private int ReturnNopara()
{return 0;
}Func<int> func = new Func<int>(ReturnNopara);
```

如果既有参数 + 返回值，那<> 中前面类型参数=输入参数，最后的类型参数=返回值

Func<int, int> func1 = new Func<int, int>(ToInt);Func<int, string, int> func2 = new Func<int, string, int>(DoNothingIntAndStringNew);Func<int, List<string>, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int> func3 = null;

问题一： 我们自己是可以定义委托的，为什么系统框架要给我们提供这样的两个委托呢？

答案一：【做到委托类型的统一】既然是系统框架给我们定义好了这两个委托，自然是希望我们在以后的开发中都去只是用这两个委托，这样就可以把委托做到统一；我们以后在使用委托的时候，就不用自己再去定义这个委托了；

场景：

//正常
new Thread(new ThreadStart(DoNoting));
//报错
new Thread(new NoReturnNoPara(DoNoting));//为什么ThreadStart 和 NoReturnNoPara都是没有参数没有返回的委托，但是传入NoReturnNoPara会报错呢？
//因为委托本质是一个类，你传入的实例类型和定义的参数类型不一致，当然会报错啦
//系统框架给我们定义好了这两个委托，自然是希望我们在以后的开发中都去只是用这两个委托

问题二： 那之前定义好的委托呢？

答案二： 【历史包袱】我们是去不掉的，这被称之为历史包袱；

**问题三：**什么情况下可以考虑使用委托？

**答案三：**方法内部业务逻辑耦合严重；如果多个方法中出现了很多重复代码–去除重复代码，逻辑重用，考虑委托，达到逻辑解耦的目的。

从上而下：代码稳定，不需要修改；执行的逻辑不在同一个方法中–逻辑解耦
从下而上：去掉了重复代码，逻辑重用

四、委托的嵌套使用（俄罗斯套娃）

Asp .Net Core的核心设计，委托实现中间件的应用；

俄罗斯套娃，属于番外装饰器–AOP支持；就是把委托这个箱子一层一层的包装起来，将要执行的核心业务逻辑封装在最内部的箱子中，执行顺序是从最外层开始到最内层，在一层一层执行出来。

每一层执行的时候，我们就可以增加一些其他的业务逻辑；-- AOP的支持，装饰器

经过特性+委托 多层嵌套的封装–程序的执行环节的自动装配；如果有十个环节，那么只需要定义10个特性，分别标记就可以增加一个处理环节–ASP.NET Core的管道处理模型。

普通类 InvokerAction.cs – Method方法

public class InvokerAction
{[BeforeWriteLogAttribute][BeforeMethodAttribute]public void Method(int i){Console.WriteLine("这里是要执行的核心业务逻辑");}
}

普通方式：

InvokerAction invokerAction = new InvokerAction();
invokerAction.Method(256);

反射：

InvokerAction invokerAction = new InvokerAction();
Type type = invokerAction.GetType();
MethodInfo methodInfo = type.GetMethod("Method");
methodInfo.Invoke(invokerAction, new object[] { 123 });

反射+委托：

public delegate void ShowDelegate();public static void Show()
{InvokerAction invokerAction = new InvokerAction();Type type = invokerAction.GetType();MethodInfo methodInfo = type.GetMethod("Method");//实例化一个委托：委托内部包含了一个行为： 行为：执行Method方法ShowDelegate showMethod = new ShowDelegate(() =>{methodInfo.Invoke(invokerAction, new object[] { 123 });}); showMethod.Invoke();
}

套娃–多层委托的嵌套：

ShowDelegate showmthod1 = new ShowDelegate(() =>{showMthod.Invoke();});ShowDelegate showmthod2 = new ShowDelegate(() =>{showmthod1.Invoke();});ShowDelegate showmthod3 = new ShowDelegate(() =>{showmthod2.Invoke();});ShowDelegate showmthod4 = new ShowDelegate(() =>{showmthod3.Invoke();});
//执行
showmthod4.Invoke();

定义一个特性：在特性中定义每个环节中要执行的动作：

抽象类–AbstractMethodAttribute.cs

public abstract class AbstractMethodAttribute : Attribute
{/// <summary>/// 在xxx 执行之前执行的点业务落/// </summary>public abstract ShowDelegate Do(ShowDelegate action);
}

BeforeWriteLogAttribute.cs

public class BeforeWriteLogAttribute : AbstractMethodAttribute
{/// <summary>/// 在xxx 执行之前执行的点业务落/// </summary>public override ShowDelegate Do(ShowDelegate action){ ShowDelegate actionResult = new ShowDelegate(() =>{{Console.WriteLine("前面写一个日志");  //这里可以随便写。。。。}action.Invoke();{Console.WriteLine("后面写一个日志");  //这里可以随便写。。。。}});return actionResult;}
}

BeforeMethodAttribute.cs

public class BeforeMethodAttribute : AbstractMethodAttribute
{/// <summary>/// 在xxx 执行之前执行的点业务落/// </summary>public override ShowDelegate Do(ShowDelegate action){ShowDelegate actionResult = new ShowDelegate(() =>{{Console.WriteLine("在xxx 执行之前执行点业务逻辑");  //这里可以随便写。。。。}action.Invoke();{Console.WriteLine("在xxx 执行之后执行点业务逻辑");  //这里可以随便写。。。。}});//actionResult.Invoke(); return actionResult;}
}

调用：

public static void Show()
{InvokerAction invokerAction = new InvokerAction();Type type = invokerAction.GetType();MethodInfo methodInfo = type.GetMethod("Method");ShowDelegate showMethod = new ShowDelegate(() =>{methodInfo.Invoke(invokerAction, new object[] { 123 });}); //如果方法上存在继承于自AbstractMethodAttribute的属性if (methodInfo.IsDefined(typeof(AbstractMethodAttribute), true)){//获取所有属性foreach (AbstractMethodAttribute attribute in methodInfo.GetCustomAttributes().Reverse()){//第一次循环时，showMethod.Invoke 交于第一个属性执行//接下来得每次执行，都是下一个属性执行上一个属性返回来得委托//最后形成一个俄罗斯套娃，值得注意的时候，这时候所有委托并没有实际执行showMethod = attribute.Do(showMethod);	}}//返回的最后一个委托开始执行，即从套娃的最外层开始执行，最终到 showMethod.Invoke -> methodInfo.Invoke;showMethod.Invoke();
}

五、多播委托

多播委托：我们声明的任何一个委托都是多播委托；任何一个委托都是继承自MulticastDelegate(多播委托)，定义的所有的委托都是多播委托；

作用：可以通过+= 把多个方法添加到这个委托中去；形成一个方法的执行链；利用 action1.Invoke() 执行委托的时候，按照添加方法的顺序，依次去执行委托；

Action action = new Action(DoNothing);
action += DoNothingStatic;
action += new Student().Study;
action += Student.StudyAdvanced;
action += DoNothing;
action += () =>
{Console.WriteLine("this is 拉姆达表达式。。。");
};

action.BeginInvoke(); //开启一个新的线程去执行委托

注册有多个方法的委托，不能使用BeginInvoke；如上述action, 因添加多个方法，所以不能使用 BeginInvoke直接执行，需要用到第四点的 action.GetInvocationList() 获取委托列表循环执行；
想要开启一个新的线程去执行委托呢？

通过action.GetInvocationList() 获取到所有的委托，然后循环，每个方法执行的时候可以BeginInvoke
```
foreach (Action action1 in action.GetInvocationList())
{//action1.Invoke();action1.BeginInvoke(null,null);
}
```
多播委托也可以通过-=移除方法

是从后往前，逐个匹配，如果匹配不到，就不做任何操作就不做任何操作;如果匹配到，就把当前这个移除，且停止去继续往后匹配；
```
action -= DoNothing;
```
在移除的方法的时候，必须是同一个实例，同一个方法才能移除；
```
action -= new Student().Study;	//没有移除掉：因为不是同一个实例
```

lambda表示式是不能移除的；

虽然方法体内容是一样的，但是lambada表示在底层会生成不同的方法

action -= () => //没有移除：  其实是因为不是同一个方法---lambda表达式--在底层会生成不同的方法
{Console.WriteLine("this is 拉姆达表达式。。。");
};

六、观察者模式

事例：猫的故事

Cat.cs

public void Miao()
{Console.WriteLine("{0} Miao", this.GetType().Name);new Dog().Wang(); //狗叫了new Mouse().Run();//老鼠跑了new Baby().Cry(); // 小孩哭了
}

缺点：

职责不单一 — 一个类中包含的职责太多了，除了Miao 一声，依赖于其他的类太多；
依赖太重–依赖于Dog、Mouse、…—代码不稳定；Dog、Mouse、…任何一个类的修改，都有可能会影响到这只猫；
这完全是面向过程式编程–完全是翻译需求；

改造目的：

职责单一：猫的职责仅仅只是Miao一下，其他的动作，不是猫的动作；
猫Miao一声后会引发一些列的动作，应该放出去，不能属于这只猫
猫Miao一声后，触发一些列的动作—不能把这一些列的动作放在猫的内部

接口类 IObject.cs：

public interface IObject
{void DoAction();
}

观察者们： 【订阅者】

public class Dog : IObject
{public void DoAction(){this.Wang();}public void Wang(){Console.WriteLine("{0} Wang", this.GetType().Name);}
}

public class Mouse : IObject
{public void DoAction(){this.Run();}public void Run(){Console.WriteLine("{0} Run", this.GetType().Name);}
}

public class Baby : IObject
{public void DoAction(){this.Cry();}public void Cry(){Console.WriteLine("{0} Cry", this.GetType().Name);}
}

发布者1：Cat.cs 【委托】

通过定义委托属性
给委托+=方法–Miao一声之后，要触发的动作
特点：把要执行的动作不放在猫的内部从外面去指定
多播委托+=来完成了一系列动作的转移，把猫Miao一声后的动作转移到上端
去掉了猫对于其他的依赖—提高了猫的稳定性
通过委托实现了观察者模式–观察者模式—把不属于我的动作转移出去—甩锅

public  Action MiaoAction = null; 
/// <summary>
/// 这个方法仅仅只是Miao一声
/// 引发的动作---可以放到多播委托中去
/// </summary>
public void MiaoDelegate()
{Console.WriteLine("{0} MiaoDelegate", this.GetType().Name);MiaoAction?.Invoke();//?. 如果不为null，就执行后面的动作； 若event不为null，则invoke，这是C#6的新语法。 ?.称为空值传播运算符。
}

cat.MiaoAction += new Dog().Wang; //狗叫了
cat.MiaoAction += new Mouse().Run;//老鼠跑了
cat.MiaoAction += new Mother().Wispher;
cat.MiaoAction += new Baby().Cry; // 小孩哭了
cat.MiaoDelegate();	//执行1cat.MiaoAction();	//和执行1一样，也可以执行

发布者2：Cat.cs 【接口 + 列表 + 循环执行】

public List<IObject> observerlist = new List<IObject>();	//IObject 含有 DoAction方法public void MiaoObsever()
{Console.WriteLine("{0} MiaoObsever", this.GetType().Name);if (observerlist.Count>0){foreach (var item in observerlist){item.DoAction();}}
}

cat.observerlist.Add(new Dog()); //狗叫了
cat.observerlist.Add(new Mouse());//老鼠跑了
cat.observerlist.Add(new Baby()); // 小孩哭了
cat.MiaoObsever();

两者从本质上来说是没有什么太大的区别

第一种是通过多播委托来支持，是语法层面来支持；

第二种是通过面向对象的方法来完成，是程序设计层面来支持；

七、事件

发布者3：Cat.cs 【事件】

public event Action MiaoEventHanlder = null;public void MiaoEnvent()
{Console.WriteLine("{0} MiaoEnvent", this.GetType().Name);MiaoEventHanlder?.Invoke();//若event不为null，则invoke，这是C#6的新语法。 ?.称为空值传播运算符。
}

cat.MiaoEventHanlder += new Dog().Wang; //狗叫了
cat.MiaoEventHanlder += new Mouse().Run;//老鼠跑了
cat.MiaoEventHanlder += new Mother().Wispher;
cat.MiaoEnvent(); cat.MiaoEventHanlder.Invoke(); //不能执行

问题一：委托和事件有什么联系和区别？