当前位置： 首页 > article >正文

C# 委托简述

article 2024/10/25 13:04:24

1.委托

    1.1什么是委托

委托委托        官网解释: 委托是安全封装方法的类型，类似于 C 和 C++ 中的函数指针。 与 C 函数指针不同的是，委托是面向对象的、类型安全的和可靠的。 委托的类型由委托的名称确定。

        个人理解:委托就是一个方法的模板。它可以接收签名(签名一致就是方法的参数与返回值类型与其一致)与它一致的方法作为参数传递给它执行。

     1.2 如何定义委托

                使用关键字 delegate 声明委托

public delegate int GetNum(int a, int b);

                除了使用delegate 定义 委托以外C#提供两个定义好的泛型委托 (Action 与 Func) (当然你也可以使用delegate自定义泛型委托)

这里先介绍两个C#定义的委托，相信很多人都在使用，不管你清不清楚什么是委托

Action:是无返回值的泛型委托。

下面action 表示无参，无返回值的委托

private void WTBtn_Click(object sender, EventArgs e)
{
    Action action = new Action(AA);//定义委托
    action();//使用方式1
    action.Invoke();//使用方式2
}


private void AA()
{
    Console.WriteLine("我是传入的无参无返回值的委托方法");
}

下面action 表示有传入参数int,string无返回值的委托

private void WTBtn_Click(object sender, EventArgs e)
{
    Action<int,string> action = new Action<int, string>(AA);
    action(1,"");//使用方式1
    action.Invoke(1, "");//使用方式2
}


private void AA(int a,string b)
{
    Console.WriteLine("我是传入的有参无返回值的委托方法");
}

Func:是有返回值的泛型委托。Func<object,string,int> object,string为参数。int为返回值

下面action 表示有传入参数int返回值string的委托

private void WTBtn_Click(object sender, EventArgs e)
{
    Func<int,string> action = new Func<int, string>(AA);
    //a=b="我是传入的有参无返回值的委托方法"
    var a =  action(1);//使用方式1
    var b= action.Invoke(1);//使用方式2
}


private string AA(int a)
{
    Console.WriteLine("我是传入的有参无返回值的委托方法");
    return "我是传入的有参无返回值的委托方法";
}

        运行结果如下图:

下面action 表示有无参数有返回值string的委托

private void WTBtn_Click(object sender, EventArgs e)
{
    Func<string> action = new Func<string>(AA);
    //a=b="我是传入的有参无返回值的委托方法"
    var a =  action();//使用方式1
    var b= action.Invoke();//使用方式2
}


private string AA()
{
    Console.WriteLine("我是传入的有参无返回值的委托方法");
    return "我是传入的有参无返回值的委托方法";
}

 C#自带的委托说完了，下面说 delegate 自定义的委托

下面代码定义了一个委托和一个静态类的方法。委托的级别与类等同，所以可以定义在命名空间里，当然也能定义在类里。

 /// <summary>
 /// 定义委托
 /// </summary>
 /// <param name="a"></param>
 /// <param name="b"></param>
 /// <returns></returns>
 public delegate int GetNum(int a, int b);
 public static class WTModel
 {
     /// <summary>
     /// 加法
     /// </summary>
     /// <param name="a"></param>
     /// <param name="b"></param>
     /// <returns></returns>
     public static int Add(int a,int b)
     {
         Console.WriteLine("执行Add了方法");
         return a + b;
     }

     /// <summary>
     /// 减法
     /// </summary>
     /// <param name="a"></param>
     /// <param name="b"></param>
     /// <returns></returns>
     public static int Sub(int a, int b)
     {
         Console.WriteLine("执行Sub了方法");
         return a - b;
     }

     /// <summary>
     /// 乘法
     /// </summary>
     /// <param name="a"></param>
     /// <param name="b"></param>
     /// <returns></returns>
     public static int Multi(int a, int b)
     {
         Console.WriteLine("执行Multi了方法");
         return a * b;
     }

     /// <summary>
     /// 除法
     /// </summary>
     /// <param name="a"></param>
     /// <param name="b"></param>
     /// <returns></returns>
     public static int Division(int a, int b)
     {
         Console.WriteLine("执行Division了方法");
         if (b == 0)
         {
             return 0;
         }

         return a / b;
     }
 }

定义的GetNum委托与C#自带的两个委托是同级的，使用方式也是一页，只不C#自带的是泛型的，GetNum却是固定了两个参数为int类型且返回值是int类型的签名。故此能传入GetNum的方法的参数与返回值必须与GetNum保持一致。

使用方式:下面将上面Add方法传入委托并执行。

private void WTBtn_Click(object sender, EventArgs e)
{

    //实例化方式1
    GetNum num = new GetNum(WTModel.Add);
    //使用方法1
    var a = num(1, 2);
    //使用方法2
    var b = num.Invoke(1, 2);
}

执行结果:

值得注意的是，上述的委托执行方式都是同步的，并不是说把方法给到委托就会自动开启新的线程。看下面执行例子:

private void WTBtn_Click(object sender, EventArgs e)
{


    //实例化方式1
    GetNum num = new GetNum(WTModel.Add);
    //使用方法1
    var a = num(1, 2);
    //使用方法2
    var b = num.Invoke(1, 2);

    Console.WriteLine("我是一定是最后执行的");

}

 执行结果可初步看出是在委托执行了两次Add方法调用后才打印最后一段文字的(当然此处并不严谨，用于说明同步足够了):

那么如何异步执行呢 ，这里就不得不提BeginInvoke了 ，如下:

 private void WTBtn_Click(object sender, EventArgs e)
 {


     //实例化方式1
     GetNum num = new GetNum(WTModel.Add);
     //使用方法1
     var a = num(1, 2);
     //使用方法2
     //倒数第二个参数为回调函数，暂用null，
     //最后一个参数是给回调函数传入参数的参数，暂用null
     //IAsyncResult result = num.BeginInvoke(1, 2, null, null);
     var b = num.BeginInvoke(1,2,null,null);
     Console.WriteLine("我是不一定是最后执行的了");
 }

运行结果你看第二次调用Add就不一样了吧:

BeginInvoke在NetCore不支持，NetFamework支持 NetCore有更好的多线程功能来支持实现类似功能。所以在NET Core中需要自己手动去开启线程和实现异步。例如下面(在Famework里也可以这样使用异步):

 /// <summary>
 /// 定义委托
 /// </summary>
 /// <param name="a"></param>
 /// <param name="b"></param>
 /// <returns></returns>
 public delegate Task<int> GetNum(int a, int b);
  public static class WTModel
  {
      /// <summary>
      /// 加法
      /// </summary>
      /// <param name="a"></param>
      /// <param name="b"></param>
      /// <returns></returns>
      public static Task<int> Add(int a, int b)
      {
          return Task.Run(() =>
          {
              Console.WriteLine("执行Add了方法");
              return a + b;
          });
      }
}
 private void WTBtn_Click(object sender, EventArgs e)
 {


     //实例化方式1
     GetNum num = new GetNum(WTModel.Add);
     //使用方法1
     var a = num(1, 2);
     //使用方法2
     var b = num.Invoke(1,2);

     Console.WriteLine("我是不一定是最后执行的了");
 }

执行结果:

1.3:多播委托

所谓多播委托就是给委托传了多个方法，执行委托的时候会按照传入的顺序依次执行方法，当然传入的方法要注意错误处理，否则中件某个方法异常会导致后续方法无法执行，若委托有返回值，返回的值是最后一个方法的返回值。

定义多播(+=或者-=):

 private void WTBtn_Click(object sender, EventArgs e)
 {
     //多播委托
     //实例化方式1
     GetNum num = new GetNum(WTModel.Add);
     GetNum num1 = WTModel.Multi;//实例化方式2
     num += num1;
     num += WTModel.Sub;
     var c = num(1, 2);//调用一次会依次执行Add、Multi、Sub方法最终返回的值是最后一个委托的方法的返回值。
 }

 

1.4 实际应用 

说了这么多，委托到底好在哪里呢，很多人都有这个疑问吧。下面举个例子就知道了 。

仍以上面定义的GetNum委托和其四个方法为基础。

正常我们要算加法直接使用Add方法不久一步到位了吗，为何还需要多此一举定义个委托来完成调用呢，这应该是很多看到这里的人的疑惑。

场景一:委托作为参数执行不同的方法，这样在WTBtn_Click方法中就只用调用Use1就能计算不同的值:

private void WTBtn_Click(object sender, EventArgs e)
{
    Use1(1, 2, WTModel.Add);
    Use1(1, 2, WTModel.Sub);
    Use1(1, 2, WTModel.Multi);
    Use1(1, 2, WTModel.Division);
}

private void Use1(int a, int b, GetNum num)
{
    var A = num(1, 2);
}

场景2:实现根据不同地方输出产出的水果是啥

方法1：if或者switch以switch为例:

private string Use(string name)
{
    string a = "";
    switch (name)
    {
        case "广州": a = "苹果"; break;
        case "重庆": a = "香蕉"; break;
        case "四川": a = "梨"; break;
        case "广西": a = "西瓜"; break;
        default: break;
    }
    return a;
}

 使用:

Console.WriteLine(Use("广州"));

方法2：定义四个方法，分别调用方法

public static class WTModel
{

    public static void GZ(string name)
    {
        if (name == "广州")
        {
            Console.WriteLine("苹果");
            
        }
    }


    public static void CQ(string name)
    {
        if (name == "重庆")
        {
            Console.WriteLine("香蕉");
        }
    }


    public static void SC(string name)
    {
        if (name == "四川")
        {
            Console.WriteLine("梨");
            
        }
       
    }

    
    public static void GX(string name)
    {
        if (name == "广西")
        {
            Console.WriteLine("西瓜");
           
        }
    }
}

使用:

private void WTBtn_Click(object sender, EventArgs e)
{
    string name = "广州";
    WTModel.GZ(name);
    WTModel.GX(name);
    WTModel.CQ(name);
    WTModel.SC(name);
    
}

方法3、使用委托:

定义委托和其四个方法

 /// <summary>
 /// 定义委托
 /// </summary>
 /// <param name="a"></param>
 /// <param name="b"></param>
 /// <returns></returns>
 public delegate void GetName(string name);
 public static class WTModel
 {
     
     public static void GZ(string name)
     {
         if (name == "广州")
         {
             Console.WriteLine("苹果");
             
         }
     }

     
     public static void CQ(string name)
     {
         if (name == "重庆")
         {
             Console.WriteLine("香蕉");
         }
     }


     public static void SC(string name)
     {
         if (name == "四川")
         {
             Console.WriteLine("梨");
             
         }
        
     }


     public static void GX(string name)
     {
         if (name == "广西")
         {
             Console.WriteLine("西瓜");
            
         }
     }
 }

使用委托:

private void WTBtn_Click(object sender, EventArgs e)
{
    GetName get = WTModel.GZ;
    get += WTModel.GX;
    get += WTModel.CQ;
    get += WTModel.SC;
    Use("广州", get);
}

private void Use(string name, GetName get)
{
    get.Invoke(name);
}

三个方法都可以实现根据地方不同输出相应水果。调用结果都是如下;

从三个方法写法和调用来看似乎方法一最为简单。

那么，现在你的程序已经是开发好了，这个时候突然来了两个需求。

需求1：新增一个地方的水果:

方法一需要新增一行case代码 。

方法二需要新增一个方法。

方法三需要新增一个方法。

看起来仍是方法一简单，但是 如果你使用的是是打包好的DLL文件，那么你就没办法直接增加代码，除非能重写方法。

需求2:在输出水果前先输出产地。

方法一 需要编辑每行case代码 。

方法二 需要编辑每个方法。

方法三 仅需在Use方法里新增一行即可。

若你使用的是是打包好的DLL文件且方法无法被重写，那似乎仅方法三能满足需求。

1.5 事件

本来准备单独说的，但事件本质是基于委托实现的观察者模式的应用。贴两个觉得可以的链接自行去看吧。

事件的理论即使用注意:C# 事件（event）_c# event-CSDN博客

事件的应用理解:分分钟用上C#中的委托和事件 - 雾中人 - 博客园

结语:个人认为委托的主要作用在于实现代码的重用，业务的解耦，保持代码的稳定性以及扩展性。暂时就说这么多吧，仅个人理解。


http://www.kler.cn/news/364440.html

相关文章：

  • 2024年双十一有什么好物推荐？盘点2024双十一爆款好物分享
  • STM32 C语言基础知识
  • Leetcode 140 Word Break II
  • FPGA第 13 篇，使用 Xilinx Vivado 创建项目，点亮 LED 灯，Vivado 的基本使用（点亮ZYNQ-7010开发板的LED灯）
  • Deepinteraction 深度交互:通过模态交互的3D对象检测
  • C语言程序设计：现代设计方法习题笔记《chapter3》
  • ifconfig 和 ip addr
  • jmeter中csv data set config的Sharing mode和loop控制器结合使用
  • 重修设计模式-行为型-访问者模式
  • Github + 自定义域名搭建个人静态站点
  • TensorFlow面试整理-TensorFlow 结构与组件
  • Python Web 框架中 Django 框架
  • Scrapy | 通过爬取豆瓣Top250电影信息来学习在中间件中应用随机请求头和代理ip
  • C++：排序算法
  • Spring Cloud --- GateWay和Sentinel集成实现服务限流
  • pycharm中使用ctrl+鼠标滚轮改变字体大小
  • 微积分复习笔记 Calculus Volume 1 - 3.6 The Chain Rule
  • 直觉微调——简化语言模型对齐过程
  • opencv学习笔记(4)：图像属性和基本图形绘制
  • 【纯血鸿蒙】HarmonyOS和OpenHarmony 的区别
  • 【LInux】Shell脚本编写基本语法
  • 快速获取 GitHub 个人资料成就徽章
  • LinkedList 源码分析
  • 数据清洗的具体方法有哪些？
  • 数字+文旅：虚拟数字人盘活景区文化旅游资源新策略
  • ajax 读取文件