VB.net 2010 视频教程 VB.net 2010 视频教程 VB.net 2010 视频教程
当前位置:
首页 > 编程开发 > C#编程 >
  • c#教程之C#委托的一次"甜蜜"接触

  • 2018-12-16 21:19 来源:未知

委托是个说烂了的话题,但是依旧有好多人不知道为什么要在C#中使用委托,最近有朋友也问到我这个问题,所以举例些场景,以供那些知道怎么声明委托、怎么调用却不知道为什么要用的朋友一些参考,当然也是希望验证下自己的理解是否正确。

如何声明一个委托

委托使用关键字delegate,从外形上看和一个没有方法体的方法一样,只不过是多了个关键字。

    public delegate void MyDelegateHandler();//无返回值,无参数
    public delegate int MyDelegateHandler1();//有返回值,无参数
    public delegate object MyDelegateHandler2(string name);//有返回值,有参数
    public delegate object MyDelegateHandler3(object first,ref int second,out float third, params object[] args);//有返回值,多个返回值

委托的声明可以放在类的外面,也可以在类的内部

    public delegate object MyDelegateHandler2(string name);//有返回值,有参数
    static class Program
    {
        public delegate void MyDelegateHandler();//无返回值,无参数
    }

C#内置的委托类型

在.NET Framework中定义了大量的委托类型,像什么WaitCallback、ParameterizedThreadStart、EventHandler、...,为了兼容旧版本所以一直没去掉,从.NET Framework 3.5后你可以使用Action、和Func(带返回值)来更简单的使用委托,他们都定义了大量的重载版本

委托的使用

下面是流年写的一个计算器类(比较简陋),里面有各种运算方法,每个方法只干一件事,恩,满足了单一原则,棒棒的!

    public class Calculator
    {
        public static int Add(int first, int second)
        {
            return first + second;
        }

        public static int Sub(int first, int second)
        {
            return first - second;
        }
    }

流年很简单的就使用了这个类里的方法,哇,毫无压力

 var result = Calculator.Add(1, 6);

现在问题来了“在做运算前,需要去验证每个参数(假设这里希望使用的参数都是正整数)”,╮(╯▽╰)╭每个方法都需要去加一段代码

  public static int Add(int first, int second)
  {
      if (first <= 0 || second <= 0)
      {
          throw new ArgumentException("参数错误");
      }
      return first + second;
  }

一个方法一个方法的去改,很是麻烦,干脆我把计算直接写一个方法里,三下五除二,流年开始啪,啪,啪...

  public static int Calc(int first, int second, string operater)
  {
      if (first <= 0 || second <= 0)
      {
          throw new ArgumentException("参数错误");
      }
      int result = 0;
      if (operater.Equals("+"))
      {
          result = first + second;
      }
      if (operater.Equals("-"))
      {
          result = first - second;
      }
      return result;
  }

OK,搞定,很简单嘛,但仔细一看,我靠Calc计算方法中干了那么多事情,又是加又是减的,如果计算器类还要添加对乘法的支持,还需要再修改这个方法,代码耦合度太高了,这不就违背了对扩展开放,对修改关闭的原则了嘛。就在这时,天空乌云密布,一道闪电击中了流年的脑袋...
首先我们来看,这段代码的变化点是什么?运算方法嘛
有什么办法可以隔离这种变化呢?委托嘛

 public static int Calc(int first, int second, Func<int, int, int> handler)
 {
     if (first <= 0 || second <= 0)
     {
         throw new ArgumentException("参数错误");
     }
     return handler.Invoke(first, second);//更简单的写法handler(first, second)
 }
  Func<int, int, int> calcHandler = new Func<int, int, int>(Calculator.Add);
  var result = Calculator.Calc(1, 6, calcHandler);

这样不用去改变原来的方法,Add还是Add,减法运算还是减法运算,就算再添加乘/除算法,直接添加加乘/除算法相关的方法就行,也不用去改动原来的代码了。而且算法选择逻辑也是交给的客户端,而不是方法内部。将变化隔离了出去。

更简单的使用委托

上面的委托实例声明好麻烦,那我们再改进改进,可以将方法直接赋值给委托实例

  Func<int, int, int> calcHandler = Calculator.Add;
  var result = Calculator.Calc(1, 6, calcHandler);

再改进改进,直接将方法当做实参传递

 var result = Calculator.Calc(1, 6, Calculator.Add);

此刻,有没有一种想把委托按在床上的冲动。不要着急,这还只是前戏...

Lambda表达式

在上面我们提到可以将一个方法直接赋值给实例,那么是不是直接就可以将匿名方法直接赋值给委托实例呢?废话不说,直接试试就知道了

 Func<int, int, int> calcHandler = delegate (int first, int second)
 {
     return first - second;
 };
 var result = Calculator.Calc(1, 6, calcHandler);

这就完了?当然没有,让我们继续挑逗匿名方法

既然说,calcHandler 实例的引用是指向匿名方法的,那么是不是可以直接将匿名方法直接渗入Calculator.Calc方法的参数中

 var result = Calculator.Calc(1, 6,delegate (int x, int y){return x - y;});

基于匿名函数,从Visual Studio 2010开始,微软将匿名函数又升级成了Lambda表达式,代码是越来越简洁,连TMD方法都不用创建了,直接将算法写在调用上。

var result = Calculator.Calc(1, 6, (a, b) => a * b);

而且为了方便对集合类型的操作,微软还封装了大量的Linq扩展方法,这些都是基于委托实现的

 int[] numbers = { 11, 4, 3, 89, 5, 10 };
 //获取集合中大于10的数字
 var query = numbers.Where(w => w > 10);

提供异步调用

还是回到原来的代码,Calculator类中委托调用的地方handler.Invoke(first, second),如果说委托实例对应的方法是个耗时的操作,我想我们谁也不想直接同步调用,让程序傻傻的死在那里,至少给用户一些提示。为了处理这种问题,我们可以直接使用委托的异步调用

    public class Calculator
    {
        public static int Add(int first, int second)
        {
            Console.WriteLine($"Add Thread Id {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(500);//模拟耗时的操作
            return first + second;
        }

        public static int Sub(int first, int second)
        {
            return first - second;
        }

        public static int Calc(int first, int second, Func<int, int, int> handler)
        {
            Console.WriteLine($"Calc Thread Id {Thread.CurrentThread.ManagedThreadId}");
            if (first <= 0 || second <= 0)
            {
                throw new ArgumentException("参数错误");
            }
            var ir = handler.BeginInvoke(first, second, null, null);
            Console.WriteLine("还在计算当中...");
            //等待计算结果
            return handler.EndInvoke(ir);
        }
    }


最后一行代码handler.EndInvoke(ir),作用是等待异步调用返回结果。他会一直阻塞线程直到异步调用完成,然后返回计算的结果值。
委托异步调用方法的返回值为一个IAsyncResult接口,我们可以通过该接口的实例属性IsCompleted轮询判断异步是否调用完成。
在异步调用的方法参数中,有一个委托类型AsyncCallback,我们可以将一个函数传给他,异步方法执行完的时候会自动的去调用这个方法,这也就是所谓的回调函数。在回调函数中我们就可以干些别的事情,比如定义个事件将结果传递出去

  //定义一个计算完成事件
  public static event Action<int> OnCalcCompelted;
   var ir = handler.BeginInvoke(first, second,
       (o) =>
       {
           var result = handler.EndInvoke(o);
           //通过事件通知注册用户计算已经完成,并将结果传递出去
           if (OnCalcCompelted!=null)
           {
               OnCalcCompelted(result);
           }
       }, 
       null);
   Console.WriteLine("还在计算当中...");

结语:
方法与委托就好比普通类与接口(抽象类)的关系。
编码过程中委托并不一定是强制使用,他只不过是一种实现方式,在某些场景下比较合适,所以不要纠结于是要调用方法还是要通过委托调用,就像不懂设计模式也可以写代码完成功能,但是懂得这些套路之后你的代码会更加有条理,更具有扩展性,当然逼格也越高。但是,我觉得不用模式套路的代码逼格更高,谁都看不懂 O(∩_∩)O哈哈~

回到我们的Calculator类,如果需求是Calculator中只要实现加法运算,那TMD的谁还用委托,直接实现一个加法方法就行了,就这么简单。
涉及到委托的使用还不仅仅是这些,像什么事件、表达式树...每个都可以单独作为主题来讲,而且园子里也有很多讲解的文章。流年水平有限,就简单写到这里。

相关教程