委托（续）

委托事件

① 委托的多中实例化

 1 {            Console.WriteLine("---------委托的多种实例化--------------");
 2             {
 3              //this 当前所在类的  
 4                 NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(this.NoRunturnMethod);
 5             }
 6             {
 7                 //当前所在的静态类
 8                 NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(NoRunturnMethods);
 9             }
10             {
11                 /*
12               public class Customclass
13               {  public void NoRunturnMethod() { }
14                 public static void NoRunturnMethods() { }
15                }
16                 */
17                 NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(new Customclass().NoRunturnMethod);
18             }
19             {
20                 NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(Customclass.NoRunturnMethods);
21 
22             }
23 }
View Code

②Action/Func

Action/Func是系统给我们提供的一个委托 最多可以有16个泛型参数,多了需要开发人员自己定义

为什么框架要给我们提供这两个委托呢?

  1. 委托的本质的一个类 定义的不用的委托其实就是不用的类 这些类没有父子级关系,不能替换,但是这些委托参数和返回值又都是一致的

  2. 为了避免大家在开发的过程中定义了过多的委托, 产生冗余

那为什么我们还是可以自定义委托呢?!

因为历史原因,以前的框架中,使用了各种委托,C#是向前兼容

 1     Console.WriteLine("***********Action/Func**************");
 2                 //Action:是系统给我们提供的一个委托,是一个没有返回值,可以有参数的委托;最多可以有16个泛型参数,可以自己后期添加
 3                 //Action action = new Action(this.NoRunturnMethod);
 4                 { Action<int> method = new Action<int>((a) => { Console.WriteLine(a.GetType().Name); }); }
 5                 { Action<int, string> method = new Action<int, string>((a, b) => { Console.WriteLine(a.GetType().Name); Console.WriteLine(b.GetType().Name); }); }
 6                 { Action<int, object, string> method = new Action<int, object, string>((a, b, c) => { Console.WriteLine(a); }); }
 7 
 8                 //Func:是系统给我们提供的一个委托,是一个必须有返回值,可以有参数的委托;最多可以有16个泛型参数,可以自己后期添加
 9                 { Func<string> func = () => { return ""; }; }
10                 { Func<string> func = null; }
11 
12                 //为什么框架要给我们提供这两个委托呢?   既然是框架提供的委托,是希望我们就是用这两个委托
13                 new Thread(new ParameterizedThreadStart((a) => { Console.WriteLine("a"); }));
14                 ThreadPool.QueueUserWorkItem(new WaitCallback((a) => { Console.WriteLine("a"); }));
15                 new Thread(new ParameterizedThreadStart(new WaitCallback((a) => { Console.WriteLine("a"); })));//委托不能这么使用?
16                 //委托的本质的一个类 定义的不用的委托其实就是不用的类 这些类没有父子级关系,不能替换,但是这些委托参数和返回值又都是一致的
17                 //所有推荐以后使用委托的时候就不需要自己定义了.直接使用Action /Func
18                 //为了避免大家在开发的过程中定义了过多的委托, 
19                 //那为什么我们还是可以自定义委托呢?!  因为历史原因,以前的框架中,使用了各种委托
20                 //C#是向前兼容
View Code

③多播委托

1.我们创建的每一个委托都是多播委托
2.多播委托可以在实例化以后，可以通过+=添加和当前委托参数返回值完全一样的多个方法，形成方法链。在调用Invoke方法的时候 会按照+=的顺序依次执行 【重载方法是不添加不上的】
3.可以通过-= 移除方法 （必须是同一个方法），是按照从下往上按照顺序依次匹配，只要是匹配到一个就移除，且只能移除一个，如果匹配不到，不做任何操作
4.多播委托允许异步

 

 1      Console.WriteLine("---------------多播委托------------------------");
 2                 //多播委托可以在实例化以后，可以通过+=添加和当前委托参数返回值完全一样的多个方法，形成方法链。在调用Invoke方法的时候 会按照+=的顺序依次执行  【重载方法是不添加不上的】
 3                 NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(Customclass.NoRunturnMethods);
 4                 noRunturnNoParameter += this.NoRunturnMethod;
 5                 noRunturnNoParameter += NoRunturnMethods;
 6                 noRunturnNoParameter += new Customclass().NoRunturnMethod;
 7                 noRunturnNoParameter += Customclass.NoRunturnMethods;
 8                 noRunturnNoParameter += () => { Console.WriteLine("***this is Lamda"); };
 9                 // noRunturnNoParameter.Invoke();
10                 /*
11                 执行顺序：
12                  Customclass.NoRunturnMethods
13                  this.NoRunturnMethod;
14                  NoRunturnMethods;
15                  new Customclass().NoRunturnMethod;
16                  Customclass.NoRunturnMethods;
17                 () => { Console.WriteLine("***this is Lamda"); };
18                 */
19                 //多播委托：可以通过-= 移除方法 （必须是同一个方法），是按照从下往上按照顺序依次匹配，只要是匹配到一个就移除，且只能移除一个，如果匹配不到，不做任何操作
20                 noRunturnNoParameter -= this.NoRunturnMethod;
21                 noRunturnNoParameter -= NoRunturnMethods;
22                 noRunturnNoParameter -= new Customclass().NoRunturnMethod;//匿名对象的方法也不能移除
23                 noRunturnNoParameter -= Customclass.NoRunturnMethods;
24                 noRunturnNoParameter -= () => { Console.WriteLine("***this is Lamda"); };//匿名函数不能移除
25                 // noRunturnNoParameter.Invoke();
26                 /*
27                执行顺序：
28                 Customclass.NoRunturnMethods
29                 new Customclass().NoRunturnMethod;
30                () => { Console.WriteLine("***this is Lamda"); };
31                */
32                 //noRunturnNoParameter.Invoke();
33                 //noRunturnNoParameter.BeginInvoke(null, null);//开启一个新的线程去完成计算，多播委托允许异步 
34                 //如果想要异步的话   可以进行遍历之后使用
35                 foreach (NoRunturnNoParameter item in noRunturnNoParameter.GetInvocationList()) 
36                 {
37                     item.BeginInvoke(null, null);
38                     item.Invoke();
39                 }
View Code

 

④事件Event/观察者模式

事件：事件和委托好像没有太大的变化 ,只是在委托的前面加了Event关键字

 1 public event Action ActionHanlder; 
事件和委托的区别?

事件 其实就是委托+event关键字，事件只能声明在当前这个事件的类的内部Invoke，即使是子类也不行 委托 可以在声明当前委托类的外部Invok; 委托是一个类,事件其实是委托的一个实例,事件是比委托更加安全

事件的应用:AspNetCoreMVC管道,Winfrom,WPF

 

posted @ 2021-07-07 13:08  .NetCat  阅读(35)  评论(0)  编辑  收藏  举报