委托

  • 委托已关闭评论
  • 30 次浏览
  • A+
所属分类:.NET技术
摘要

现在有一个学生类我们可以调用一下学生中的方法我们现在多了一个这样的使用场景的问题
场景1. 学生分类?武汉人、上海人、广东人–三种不同类型的人;问候的口语不一样;
定义三种人:a.武汉 b.上海 c.广东人
问好的方式有多种;
WuHan 人: 吃了么?
GuanDong 人:靓仔/靓女~ 雷猴!
BeiJing 人: 你好!


委托

一、什么是委托,委托的本质是什么?

  1. 跟方法有点类似,有参数,返回值,访问修饰符+delegate --委托--特殊的方法?
  2. 委托的本质是什么?是方法吗?
  3. 反编译试试:发现定义的委托-----再CustomDelegate ----有对应的class
    委托
  4. 委托的本质是什么?---Class(类),继承自一个MulticastDelegate的特殊类,自己在定义类的时候,是无法继承的。包含的有构造函数和方法。
  5. 委托既然是一个类---怎么使用这个类?new ---调用方法/属性
    public class DelegateDemo    {               public delegate void NoReturnWithoutParaout();        public delegate void NoReturnWithParaout(out int x);        public delegate void NoReturnWithParaRef(ref int x);        public delegate int WithReturnWithoutPara();        public delegate int WithReturnWithPara(int x, int y);         public static void  NoReturnWithoutParaoutfunc()        {            Console.WriteLine("NoReturnWithoutParaoutfunc called!");        }         public static void NoReturnWithParaoutfunc(out int x)        {            x = 100;            Console.WriteLine("NoReturnWithParaoutfunc called!");        }         public static void NoReturnWithParaReffunc(ref int x)        {            x = 100;            Console.WriteLine("NoReturnWithParaReffunc called!");        }         public static int WithReturnWithoutParafunc()        {            Console.WriteLine("WithReturnWithoutParafunc called!");            return 100;        }         public static int WithReturnWithParafunc(int x, int y)        {            Console.WriteLine("WithReturnWithParafunc called!");            return x + y;        }      }  

二、委托的实例化

  1. ILSpy反编译--委托的本质其实是一个类
  2. 委托本质是一个类,这个类的构造参数--Method方法
  3. 委托可以通过New来实例化,要求传递一个和这个委托的参数和返回值完全匹配的方法,委托有什么参数(几个,什么类型)---完全匹配
  4. 委托的实例---可以直接指向和这个委托参数+返回值完全匹配的方法;--语法糖--编译器给我们提供便捷功能new省略掉了。
  5. 执行委托实例的Invoke方法--去执行这个委托实例化的指向的这个方法---执行方法;
  6. 就可以执行这个实例内部的三个方法
  7. 多种实例化:new、指向一个方法、指向一个lambda表达式
 NoReturnWithoutParaout noReturnWithoutParaout = new NoReturnWithoutParaout(NoReturnWithoutParaoutfunc);  noReturnWithoutParaout();   

三、委托的作用和意义

现在有一个学生类

 {      public int Id { get; set; }      public string Name { get; set; }      public int ClassId { get; set; }      public int Age { get; set; }      public Student() { }       public void SayHi()      {          Console.WriteLine("大家好,我是学员,我叫{0}", this.Name);      }      public void Study()      {          Console.WriteLine("学习.net高级班公开课");      }       public static void StudyAdvanced()      {          Console.WriteLine("学习.net高级班vip课");      }  } 

我们可以调用一下学生中的方法

{     Student stu = new Student()     {         Id = 1,         Name = "张三",         ClassId = 1,         Age = 18     };     stu.SayHi(); } 

我们现在多了一个这样的使用场景的问题
场景1. 学生分类?武汉人、上海人、广东人--三种不同类型的人;问候的口语不一样;
定义三种人:a.武汉 b.上海 c.广东人
问好的方式有多种;
WuHan 人: 吃了么?
GuanDong 人:靓仔/靓女~ 雷猴!
BeiJing 人: 你好!

问题一:如果想要增加一个地方的人;

解决方案一:(多增加几个方法)可以为每一个地方的人,各自定义一个方法

 public void SayShangHai()  {      Console.WriteLine("招招手~");      Console.WriteLine("侬好?");  }   public void SayHiWuHan()  {      Console.WriteLine("招招手~");      Console.WriteLine("吃了么?");  }   public void SayHiGuanDong()  {      Console.WriteLine("招招手~");      Console.WriteLine("靓仔/靓女~ 雷猴!");  }   public void SayHiBeiJing()  {      Console.WriteLine("招招手~");      Console.WriteLine("你好!");  }  

解决方案二:(传递参数来判断)

  /// 传入参数,分辨类型----使用枚举--避免调用方出错;   /// 不同的类型给不同的逻辑  public enum UserType {     Wuhan = 1,      GuangDong = 2,     BeiJing = 3 }     public void SayHi(UserType userType) //1.   哪儿的人  2 哪儿的人    {        Console.WriteLine("招招手~");  //只需要一句代码搞定了        switch (userType)        {            case UserType.Wuhan:                Console.WriteLine("吃了么?");                break;            case UserType.BeiJing:                Console.WriteLine("你好!");                break;            case UserType.GuangDong:                Console.WriteLine("靓仔/靓女~ 雷猴!");                break;            default:                throw new Exception("No userType");         }    } 

点评:
方案一:更好---每个方案,可以相互独立,互不干扰,逻辑没有解耦;满足单一职责;
方案二:耦合在一起,如果有需求的升级,可能需要修改原有的方案,代码可能会不稳定

问题二:如果我想要增加一些公共的业务逻辑呢?问好前---伴随一个动作---“招招手”

再比较:方案二更有有优势了; 只需要增加一句,就可以覆盖所有的人;
方案一出现了重复代码;

有没有一个完美方案呢?

自上而下比较:逻辑单一,逻辑解耦,职责单一,保证代码的稳定性;
如何写?
思路:传递参数枚举---分辨不同地方的人----给出不同的业务逻辑-----(传枚举usertype---选择逻辑)----直接传递逻辑呗; 逻辑在哪儿? 封装成一个方法; 其实就是需要传递一个方法;
问题:如何把方法当做参数来进行传递??? 啥??? 当然是委托;

 public delegate void DoHandlerDelegate();  public void SayHiPerfect(DoHandlerDelegate doHandler)  {      Console.WriteLine("保持微笑~~");      doHandler.Invoke();  }  

在主程序执行的时候

 Console.WriteLine("通过委托传递逻辑 rn"); DoHandlerDelegate doHandlerWuhan = new DoHandlerDelegate(student.SayHiWuHan); student.SayHiPerfect(doHandlerWuhan);  DoHandlerDelegate doHandlerBeiJin = new DoHandlerDelegate(student.SayHiBeiJing); student.SayHiPerfect(doHandlerBeiJin);  DoHandlerDelegate doHandlerGuangDong = new DoHandlerDelegate(student.SayHiGuanDong); student.SayHiPerfect(doHandlerGuangDong); 

问题一:增加一个上海人 --- 增加了一个方案; 方法单一; 方法相互独立,互不干扰;--稳定性,逻辑解耦

问题二:增加一个公共的业务逻辑,只需要在SayHiPerfect 增加一个动作即可;去掉重复代码;

         public void SayShangHai()         {             Console.WriteLine("招招手~");             Console.WriteLine("侬好?");         }  

主程序中

DoHandlerDelegate doHandlerShangHi = new DoHandlerDelegate(student.SayShangHai); student.SayHiPerfect(doHandlerShangHi);   

委托的价值:
1.逻辑解耦,代码的职责单一
2.去掉重复代码

建议: 如果代码中出现了严重的耦合----考虑使用委托来解决下
如果代码中,出现了大量的重复代码----考虑使用委托来解决下

四、框架内置的委托Action/Func

这里我们定义了两个相同的委托,

public delegate void DoGodDelegate(object? o); public delegate void ParameterizedThreadStart(object? o); 

我们在单独使用这2个委托的时候,并不会遇到什么问题,
我们可以发现无论是doRichard 还是threadStart 执行委托,都是执行的同一个方法;
两个委托做的事儿是一模一样;

问题

Thread thread = new Thread(threadStart); //Thread thread1 = new Thread(doRichard); //不允许的;问题:在两个结构,功能完全相同的委托;  有可能不能通用的;  不太合理??? 

Why?? 类型不一样~~
委托的本质是一个类, 多个委托就是多个不同的类, 这些没有继承关系,所以不能用;
以上问题、微软也发现了;
为了能够让委托能通用, 为了不用定义过多的委托;
微软提供了两个类功的委托: Action/Func

Action: 应对了没有返回值的委托场景;
可有可无参数,一定没有返回值的委托;最多可以有16个参数~~ 16个泛型版本
如果想要有17个参数的委托呢?(自己扩展)

 Action<int> action1 = new Action<int>(s => {  }); //接收一个int类型参数,没有返回值  Action<int,string> action2 = new Action<int, string>((i,s) => { }); //接收一个int类型参数,没有返回值  Action<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object> action3 = null;  Action<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object,int> action4 = null; 

这是一个没有返回值的通用委托---如果所有的人需要使用没有返回值的委托的时候,都用Action, 不用定义委托;委托都是同一个类型; 就可以通用了;
微软既然提供这个委托,自然是希望我们在以后的编码中,都尽可能使用这些,这样就可以统一了委托的类型;
对于以前定义的委托呢? 咋办? 解决不了~~ 这些被称为技术上的历史包袱,丢不掉~~ 以后在使用委托的时候,就不要自己定义了,直接使用现有提供的委托即可~~

委托要有返回值呢?
Func:多版本的委托:应对了有返回值的情况;
一定有返回值的委托;泛型委托Func中的最后一个类型参数,是作为返回值的类型;前面的类型参数,是作为委托的参数;也提供了最多可以有16个参数;
如果需要有17个参数,且有返回值的委托呢? 可以扩展下呗;

Func<int> func = new Func<int>(() => { return 10; }); //一个返回值的委托,没有参数; Func<int, string> func1 = new Func<int, string>(s => { return "R"; }); Func<int,string,DateTime,object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, string> func2 = null;  //17个参数; Func<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime,object, object, string> func3 = null;    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17);  public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17); 

五、委托的嵌套使用,ASP.NET CORE中间件的核心设计----委托的多层嵌套

这里创建一个很基础的一个类

 public class DelegateExtension  {      public static void Show()      {          InvokeAction invokeAction = new InvokeAction();          {                        }        }  }   public class InvokeAction {      public void ExeMethod()      {          Console.WriteLine("Exec ExeMethod");      }  } 

问题:想要去在Invoke.Show方法前后,扩展一些业务逻辑.

这里根据我们之前上面拓展出来的知识可以写出来这样的代码

    public static void Show()     {         InvokeAction invokeAction = new InvokeAction();         {             Action action = new Action(invokeAction.ExeMethod);             //再次定义委托             {                 Func<Action, Action> action2 = new Func<Action, Action>(ExeNextMethod006);                 Action action3 = action2.Invoke(action);                 action = action3;                  Func<Action, Action> action4 = new Func<Action, Action>(ExeNextMethod005);                 Action action5 = action4.Invoke(action);                 action = action5;                   Func<Action, Action> action6 = new Func<Action, Action>(ExeNextMethod004);                 Action action7 = action6.Invoke(action);                 action = action7;                   Func<Action, Action> action8 = new Func<Action, Action>(ExeNextMethod003);                 Action action9 = action8.Invoke(action);                 action = action9;                   Func<Action, Action> action10 = new Func<Action, Action>(ExeNextMethod002);                 Action action11 = action10.Invoke(action);                 action = action11;                  Func<Action, Action> action12 = new Func<Action, Action>(ExeNextMethod001);                 Action action13 = action12.Invoke(action);                 action = action13;                  action.Invoke();             }                      }     }      public static Action ExeNextMethod001(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod001 Start");             action();             Console.WriteLine("Exec ExeNextMethod001 End");         });     }      public static Action ExeNextMethod002(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod002 Start");             action();             Console.WriteLine("Exec ExeNextMethod002 End");         });     }      public static Action ExeNextMethod003(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod003 Start");             action();             Console.WriteLine("Exec ExeNextMethod003 End");         });     }     public static Action ExeNextMethod004(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod004 Start");             action();             Console.WriteLine("Exec ExeNextMethod004 End");         });     }      public static Action ExeNextMethod005(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod005 Start");             action();             Console.WriteLine("Exec ExeNextMethod005 End");         });     }      public static Action ExeNextMethod006(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod006 Start");             action();             Console.WriteLine("Exec ExeNextMethod006 End");         });     } }    public class InvokeAction {     public void ExeMethod()     {         Console.WriteLine("Exec ExeMethod");     } }  

我希望无限制的 增加扩展业务逻辑;
再增加一个--定义方法,通过委托包装后去当做参数传递;
现在的代码已经做到了
1.已经做到了职责的单一;
2.但是当前这个 DelegateExtension.Show 方法不太稳定,如果要增加一环,我需要修改DelegateExtension.Show方法
思路:可以把要执行的业务逻辑----特性--封装到特性中去;

public static void Show() {     InvokeAction invokeAction = new InvokeAction();     {                 {             Type type= typeof(InvokeAction);             MethodInfo method = type.GetMethod("ExeMethod");              ExecNextMethod001Attribute attribute1 = method.GetCustomAttribute<ExecNextMethod001Attribute>();             Action action=new Action(()=> { method.Invoke(invokeAction, null); });             action=attribute1.Do(action);              ExecNextMethod002Attribute attribute2 = method.GetCustomAttribute<ExecNextMethod002Attribute>();             action = attribute2.Do(action);              ExecNextMethod003Attribute attribute3 = method.GetCustomAttribute<ExecNextMethod003Attribute>();             action = attribute3.Do(action);              ExecNextMethod004Attribute attribute4 = method.GetCustomAttribute<ExecNextMethod004Attribute>();             action = attribute4.Do(action);              action.Invoke();          }              } } [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod001Attribute: Attribute {    public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod001 Start");             action();             Console.WriteLine("Exec ExeNextMethod001 End");         });     } } [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod002Attribute : Attribute {     public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod002 Start");             action();             Console.WriteLine("Exec ExeNextMethod002 End");         });     } }  [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod003Attribute : Attribute {     public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod003 Start");             action();             Console.WriteLine("Exec ExeNextMethod003 End");         });     } }  [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod004Attribute : Attribute {     public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod004 Start");             action();             Console.WriteLine("Exec ExeNextMethod004 End");         });     } }   [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod005Attribute : Attribute {     public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod005 Start");             action();             Console.WriteLine("Exec ExeNextMethod005 End");         });     } }   [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod006Attribute : Attribute {     public Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod006 Start");             action();             Console.WriteLine("Exec ExeNextMethod006 End");         });     } } 

思路:因为类型不一样,所以只能一个一个的判断;
如果能一次获取所有特性(矛盾,类型不一样,没有办法一次获取所有;????统一类型,如何统一类型?? 来一个父类,让特性继承父类,然后在获取特性的时候,通过父类获取;):放在一个集合中,要逐个的调用特性的Do方法来包装委托的话,就可以循环执行;

public static void Show() {     InvokeAction invokeAction = new InvokeAction();     Type type = typeof(InvokeAction);     MethodInfo method = type.GetMethod("ExeMethod");      Action action = new Action(() => { method.Invoke(invokeAction, null); });      IEnumerable<ExecNextMethodAbstractAttribute> attributellist = method.GetCustomAttributes<ExecNextMethodAbstractAttribute>();      foreach (var attribute in attributellist.Reverse())     {         action = attribute.Do(action);     }     action.Invoke();    }  [AttributeUsage(AttributeTargets.Method)] public abstract class ExecNextMethodAbstractAttribute : Attribute {     public abstract Action Do(Action action);  } [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod001Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod001 Start");             action();             Console.WriteLine("Exec ExeNextMethod001 End");         });     } } [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod002Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod002 Start");             action();             Console.WriteLine("Exec ExeNextMethod002 End");         });     } }  [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod003Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod003 Start");             action();             Console.WriteLine("Exec ExeNextMethod003 End");         });     } }  [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod004Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod004 Start");             action();             Console.WriteLine("Exec ExeNextMethod004 End");         });     } }   [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod005Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod005 Start");             action();             Console.WriteLine("Exec ExeNextMethod005 End");         });     } }   [AttributeUsage(AttributeTargets.Method)] public class ExecNextMethod006Attribute : ExecNextMethodAbstractAttribute {     public override Action Do(Action action)     {         return new Action(() =>         {             Console.WriteLine("Exec ExeNextMethod006 Start");             action();             Console.WriteLine("Exec ExeNextMethod006 End");         });     } } 

这样就可以让我们自己在搭建框架的时候(支持了业务的扩展---AOP扩展---装饰器模式的番外篇),可以让程序员在使用我们这个框架的时候,更加聚焦业务逻辑;
可以动态增加业务逻辑;

六、多播委托/观察者模式

委托还可以通过+= 把更多的方法包装到委托中来,形成一个方法的执行链子
在执行委托的时候,可以按照+=的顺序,把方法逐个执行;
也提供了-= 操作,可以按照顺序把方法从方法链子中,依次移除;移除按照顺序依次移除,只要是匹配移除一个之后,就不在继续移除了;如果要移除的方法在,委托中不存在,-=就不做任何操作;

委托在+=,-=可以操作哪些方法呢?

  • 静态方法
  • 实例方法
  • lamdba表达式
  • 普通方法
 public void Show()  {      {          Action action = new Action(DoNothing);                   action += DoNothing;          action += DoNothing;          action += DoNothing;          action += DoNothing;                          action -= DoNothing;                    action.Invoke();      }       //委托在+=  、 -=可以操作哪些方法呢?      {          Action action = new Action(DoNothing);          action += DoNothingStatic; //+=静态方法          action += new Student().Study; //+=实例方法          action += () => { Console.WriteLine("this is Lambda"); };           //action.Invoke();  //都会依次执行           action -= DoNothing;    //普通方法          action -= DoNothingStatic;  //静态方法          action -= new Student().Study;  //实例方法          action -= () => { Console.WriteLine("this is Lambda"); }; //Lambda 表达式           action.Invoke();      }   }  private void DoNothing()  {      Console.WriteLine("This is DoNothing");  }     private static void DoNothingStatic()  {      Console.WriteLine("This is DoNothingStatic");  } 
  • 版权声明:本站原创文章,于2024年3月1日15:08:01,由 发表,共 14080 字。
  • 转载请注明:委托 - 张拓的天空