委托
委托
1.什么是委托?
个人理解:委托就是把一个方法当做参数传入另一个方法中进行调用。 (委托的实质就是一个类,可以通过中间语言IL编译工具去查看源码)
2.委托的使用?
使用委托三部曲:(1)、委托的声明 。 (2)、委托的实例化。 (3)调用。
3.委托的种类?
(1).delegate (2).泛型委托 Func/ Action (3). event 和观察者模式
通过delegate 关键字来声明委托 举例:
1 public delegate void NoReturnNoPara(); // 无参数、无返回值的委托声明 2 public delegate void NoReturnWithPara(int x, int y);//1 声明委托 3 public delegate int WithReturnNoPara(); //无参数、int类型返回值委托声明 4 public delegate MyDelegate WithReturnWithPara(out int x, ref int y);//自定义委托类
1 private void DoNothing() //无参数无返回值的方法 2 { 3 Console.WriteLine("This is DoNothing 。。。。"); 4 }
1 NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);// this表示是当前类的方法,也可以把方法拆分到其他类中。这里是为了使用方便。 2 //2 委托的实例化 要求传递一个参数类型 返回值都跟委托一致的方法, 3 method.Invoke();//3委托实例的调用 参数和委托约束的一致
上述三段代码,第一段是委托类型的声明; 第二段代码是为实例化委托做准备,通过实例化委托将DoNothing方法作为参数传入到委托中;第三段代码是最后调用DoNothing方法,执行DoNothing中的业务逻辑。注意:委托声明、委托的实例化 要求传递一个参数类型 返回值都跟委托一致的方法,委托实例的调用 参数和委托约束的一致。
Action Func .NetFramework3.0出现的
Action 系统提供 0到16个泛型参数 不带返回值 委托
1 //Action action = new Action(this.DoNothing); 2 Action action0 = this.DoNothing;//是个语法糖,就是编译器帮我们添加上new Action 3 action0.Invoke();
在这里的action0.invoke()和上述 method.Invoke() 执行的结果是一致的。这里推荐使用泛型委托。
Func 委托: 无参数int类型返回值
1 public int Get() 2 { 3 return 1; 4 } 5 6 //Func 系统提供 0到16个泛型参数 带泛型返回值 委托 7 Func<int> func0 = this.Get; 8 int iResult = func0.Invoke();
带参数有返回值的Func委托 int类型参数,字符串类型的返回值
1 private string ToString(int i) 2 { 3 return i.ToString(); 4 } 5 Func<int, string> func1 = this.ToString; //第一个是参数类型 ,第二个是返回值类型 6 func1.Invoke(0);
多播委托
多播委托有啥用呢?一个委托实例包含多个方法,可以通过+=/-=去增加/移除方法,Invoke时可以按顺序执行全部动作。
多播委托:任何一个委托都是多播委托类型的子类,可以通过+=去添加方法,+= 给委托的实例添加方法,会形成方法链,Invoke时,会按顺序执行系列方法。
1 Action method = this.DoNothing; 2 method += this.DoNothing; 3 method += DoNothingStatic; 4 method += new Student().Study; 5 method += Student.StudyAdvanced; 6 //method.BeginInvoke(null, null);//启动线程来完成计算 会报错,多播委托实例不能异步 7 foreach (Action item in method.GetInvocationList()) 8 { 9 item.Invoke(); 10 //item.BeginInvoke(null, null); 11 }
-= 给委托的实例移除方法,从方法链的尾部开始匹配,遇到第一个完全吻合的,移除,且只移除一个,如果没有匹配,就啥事儿不发生。
1 method -= this.DoNothing; 2 method -= DoNothingStatic; 3 method -= new Student().Study;//去不掉 原因是不同的实例的相同方法,并不吻合 4 method -= Student.StudyAdvanced; 5 method.Invoke(); 6 //中间出现未捕获的异常,直接方法链结束了
Func 的多播委托
1 { 2 Func<int> func = this.Get; 3 func += this.Get2; 4 func += this.Get3; 5 int iResult = func.Invoke(); 6 //结果是3 以最后一个为准,前面的丢失了。。所以一般多播委托用的是不带返回值的 7 }
解决泛型委托Func多返回值问题
举例:
1 public class DelegateMethod 2 { 3 //委托声明 4 public delegate string AddDelegate<T>(T i,T j); 5 6 /// <summary> 7 /// 8 /// </summary> 9 /// <returns></returns> 10 public string MyAdd(int k ,int j) 11 { 12 13 return k + j + " "; 14 } 15 16 public string MyFuncAdd(int k,int j) 17 { 18 19 return k + j + " "; 20 21 } 22 }
1 { 2 DelegateMethod Method = new DelegateMethod(); 3 List<string> list_str = new List<string>(); 4 5 Func<int, int, string> func = Method.MyFuncAdd; 6 func += Method.MyFuncAdd;
// GetInvocationList() //调用多播委托的方法列表 7 foreach (Func<int, int, string> item in func.GetInvocationList()) 8 { 9 list_str.Add(item.Invoke(1, 3)); 10 } 11 int i = 0; 12 foreach (var item in list_str) 13 { 14 i++; 15 Console.WriteLine($"第{i} 个值是:{ item}"); 16 } 17 }
event和观察者模式
事件可以理解成一个特殊的委托。
事件是无处不在的,winform无处不在---WPF---webform服务端控件/请求级事件
为啥要用事件?事件究竟能干什么?
事件(观察者模式)能把固定动作和可变动作分开,完成固定动作,把可变动作分离出去,由外部控制
搭建框架时,恰好就需要这个特点,可以通过事件去分离可变动作,支持扩展
控件事件:
启动Form---初始化控件Button---Click事件---+=一个动作
点击按钮--鼠标操作--操作系统收到信号--发送给程序--程序得接受信号,判断控件--登陆--
(事件只能类的内部发生)Button类自己调用Click--肯定是触发了Click事件---登陆动作就会执行
点击按钮--鼠标操作--操作系统收到信号--发送给程序--程序得接受信号,判断控件--支付--
(事件只能类的内部发生)Button类自己调用Click--肯定是触发了Click事件---支付动作就会执行
2次按钮操作,大部分东西都是一样的,就是具体业务不一样的,
封装的控件就完成了固定动作--接受信号&默认动作。。。
可变部分,就是事件---是一个开放的扩展接口,想扩展什么就添加什么
event限制权限,避免外部乱来。
举例: 一只猫,miao一声, 导致一系列的触发动作。(触发的动作有 狗吠,baby哭,母亲安慰baby......)
1 public class Dog : IObject 2 { 3 //public Dog(int id) 4 //{ } 5 6 public void DoAction() 7 { 8 this.Wang(); 9 } 10 public void Wang() 11 { 12 Console.WriteLine("{0} Wang", this.GetType().Name); 13 } 14 }
1 public class Baby : IObject 2 { 3 public void DoAction() 4 { 5 this.Cry(); 6 } 7 8 public void Cry() 9 { 10 Console.WriteLine("{0} Cry", this.GetType().Name); 11 } 12 }
1 public class Mother : IObject 2 { 3 public void DoAction() 4 { 5 this.Wispher(); 6 } 7 public void Wispher() 8 { 9 Console.WriteLine("{0} Wispher", this.GetType().Name); 10 } 11 }
下面通过猫类调用执行一系列动作。
1 public class Cat 2 { 3 public void Miao() 4 { 5 Console.WriteLine("{0} Miao", this.GetType().Name); 6 new Dog().Wang(); 7 new Baby().Cry(); 8 new Mother().Wispher(); 9 10 } 11 }
通过上述猫类调用执行可以出后续的一系列动作对猫类过度依赖, 依赖太重,依赖了多个类型,任何类型的变化都得修改猫。职责耦合,猫不仅自己Miao 还得找各种对象执行各种动作甚至控制顺序, 任意环节增加减少调整顺序 都得修改猫,实际上不该如此,猫就是猫,只做自己的事儿,需求是猫Miao一声---触发一系列的动作---代码还指定了动作, 猫只miao一声---触发一系列动作,动作从哪里来?不管,我只负责调用。
下面通过Action实现多播委托
先声明一个action委托 然后Invoke调用
1 public Action CatMiaoAction;
1 cat.CatMiaoAction += new Dog().Wang; 2 3 cat.CatMiaoAction += new Baby().Cry; 4 cat.CatMiaoAction += new Mother().Wispher;
cat.CatMiaoAction.Invoke(); //调用
使用Action委托调用后,cat类就是稳定的 不用做修改。可以任意扩展其他对象(不如还有一个哥哥类 执行其他的动作,只需要添加一个新的类,然后通过+=的形式将方法绑定上去就可以了),同时每个不同的类还可以自由调整执行的顺序。
我们来继续改造上述方法 通过事件来实现委托。
举例:
事件event:一个委托的实例,带一个event关键字,限制权限,只允许在事件声明类里面去invoke和赋值,不允许外面,甚至子类
1 public event Action CatMiaoActionHandler;
1 public void MiaoEvent() 2 { 3 Console.WriteLine("{0} MiaoEvent", this.GetType().Name); 4 this.CatMiaoActionHandler?.Invoke(); 5 6 }
1 cat.CatMiaoActionHandler += new Dog().Wang; 2 cat.CatMiaoActionHandler += new Mouse().Run; 3 cat.CatMiaoActionHandler += new Baby().Cry; 4 5 cat.CatMiaoActionHandler += new Mother().Wispher; 6 cat.CatMiaoActionHandler += new Brother().Turn; 7 cat.CatMiaoActionHandler += new Father().Roar; 8 cat.CatMiaoActionHandler += new Neighbor().Awake; 9 cat.CatMiaoActionHandler += new Stealer().Hide; 10 11 // cat.CatMiaoActionHandler.Invoke();
// 因为事件的权限限制 只能在事件声明的当前类Invoke调用 不能通过在其他类直接Invoke 所以封装了一个 MiaoEvent()方法在提供外部类使用
12 cat.MiaoEvent();
事件和委托的区别与联系?
委托是一种类型,事件是委托类型的一个实例,加上了event的权限控制