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(); //执行1
cat.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(); //不能执行
问题一:委托和事件有什么联系和区别?
-
事件是委托的实例,事件是特殊的委托;
-
事件和委托都可以使用
+=
和-=
;
问题二:既然有了多播委托,为什么又搞个事件呢?文章来源:https://www.toymoban.com/news/detail-598690.html
安全文章来源地址https://www.toymoban.com/news/detail-598690.html
- 事件是只能在类的内部执行,就算是你的子列也不能执行当前类中的事件,只能由自己来执行
- 事件从外面操作,只能有一个
+=
/-=
到了这里,关于C#基础--委托的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!