C#高级进阶教程_04_委托、多播委托、事件

2021-10-19

字数统计: 2.3k字 | 阅读时长≈ 9分

一、委托入门知识：

01、声明变量的几种方式：

1.可以在类外面声明；
2.可以声明无参数的委托；
3.可以声明带参数的委托；
4.可以声明带返回值的委托；
5.可以声明（out、ref）参数的委托；
6.可以声明参数是泛型类型的委托。

//声明委托的几种形式：
public delegate void NoReturnNoParaOutClass();
public class MyDelegate
{
  public delegate void NoReturnNoPara<T>(T t);
  public delegate void NoReturnNoPara();
  public delegate void NoReturnWithPara(int x, int y);             //1. 声明委托
  public delegate int  WithReturnNoPara();
  public delegate string WithReturnWithPara(out int x, ref int y);//out、ref的使用
  public void Show()
  {
  }
}

02、委托的使用方式：

委托三部曲：1.声明委托。 2.委托的实例化。 3.委托实例化的调用。

public void Show()
{
  Student student = new Student()
  {
     Id = 123,
     Name = "靠谱一大叔",
     Age = 32,
     ClassId = 1
  };
  student.Study();
  {
    //把方法包装成变量（对象），invoke的时候自动执行方法
    NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);//2. 委托的实例化 （需要传入方法，签名与委托约束的一致）
    method.Invoke();                                           //3. 委托实例的调用01
    method();                                                  //3. 委托实例的调用02
    //等同于 this.DoNothing();
  }
}

03、委托的本质：

1. 把方法当作参数来传递的话，就要用到委托；

2. 委托是一个类，这个类型可以赋值一个方法的引用。

3. 继承了System.MulticastDelegate

4. 委托内置了3个方法：Invoke( ),BeginInvoke( ),EndInvoke( )

04、什么时候该使用委托？为什么要用委托？委托的意义？

** 解耦、去重**

01、增加公共逻辑方便

02、方法简单、逻辑单一职责

03、委托解藕

减少重复代码、解耦是解除了判断逻辑与共用逻辑的耦合。

04、委托传递的是逻辑（方法）

** **** 05、委托的核心思想：**** **

**
**

** 解除判断逻辑与共用逻辑的耦合，新的解决方案，就是直接传递一个行为。（本质上就是传递一个方法） **

**
**

using System;
namespace DelegateStudyDemo_20201126
{
    class Program
    {
        static void Main(string[] args)
        {
            Student student=new Student()
            {
                Id = 123,
                Name = "ljk"
            };
            //方法一：
            Console.WriteLine("——--现在执行的是方法1--——");
            student.SayHiChinese("梁老师");
            student.SayHiAmerican("Mr.L");
            student.SayHiThailand("英拉");
            //方法二：
            Console.WriteLine("\n——--现在执行的是方法2--——");
            student.SayHi("梁老师",PeopleType.Chinese);
            student.SayHi("Mr.L",PeopleType.American);
            student.SayHi("英拉",PeopleType.Thailand);
            //方法三：
            //SayHiDelegate method=new SayHiDelegate(student.SayHiChinese);//02完成委托的实例化
            //student.SayHiPerfact("ljk",method);                          //03完成委托的使用（委托作为一个变量来使用）
            Console.WriteLine("\n——--现在执行的是方法3--——");
            student.SayHiPerfact("梁老师",new SayHiDelegate(student.SayHiChinese));
            student.SayHiPerfact("Mr.L",new SayHiDelegate(student.SayHiAmerican));
            student.SayHiPerfact("英拉",new SayHiDelegate(student.SayHiThailand));
            //委托无需改动，拓展性较强，面向抽象比面向细节方便，自己升级不会影响到别人，增加修改类型，对委托无影响
            student.SayHiPerfact("小马",new SayHiDelegate(student.SayHiMalaysia));
        }
    }
}

using System;
using System.Diagnostics;

namespace DelegateStudyDemo_20201126
{
    //1.声明一个委托，在类外面，因为委托本身就是一个类
    public delegate void SayHiDelegate(string name); //委托是一种无方法体的方法；委托是一种特殊的类；

    public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public void Study()
        {
            Console.WriteLine("{0}学习.Net高级开发！！！", this.Name);
        }

        //之前不使用委托之前的思想:
        
        /* 方法一：分开写
         * 逻辑简单，便于维护，遵循了单一职责
         * 增加公共逻辑不方便
         */
        public void SayHiChinese(string name)
        {
            //Console.WriteLine($"Prepare SayHi{name}");
            Console.WriteLine($"{name},早上好！");
        }

        public void SayHiAmerican(string name)
        {
            //Console.WriteLine($"Prepare SayHi{name}");
            Console.WriteLine($"{name},GoodMorning！");
        }

        public void SayHiThailand(string name)
        {
            //Console.WriteLine($"Prepare SayHi{name}");
            Console.WriteLine($"{name},萨瓦迪卡！");
        }
        public void SayHiMalaysia(string name)
        {
            //Console.WriteLine($"Prepare SayHi{name}");
            Console.WriteLine($"{name},马来西亚！");
        }
        
        /* 写法二：加参数，判断不同分支不同逻辑
         * "巨无霸式"，拓展性不强，增加一个分支（增加类型），需要修改方法
         * 一个分支变化了，需要改方法
         * 某个分支变化可能影响到别人
         * 违背了单一职责
         * 增加公共逻辑简单方便
         */
        public void SayHi(string name, PeopleType peopleType)
        {
            Console.WriteLine($"Prepare SayHi{name}");
            switch (peopleType)
            {
                case PeopleType.Chinese:
                    Console.WriteLine($"{name}，早上好！");
                    break;
                case PeopleType.American:
                    Console.WriteLine($"{name}，GoodMorning！");
                    break;
                case PeopleType.Thailand:
                    Console.WriteLine($"{name}，萨瓦迪卡！");
                    break;
                default:
                    break;
            }
        }
        
        /* 方法三：优化方案
         * 1、增加公共逻辑方便简单
         * 2、方法简单，遵循单一职责
        */
        public void SayHiPerfact(string name, SayHiDelegate method)     //委托何时使用？怎么使用？委托的核心意义？
                                                                        /*给一个类型，判断一下，再执行一个行为？
                                                                         *直接传一个行为，把行为执行一下。面向对象中，行为=方法
                                                                         *不同的条件对应不同的行为下使用委托
                                                                         */
        {
            Console.WriteLine($"Prepare SayHi {name}");                 //这里提取出公共逻辑，单个方法里面重复的内容可以删去了
            method.Invoke(name);
            Console.WriteLine($"After SayHi {name}");                   //增加公共逻辑简单
        }
    }

    public enum PeopleType
    {
        Chinese = 0,
        American = 1,
        Thailand = 2
    }
}

以上代码解释了什么时候用委托？为什么要用委托？详细查看理解。

1. 需要把方法包裹成变量进行传递的时候。传递逻辑的时候。

2. 解耦（业务逻辑和公共逻辑解除了耦合），去重（把相同的代码提取出来了），try/catch可以提取出来。

（3）异步多线程都需要委托（多线程、线程池等的补充）（后面补充！）

二、委托的核心内容：

01、Action、Func的使用

Action是没有返回值的委托，Func是有返回值的委托。

Action、Func是.Framework3.0框架提供的，所以可以不用再手写声明定义委托。这两种类型的委托是常用的委托所以框架给出了。

02、多播委托

** ** +=为委托实例按顺序增加方法，形成方法链。Invoke时，按顺序依次执行。

-=为委托实例按顺序移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常。

需要注意：

1. 多播委托不能异步

2. GetInvocationList(); 可以找到多播委托中所有的方法。

3. 多播委托带返回值的话，以最后的为准。

4. 根据上面一条，通常利用多播委托，不是用返回值的，无意义了。

** 多播委托有什么用呢？**

多播委托：一个变量保存多段逻辑（方法），可以增减；invoke的时候可以按照顺序执行。

多播委托会让程序更稳健。

03、事件和委托的区别？

**
**

事件： 1. 避免/限制委托的实例在外面直接被invoke()或直接赋值。（安全保障）

2.“出现event只能在+=的左边”，只能赋值不能调用

3. 子类也不能调用，只能在声明的内部使用，有很好的安全保障。

委托：

1.外部可以随意篡改，不安全，清空了，event增加了安全的权限！

** 委托是一个类。事件是委托类型的一个实例（变量）。**

**
**

04、最重要的是委托、多播委托、事件、Action、Func的具体使用场景，使用方式，如何应用！

拓展内容：

** 01、事件和设计模式**

1.事件就是观察者模式的一种实现。观察者模式是面向对象的23种设计模式其中的一种。

2.事件的设计思想：事件可以把一堆可变的动作/行为封装，交给第三方指定。

3.事件不仅是一种语法，而是一种设计思想。

*** 02、事件/接口/容器的区别与联系***

1. 外部可以对事件/接口/容器随便指定添加动作。可以做到“预定义”。

2.在程序设计的时候，将程序分为两部分，一部分是固定的，直接写死；还有不固定的地方，通过一个事件开放接口，外部可以随意扩展动作。

03、框架

** ** 定制框架/封装框架。完成了固定部分（通用部分）, 把可变部分留成拓展点，支持扩展，支持自定义。

** 事件对框架的搭建非常有用！**

框架很重要，固定的部分框架制作，可变的部分使用事件拓展。**
**

例如：网站的制作。利用统一框架。整体的事情完成，小的可变部分开放出来，使用事件解决。哪些地方想拓展都留成事件，在事件上扩充。事件驱动思维。

服务端控件事件/页面加载的事件/请求集的事件/MVC的各种事件

小作业：

**
**

** 数据库增删改查的时候，利用委托写。**

“IO和序列化”前30分钟完成解决。

本文作者： 梁俊可
本文链接： http://ljk3d.com/2021/10/19/cSharpNote/CSharp高级进阶教程_04_委托、多播委托、事件/
版权声明： 梁俊可工作室