委托
委托
一、什么是委托，委托的本质是什么？
- 跟方法有点类似，有参数，返回值，访问修饰符+delegate --委托--特殊的方法？
- 委托的本质是什么？是方法吗？
- 反编译试试：发现定义的委托-----再CustomDelegate ----有对应的class
- 委托的本质是什么？---Class(类)，继承自一个MulticastDelegate的特殊类，自己在定义类的时候，是无法继承的。包含的有构造函数和方法。
- 委托既然是一个类---怎么使用这个类？new ---调用方法/属性
public class DelegateDemo
{
public delegate void NoReturnWithoutParaout();
public delegate void NoReturnWithParaout(out int x);
public delegate void NoReturnWithParaRef(ref int x);
public delegate int WithReturnWithoutPara();
public delegate int WithReturnWithPara(int x, int y);
public static void NoReturnWithoutParaoutfunc()
{
Console.WriteLine("NoReturnWithoutParaoutfunc called!");
}
public static void NoReturnWithParaoutfunc(out int x)
{
x = 100;
Console.WriteLine("NoReturnWithParaoutfunc called!");
}
public static void NoReturnWithParaReffunc(ref int x)
{
x = 100;
Console.WriteLine("NoReturnWithParaReffunc called!");
}
public static int WithReturnWithoutParafunc()
{
Console.WriteLine("WithReturnWithoutParafunc called!");
return 100;
}
public static int WithReturnWithParafunc(int x, int y)
{
Console.WriteLine("WithReturnWithParafunc called!");
return x + y;
}
}
二、委托的实例化
- ILSpy反编译--委托的本质其实是一个类
- 委托本质是一个类，这个类的构造参数--Method方法
- 委托可以通过New来实例化，要求传递一个和这个委托的参数和返回值完全匹配的方法，委托有什么参数(几个，什么类型)---完全匹配
- 委托的实例---可以直接指向和这个委托参数+返回值完全匹配的方法；--语法糖--编译器给我们提供便捷功能new省略掉了。
- 执行委托实例的Invoke方法--去执行这个委托实例化的指向的这个方法---执行方法；
- 就可以执行这个实例内部的三个方法
- 多种实例化:new、指向一个方法、指向一个lambda表达式
NoReturnWithoutParaout noReturnWithoutParaout = new NoReturnWithoutParaout(NoReturnWithoutParaoutfunc);
noReturnWithoutParaout();
三、委托的作用和意义
现在有一个学生类
{
public int Id { get; set; }
public string Name { get; set; }
public int ClassId { get; set; }
public int Age { get; set; }
public Student() { }
public void SayHi()
{
Console.WriteLine("大家好，我是学员，我叫{0}", this.Name);
}
public void Study()
{
Console.WriteLine("学习.net高级班公开课");
}
public static void StudyAdvanced()
{
Console.WriteLine("学习.net高级班vip课");
}
}
我们可以调用一下学生中的方法
{
Student stu = new Student()
{
Id = 1,
Name = "张三",
ClassId = 1,
Age = 18
};
stu.SayHi();
}
我们现在多了一个这样的使用场景的问题
场景1. 学生分类？武汉人、上海人、广东人--三种不同类型的人；问候的口语不一样；
定义三种人:a.武汉 b.上海 c.广东人
问好的方式有多种；
WuHan 人： 吃了么？
GuanDong 人：靓仔/靓女~ 雷猴！
BeiJing 人： 你好！
问题一：如果想要增加一个地方的人；
解决方案一：（多增加几个方法）可以为每一个地方的人，各自定义一个方法
public void SayShangHai()
{
Console.WriteLine("招招手~");
Console.WriteLine("侬好？");
}
public void SayHiWuHan()
{
Console.WriteLine("招招手~");
Console.WriteLine("吃了么？");
}
public void SayHiGuanDong()
{
Console.WriteLine("招招手~");
Console.WriteLine("靓仔/靓女~ 雷猴！");
}
public void SayHiBeiJing()
{
Console.WriteLine("招招手~");
Console.WriteLine("你好！");
}
解决方案二：（传递参数来判断）
/// 传入参数，分辨类型----使用枚举--避免调用方出错；
/// 不同的类型给不同的逻辑
public enum UserType
{
Wuhan = 1,
GuangDong = 2,
BeiJing = 3
}
public void SayHi(UserType userType) //1. 哪儿的人 2 哪儿的人
{
Console.WriteLine("招招手~"); //只需要一句代码搞定了
switch (userType)
{
case UserType.Wuhan:
Console.WriteLine("吃了么？");
break;
case UserType.BeiJing:
Console.WriteLine("你好！");
break;
case UserType.GuangDong:
Console.WriteLine("靓仔/靓女~ 雷猴！");
break;
default:
throw new Exception("No userType");
}
}
点评：
方案一：更好---每个方案，可以相互独立，互不干扰，逻辑没有解耦；满足单一职责；
方案二：耦合在一起，如果有需求的升级，可能需要修改原有的方案，代码可能会不稳定
问题二：如果我想要增加一些公共的业务逻辑呢？问好前---伴随一个动作---“招招手”
再比较：方案二更有有优势了； 只需要增加一句，就可以覆盖所有的人；
方案一出现了重复代码；
有没有一个完美方案呢？
自上而下比较：逻辑单一，逻辑解耦，职责单一，保证代码的稳定性；
如何写？
思路：传递参数枚举---分辨不同地方的人----给出不同的业务逻辑-----（传枚举usertype---选择逻辑）----直接传递逻辑呗； 逻辑在哪儿？ 封装成一个方法； 其实就是需要传递一个方法；
问题：如何把方法当做参数来进行传递？？？ 啥？？？ 当然是委托；
public delegate void DoHandlerDelegate();
public void SayHiPerfect(DoHandlerDelegate doHandler)
{
Console.WriteLine("保持微笑~~");
doHandler.Invoke();
}
在主程序执行的时候
Console.WriteLine("通过委托传递逻辑 \r\n");
DoHandlerDelegate doHandlerWuhan = new DoHandlerDelegate(student.SayHiWuHan);
student.SayHiPerfect(doHandlerWuhan);
DoHandlerDelegate doHandlerBeiJin = new DoHandlerDelegate(student.SayHiBeiJing);
student.SayHiPerfect(doHandlerBeiJin);
DoHandlerDelegate doHandlerGuangDong = new DoHandlerDelegate(student.SayHiGuanDong);
student.SayHiPerfect(doHandlerGuangDong);
问题一：增加一个上海人 --- 增加了一个方案； 方法单一； 方法相互独立，互不干扰；--稳定性，逻辑解耦
问题二：增加一个公共的业务逻辑，只需要在SayHiPerfect 增加一个动作即可；去掉重复代码；
public void SayShangHai()
{
Console.WriteLine("招招手~");
Console.WriteLine("侬好？");
}
主程序中
DoHandlerDelegate doHandlerShangHi = new DoHandlerDelegate(student.SayShangHai);
student.SayHiPerfect(doHandlerShangHi);
委托的价值：
1.逻辑解耦,代码的职责单一
2.去掉重复代码
建议： 如果代码中出现了严重的耦合----考虑使用委托来解决下
如果代码中，出现了大量的重复代码----考虑使用委托来解决下
四、框架内置的委托Action/Func
这里我们定义了两个相同的委托，
public delegate void DoGodDelegate(object? o);
public delegate void ParameterizedThreadStart(object? o);
我们在单独使用这2个委托的时候，并不会遇到什么问题，
我们可以发现无论是doRichard 还是threadStart 执行委托，都是执行的同一个方法；
两个委托做的事儿是一模一样；
问题
Thread thread = new Thread(threadStart);
//Thread thread1 = new Thread(doRichard); //不允许的；问题：在两个结构，功能完全相同的委托； 有可能不能通用的； 不太合理？？？
Why?? 类型不一样~~
委托的本质是一个类， 多个委托就是多个不同的类， 这些没有继承关系，所以不能用；
以上问题、微软也发现了；
为了能够让委托能通用， 为了不用定义过多的委托；
微软提供了两个类功的委托： Action/Func
Action: 应对了没有返回值的委托场景；
可有可无参数，一定没有返回值的委托；最多可以有16个参数~~ 16个泛型版本
如果想要有17个参数的委托呢？(自己扩展)
Action<int> action1 = new Action<int>(s => { }); //接收一个int类型参数，没有返回值
Action<int,string> action2 = new Action<int, string>((i,s) => { }); //接收一个int类型参数，没有返回值
Action<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object> action3 = null;
Action<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object,int> action4 = null;
这是一个没有返回值的通用委托---如果所有的人需要使用没有返回值的委托的时候，都用Action, 不用定义委托；委托都是同一个类型； 就可以通用了；
微软既然提供这个委托，自然是希望我们在以后的编码中，都尽可能使用这些，这样就可以统一了委托的类型；
对于以前定义的委托呢？ 咋办？ 解决不了~~ 这些被称为技术上的历史包袱，丢不掉~~ 以后在使用委托的时候，就不要自己定义了，直接使用现有提供的委托即可~~
委托要有返回值呢？
Func：多版本的委托：应对了有返回值的情况；
一定有返回值的委托；泛型委托Func中的最后一个类型参数，是作为返回值的类型；前面的类型参数，是作为委托的参数；也提供了最多可以有16个参数；
如果需要有17个参数，且有返回值的委托呢？ 可以扩展下呗；
Func<int> func = new Func<int>(() => { return 10; }); //一个返回值的委托，没有参数；
Func<int, string> func1 = new Func<int, string>(s => { return "R"; });
Func<int,string,DateTime,object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, string> func2 = null;
//17个参数；
Func<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime,object, object, string> func3 = null;
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17);
五、委托的嵌套使用，ASP.NET CORE中间件的核心设计----委托的多层嵌套
这里创建一个很基础的一个类
public class DelegateExtension
{
public static void Show()
{
InvokeAction invokeAction = new InvokeAction();
{
}
}
}
public class InvokeAction {
public void ExeMethod()
{
Console.WriteLine("Exec ExeMethod");
}
}
问题:想要去在Invoke.Show方法前后，扩展一些业务逻辑.
这里根据我们之前上面拓展出来的知识可以写出来这样的代码
public static void Show()
{
InvokeAction invokeAction = new InvokeAction();
{
Action action = new Action(invokeAction.ExeMethod);
//再次定义委托
{
Func<Action, Action> action2 = new Func<Action, Action>(ExeNextMethod006);
Action action3 = action2.Invoke(action);
action = action3;
Func<Action, Action> action4 = new Func<Action, Action>(ExeNextMethod005);
Action action5 = action4.Invoke(action);
action = action5;
Func<Action, Action> action6 = new Func<Action, Action>(ExeNextMethod004);
Action action7 = action6.Invoke(action);
action = action7;
Func<Action, Action> action8 = new Func<Action, Action>(ExeNextMethod003);
Action action9 = action8.Invoke(action);
action = action9;
Func<Action, Action> action10 = new Func<Action, Action>(ExeNextMethod002);
Action action11 = action10.Invoke(action);
action = action11;
Func<Action, Action> action12 = new Func<Action, Action>(ExeNextMethod001);
Action action13 = action12.Invoke(action);
action = action13;
action.Invoke();
}
}
}
public static Action ExeNextMethod001(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod001 Start");
action();
Console.WriteLine("Exec ExeNextMethod001 End");
});
}
public static Action ExeNextMethod002(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod002 Start");
action();
Console.WriteLine("Exec ExeNextMethod002 End");
});
}
public static Action ExeNextMethod003(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod003 Start");
action();
Console.WriteLine("Exec ExeNextMethod003 End");
});
}
public static Action ExeNextMethod004(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod004 Start");
action();
Console.WriteLine("Exec ExeNextMethod004 End");
});
}
public static Action ExeNextMethod005(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod005 Start");
action();
Console.WriteLine("Exec ExeNextMethod005 End");
});
}
public static Action ExeNextMethod006(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod006 Start");
action();
Console.WriteLine("Exec ExeNextMethod006 End");
});
}
}
public class InvokeAction {
public void ExeMethod()
{
Console.WriteLine("Exec ExeMethod");
}
}
我希望无限制的 增加扩展业务逻辑；
再增加一个--定义方法，通过委托包装后去当做参数传递；
现在的代码已经做到了
1.已经做到了职责的单一；
2.但是当前这个 DelegateExtension.Show 方法不太稳定，如果要增加一环，我需要修改DelegateExtension.Show方法
思路：可以把要执行的业务逻辑----特性--封装到特性中去；
public static void Show()
{
InvokeAction invokeAction = new InvokeAction();
{
{
Type type= typeof(InvokeAction);
MethodInfo method = type.GetMethod("ExeMethod");
ExecNextMethod001Attribute attribute1 = method.GetCustomAttribute<ExecNextMethod001Attribute>();
Action action=new Action(()=> { method.Invoke(invokeAction, null); });
action=attribute1.Do(action);
ExecNextMethod002Attribute attribute2 = method.GetCustomAttribute<ExecNextMethod002Attribute>();
action = attribute2.Do(action);
ExecNextMethod003Attribute attribute3 = method.GetCustomAttribute<ExecNextMethod003Attribute>();
action = attribute3.Do(action);
ExecNextMethod004Attribute attribute4 = method.GetCustomAttribute<ExecNextMethod004Attribute>();
action = attribute4.Do(action);
action.Invoke();
}
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod001Attribute: Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod001 Start");
action();
Console.WriteLine("Exec ExeNextMethod001 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod002Attribute : Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod002 Start");
action();
Console.WriteLine("Exec ExeNextMethod002 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod003Attribute : Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod003 Start");
action();
Console.WriteLine("Exec ExeNextMethod003 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod004Attribute : Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod004 Start");
action();
Console.WriteLine("Exec ExeNextMethod004 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod005Attribute : Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod005 Start");
action();
Console.WriteLine("Exec ExeNextMethod005 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod006Attribute : Attribute
{
public Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod006 Start");
action();
Console.WriteLine("Exec ExeNextMethod006 End");
});
}
}
思路：因为类型不一样，所以只能一个一个的判断；
如果能一次获取所有特性(矛盾，类型不一样，没有办法一次获取所有；？？？？统一类型，如何统一类型？？ 来一个父类，让特性继承父类，然后在获取特性的时候，通过父类获取；)：放在一个集合中，要逐个的调用特性的Do方法来包装委托的话，就可以循环执行；
public static void Show()
{
InvokeAction invokeAction = new InvokeAction();
Type type = typeof(InvokeAction);
MethodInfo method = type.GetMethod("ExeMethod");
Action action = new Action(() => { method.Invoke(invokeAction, null); });
IEnumerable<ExecNextMethodAbstractAttribute> attributellist = method.GetCustomAttributes<ExecNextMethodAbstractAttribute>();
foreach (var attribute in attributellist.Reverse())
{
action = attribute.Do(action);
}
action.Invoke();
}
[AttributeUsage(AttributeTargets.Method)]
public abstract class ExecNextMethodAbstractAttribute : Attribute
{
public abstract Action Do(Action action);
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod001Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod001 Start");
action();
Console.WriteLine("Exec ExeNextMethod001 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod002Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod002 Start");
action();
Console.WriteLine("Exec ExeNextMethod002 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod003Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod003 Start");
action();
Console.WriteLine("Exec ExeNextMethod003 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod004Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod004 Start");
action();
Console.WriteLine("Exec ExeNextMethod004 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod005Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod005 Start");
action();
Console.WriteLine("Exec ExeNextMethod005 End");
});
}
}
[AttributeUsage(AttributeTargets.Method)]
public class ExecNextMethod006Attribute : ExecNextMethodAbstractAttribute
{
public override Action Do(Action action)
{
return new Action(() =>
{
Console.WriteLine("Exec ExeNextMethod006 Start");
action();
Console.WriteLine("Exec ExeNextMethod006 End");
});
}
}
这样就可以让我们自己在搭建框架的时候（支持了业务的扩展---AOP扩展---装饰器模式的番外篇），可以让程序员在使用我们这个框架的时候，更加聚焦业务逻辑；
可以动态增加业务逻辑；
六、多播委托/观察者模式
委托还可以通过+= 把更多的方法包装到委托中来，形成一个方法的执行链子
在执行委托的时候，可以按照+=的顺序，把方法逐个执行；
也提供了-= 操作，可以按照顺序把方法从方法链子中，依次移除；移除按照顺序依次移除，只要是匹配移除一个之后，就不在继续移除了；如果要移除的方法在，委托中不存在，-=就不做任何操作；
委托在+=,-=可以操作哪些方法呢？
- 静态方法
- 实例方法
- lamdba表达式
- 普通方法
public void Show()
{
{
Action action = new Action(DoNothing);
action += DoNothing;
action += DoNothing;
action += DoNothing;
action += DoNothing;
action -= DoNothing;
action.Invoke();
}
//委托在+= 、 -=可以操作哪些方法呢？
{
Action action = new Action(DoNothing);
action += DoNothingStatic; //+=静态方法
action += new Student().Study; //+=实例方法
action += () => { Console.WriteLine("this is Lambda"); };
//action.Invoke(); //都会依次执行
action -= DoNothing; //普通方法
action -= DoNothingStatic; //静态方法
action -= new Student().Study; //实例方法
action -= () => { Console.WriteLine("this is Lambda"); }; //Lambda 表达式
action.Invoke();
}
}
private void DoNothing()
{
Console.WriteLine("This is DoNothing");
}
private static void DoNothingStatic()
{
Console.WriteLine("This is DoNothingStatic");
}
