C# 委托简述

14 阅读 0 评论 0 点赞

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#中的委托和事件 - 雾中人 - 博客园

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

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » C# 委托简述

点赞(0) 打赏

本文分类：文章资讯
本文标签：C# 委托简述
浏览次数：14 次浏览
本文链接：https://freeymw.com/article/34272.html

上一篇 > httpd服务
下一篇 > Kafka 为什么要抛弃 Zookeeper？

评论列表共有 0 条评论

暂无评论