委托（续）

委托事件

① 委托的多中实例化

{            Console.WriteLine("---------委托的多种实例化--------------");
            {
             //this 当前所在类的  
                NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(this.NoRunturnMethod);
            }
            {
                //当前所在的静态类
                NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(NoRunturnMethods);
            }
            {
                /*
              public class Customclass
              {  public void NoRunturnMethod() { }
                public static void NoRunturnMethods() { }
               }
                */
                NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(new Customclass().NoRunturnMethod);
            }
            {
                NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(Customclass.NoRunturnMethods);

            }
}

②Action/Func

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

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

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

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

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

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

    Console.WriteLine("***********Action/Func**************");
                //Action:是系统给我们提供的一个委托,是一个没有返回值,可以有参数的委托;最多可以有16个泛型参数,可以自己后期添加
                //Action action = new Action(this.NoRunturnMethod);
                { Action<int> method = new Action<int>((a) => { Console.WriteLine(a.GetType().Name); }); }
                { Action<int, string> method = new Action<int, string>((a, b) => { Console.WriteLine(a.GetType().Name); Console.WriteLine(b.GetType().Name); }); }
                { Action<int, object, string> method = new Action<int, object, string>((a, b, c) => { Console.WriteLine(a); }); }

                //Func:是系统给我们提供的一个委托,是一个必须有返回值,可以有参数的委托;最多可以有16个泛型参数,可以自己后期添加
                { Func<string> func = () => { return ""; }; }
                { Func<string> func = null; }

                //为什么框架要给我们提供这两个委托呢?   既然是框架提供的委托,是希望我们就是用这两个委托
                new Thread(new ParameterizedThreadStart((a) => { Console.WriteLine("a"); }));
                ThreadPool.QueueUserWorkItem(new WaitCallback((a) => { Console.WriteLine("a"); }));
                new Thread(new ParameterizedThreadStart(new WaitCallback((a) => { Console.WriteLine("a"); })));//委托不能这么使用?
                //委托的本质的一个类 定义的不用的委托其实就是不用的类 这些类没有父子级关系,不能替换,但是这些委托参数和返回值又都是一致的
                //所有推荐以后使用委托的时候就不需要自己定义了.直接使用Action /Func
                //为了避免大家在开发的过程中定义了过多的委托, 
                //那为什么我们还是可以自定义委托呢?!  因为历史原因,以前的框架中,使用了各种委托
                //C#是向前兼容

③多播委托

1.我们创建的每一个委托都是多播委托

2.多播委托可以在实例化以后，可以通过+=添加和当前委托参数返回值完全一样的多个方法，形成方法链。在调用Invoke方法的时候 会按照+=的顺序依次执行 【重载方法是不添加不上的】

3.可以通过-= 移除方法 （必须是同一个方法），是按照从下往上按照顺序依次匹配，只要是匹配到一个就移除，且只能移除一个，如果匹配不到，不做任何操作

4.多播委托允许异步

     Console.WriteLine("---------------多播委托------------------------");
                //多播委托可以在实例化以后，可以通过+=添加和当前委托参数返回值完全一样的多个方法，形成方法链。在调用Invoke方法的时候 会按照+=的顺序依次执行  【重载方法是不添加不上的】
                NoRunturnNoParameter noRunturnNoParameter = new NoRunturnNoParameter(Customclass.NoRunturnMethods);
                noRunturnNoParameter += this.NoRunturnMethod;
                noRunturnNoParameter += NoRunturnMethods;
                noRunturnNoParameter += new Customclass().NoRunturnMethod;
                noRunturnNoParameter += Customclass.NoRunturnMethods;
                noRunturnNoParameter += () => { Console.WriteLine("***this is Lamda"); };
                // noRunturnNoParameter.Invoke();
                /*
                执行顺序：
                 Customclass.NoRunturnMethods
                 this.NoRunturnMethod;
                 NoRunturnMethods;
                 new Customclass().NoRunturnMethod;
                 Customclass.NoRunturnMethods;
                () => { Console.WriteLine("***this is Lamda"); };
                */
                //多播委托：可以通过-= 移除方法 （必须是同一个方法），是按照从下往上按照顺序依次匹配，只要是匹配到一个就移除，且只能移除一个，如果匹配不到，不做任何操作
                noRunturnNoParameter -= this.NoRunturnMethod;
                noRunturnNoParameter -= NoRunturnMethods;
                noRunturnNoParameter -= new Customclass().NoRunturnMethod;//匿名对象的方法也不能移除
                noRunturnNoParameter -= Customclass.NoRunturnMethods;
                noRunturnNoParameter -= () => { Console.WriteLine("***this is Lamda"); };//匿名函数不能移除
                // noRunturnNoParameter.Invoke();
                /*
               执行顺序：
                Customclass.NoRunturnMethods
                new Customclass().NoRunturnMethod;
               () => { Console.WriteLine("***this is Lamda"); };
               */
                //noRunturnNoParameter.Invoke();
                //noRunturnNoParameter.BeginInvoke(null, null);//开启一个新的线程去完成计算，多播委托允许异步 
                //如果想要异步的话   可以进行遍历之后使用
                foreach (NoRunturnNoParameter item in noRunturnNoParameter.GetInvocationList()) 
                {
                    item.BeginInvoke(null, null);
                    item.Invoke();
                }

④事件Event/观察者模式

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

 public event Action ActionHanlder; 

事件和委托的区别?

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

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