C # 委托

云卷678

已于 2024-02-08 09:36:57 修改

阅读量554

点赞数 9

文章标签： c# 开发语言

于 2024-02-04 18:30:48 首次发布

本文链接：https://blog.csdn.net/weixin_61884921/article/details/136023082

版权

1.什么是委托

委托是函数指针的“升级版”，委托是一种类，类是数据类型，所以委托也是一种数据类型，委托与类都属于引用类型。

指向多个方法的委托叫做多播委托。

2.直接调用与间接调用

函数的两种调用方式：直接调用/间接调用显而易见的，通过委托调用函数属于间接调用。

3.自定义委托

  //委托的声明
  public delegate void MyDelegate();// ←（这里声明的委托参数列表为空）//注意！ 该委托声明在名称空间体内 而不是在类体里
   //        ↑       ↑
  //delegate关键字  返回值类型（这里声明的委托返回值类型为空）
  //该委托就可以指向Log方法，因为Log方法的返回值类型为空，且参数列表为空！ 委托是需要 类型兼容的！ 类型兼容！ 类型兼容！

  public class MyClass
  {
      //类的声明
      public void Log()
      {
          //方法的声明
          Console.WriteLine("简单例子");
      }
  }

注意声明委托的位置！委托的声明一般如同类的声明，是在名称空间体内的，如果你将委托声明在了类体里，那委托就会声明成一个嵌套类型。

委托的声明方式与一般的类不同，主要是为了照顾可读性和C/C++传统

我们可以根据实际情况自定义委托的返回值类型与参数列表，注意委托所指向的方法必须要与委托类型兼容（返回值类型与参数列表）。

  static void Main(string[] args)
  {
      MyClass myClass = new MyClass();
      MyDelegate myDelegate = new MyDelegate(myClass.Log);//myDelegate委托指向myClass中的Log方法
  }

注意！为什么我们在new MyDelegate（myClass.Log)的Log后没有加（）呢？因为在这里我们并不是去调用myClass.Log这个方法，所以不需要加上该方法的构造器，在这里我们只是需要myClass.Log这个方法的方法名！

4.C#为我们准备好的两种委托Action和Func

Action委托无返回值类型（一定无），16种重载，最多支持16个参数。

static void Main(string[] args)
{
    Calculator calculator = new Calculator();
    Action action = new Action(calculator.Report);            
    calculator.Report();//直接调用
    action.Invoke();//间接调用
    action();

上图中的Action委托无参数列表，指向Calculator类中的Report方法（同样无返回值，无参数列表，类型兼容！）如果你想使用带有参数的Action委托，在Action后+<>（如Action<>）。

 class Calculator
 {
     public void Report()
     {
         Console.WriteLine("I Have 3 methods");
     }
     public int Add(int a, int b)
     {
         int result=a+b;
         return result;
     }
     public int Sub(int a, int b)
     {
         int result=a-b;
         return result;
     }
 }

Func委托，有返回值类型（一定有），17种重载，最多支持16个参数（可以无参数）。

 Func<int, int, int> func1 = new Func<int, int, int>(calculator.Add);
 Func<int, int, int> func2 = new Func<int, int, int>(calculator.Sub);
 int x = 100;
 int y = 200;
 int z = 0;
 z = func1.Invoke(x, y);//间接调用
 Console.WriteLine(z);
 z = func2.Invoke(x, y);//间接调用
 Console.WriteLine(z);
 Console.ReadLine();

上图中的func1和func2委托，均含有两个int类型的参数，并且返回值类型也为int。

他们所指向的Add与Sub方法与fun1和func2类型兼容！

5.回调方法和模板方法

模板方法就如下面代码中的WrapProduct（Func<Product> getProduct)一样，借用了作为参数传进来的委托所指向的方法，这是委托的一个用法。

internal class Program
{
  
    static void Main(string[] args)
    {
        ProductFactory productFactory = new ProductFactory();
        WrapFactory wrapFactory = new WrapFactory();

        Func<Product> func1 = new Func<Product>(productFactory.MakePizza);//func1委托指向productFactory.MakePizza方法
        Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);//func2委托指向productFactory.MakeToyCar方法
        //func1 委托与func2委托的返回值类型均为Product 指向的方法返回值类型也均为Product 类型兼容！


        Box box1 = wrapFactory.WrapProduct(func1);//此时相当于将productFactory.MakePizza方法当作一个参数传给了（利用委托）wrapFactory.WrapProduct方法 所以称为模板方法
        Box box2 = wrapFactory.WrapProduct(func2);//此时相当于将productFactory.MakeToyCar方法当作一个参数传给了（利用委托）wrapFactory.WrapProduct方法 所以称为模板方法

        Console.WriteLine(box1.Product.Name);
        Console.WriteLine(box2.Product.Name);
        Console.ReadLine();
    }

   
}


class Product
{ 
    public string Name{ get; set; }
}

class Box
{
    public Product Product { get; set; }
}

class WrapFactory
{
    public Box WrapProduct (Func<Product> getProduct)//参数为一个委托类型参数  
    {
        Box box=new Box();
        Product product = getProduct.Invoke();
        box.Product= product;
        return box;
    }
}
class ProductFactory//ProductFactory类中的两个Make方法的返回值类型都为Product
{
    public Product MakePizza()
    {
        Product product= new Product();
        product.Name = "Pizza";
        return product;
    }

    public Product MakeToyCar()
    {
        Product product = new Product();
        product.Name = "Toy Car";
        return product;
    }
   
   
}

模板方法与回调方法的最大区别就在于，模板方法，“我”一定使用，而回调方法，“我可以不用，但不能没有”，回调方法是可以被选择是否使用的（根据具体情况），并且模板方法（用Func）有返回值，回调方法（用Action）无返回值，下面代码中的例子就是产品的价格大于等于50，才选择执行回调方法的逻辑。

 internal class Program
 {
  
     static void Main(string[] args)
     {
         ProductFactory productFactory = new ProductFactory();
         WrapFactory wrapFactory = new WrapFactory();
         Logger logger = new Logger();
         Action<Product> log = new Action<Product>(logger.Log);
         //Action委托log 与logger.Log方法类型兼容

         Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
         Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);
        


         Box box1 = wrapFactory.WrapProduct(func1,log);//此时相当于又将log方法当作一个参数传给了（利用委托）wrapFactory.WrapProduct方法 
         Box box2 = wrapFactory.WrapProduct(func2,log);//此时相当于又将log方法当作一个参数传给了（利用委托）wrapFactory.WrapProduct方法 

         Console.WriteLine(box1.Product.Name);
         Console.WriteLine(box2.Product.Name);
         Console.ReadLine();
     }

    
 }

 
   class Logger
 {
     public void Log(Product product)
     {
         Console.WriteLine("Product'{0}'created at{1}.Price is{2}",product.Name,DateTime.UtcNow,product.Price);
     }
 }
 class Product
 { 
     public string Name{ get; set; }
     public int Price { get; set; }
 }

 class Box
 {
     public Product Product { get; set; }
 }

 class WrapFactory
 {
     public Box WrapProduct (Func<Product> getProduct,Action<Product> logCallback)//将Action委托指向的方法当作参数传进了WrapProduct方法
     {
         Box box=new Box();
         Product product = getProduct.Invoke();
         if (product.Price >= 50)//回调方法与模板方法的最大区别，“可以不用，但不能没有”，即我不一定执行你的方法
         {
             logCallback(product);
         }

         box.Product= product;
         return box;
     }
 }
 class ProductFactory//ProductFactory类中的两个Make方法的返回值类型都为Product
 {
     public Product MakePizza()
     {
         Product product= new Product();
         product.Name = "Pizza";
         product.Price = 10;
         return product;
     }

     public Product MakeToyCar()
     {
         Product product = new Product();
         product.Name = "Toy Car";
         product.Price= 50;
         return product;
     }     
 }

6.单播委托与多播委托

单播委托指的是一个委托只指向了一个方法，如下面的代码所示，action1，action2，action3三个委托都分别指向了stu1，stu2，stu3的一个DoHomework方法，它们均为单播委托

  static void Main(string[] args)
  {
      Student stu1=new Student() { ID=1,PenColor=ConsoleColor.Red};
      Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
      Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };
      Action action1 = new Action(stu1.DoHomework);
      Action action2 = new Action(stu2.DoHomework);
      Action action3 = new Action(stu3.DoHomework);
      action1();//action1.Inovke() 间接调用
      action2();
      action3();
  }

我们来看一下Student类，和上面的代码的执行效果。为我们对多播委托的理解作一个铺垫。

 public class Student
 {
     public int ID { get; set; }
     public ConsoleColor PenColor { get; set; }

     public void DoHomework()
     {
         for(int i = 0; i < 3; i++)
         {
             Console.ForegroundColor = this.PenColor;
             Console.WriteLine("Student {0} doing homework {1} hour(s)",this.ID,i);
             Thread.Sleep(1000);
         }
     }
 }

执行结果

下图为多播委托，我们可以看到action1委托指向了3个方法（封装了3个方法）。

一个委托封装多个方法可以通过+=操作符完成，注意如果此时漏掉了+号，只写一个=号的话，会导致一个委托的重置（这也为我们后面引出事件作了铺垫，因为委托的使用是不安全的，就像字段的使用是不安全的，我们会更倾向于使用属性）！

该多播委托的执行结果与之前的单播委托的执行结果完全相同，我们可以得出，多播委托所封装方法的执行顺序，与封装他们时的封装顺序一致。

static void Main(string[] args)
{
    Student stu1=new Student() { ID=1,PenColor=ConsoleColor.Red};
    Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
    Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };
    Action action1 = new Action(stu1.DoHomework);
    action1 += stu2.DoHomework;
    action1+= stu3.DoHomework;
    action1();
    Console.ReadLine();
}

7.异步调用/同步调用(可以选择性浏览)

这里我们要注意中英文语言的差异性，区分C#中的同步与异步与我们平时生活用语的不同。

同步调用有：1.直接同步调用（这里的直接指的是直接通过方法名调用方法）2.间接同步调用 3.多播委托（这也是间接调用的一种）

下图中红色的线代表主线程，蓝色，绿色，黄色代表stu1，stu2，stu3的Dohomework方法，我们程序的执行是线性的，从左到右依次执行，所以说是同步的（按顺序依次执行）

下面是直接同步调用

static void Main(string[] args)
{
    Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
    Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
    Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };

    stu1.DoHomework();//通过方法名直接调用 
    stu2.DoHomework();
    stu3.DoHomework();
    for(int i=0;i<5;i++)
    {
        Console.ForegroundColor = ConsoleColor.Magenta;
        Console.WriteLine("Main thread do something{0}", i);
        Thread.Sleep(1000);
    }
    Console.ReadLine();
}

下面是间接同步调用

 static void Main(string[] args)
 {
     Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
     Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
     Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };

     Action action1 = new Action(stu1.DoHomework);
     Action action2 = new Action(stu2.DoHomework);
     Action action3 = new Action(stu3.DoHomework);

     action1();//action1.Inovke()   间接调用
     action2();
     action3();
     for (int i=0;i<5;i++)
     {
         Console.ForegroundColor = ConsoleColor.Magenta;
         Console.WriteLine("Main thread do something{0}", i);
         Thread.Sleep(1000);
     }
     Console.ReadLine();
 }

多播委托（间接调用）

 static void Main(string[] args)
 {
     Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
     Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
     Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };

     Action action1 = new Action(stu1.DoHomework);
     action1 += stu2.DoHomework;
     action1 += stu3.DoHomework;
     action1();    //多播委托
     for (int i=0;i<5;i++)
     {
         Console.ForegroundColor = ConsoleColor.Magenta;
         Console.WriteLine("Main thread do something{0}", i);
         Thread.Sleep(1000);
     }
     Console.ReadLine();
 }

以上三种同步调用的运行结果都是一致的，程序按顺序依次执行，执行结果如下图所示

下面我们来看看异步调用，我们可以这样理解异步，当我们在干一件事的同时也在干另一件事（好比小时候我们一边写作业一边看电视，这两件事是我们在同时做的）。

我们通过BeginInvoke方法（参数列表两个参数一般填null值）进行隐式的异步调用，下面的代码就是三个委托与主线程同时执行，我们来看看执行结果就明白了。

 static void Main(string[] args)
 {
     Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
     Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
     Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };

     Action action1 = new Action(stu1.DoHomework);
     Action action2 = new Action(stu2.DoHomework);
     Action action3 = new Action(stu3.DoHomework);

     action1.BeginInvoke(null,null);//隐式的异步调用
     action2.BeginInvoke(null,null);
     action3.BeginInvoke(null,null);

     for (int i=0;i<5;i++)
     {
         Console.ForegroundColor = ConsoleColor.Magenta;
         Console.WriteLine("Main thread do something{0}", i);
         Thread.Sleep(1000);
     }
     Console.ReadLine();
 }

下面的执行结果我们可以看出，这三个委托与主线程确实是同时执行的，但是为什么打印的颜色出现了问题呢？这涉及到了我们操作系统的一些知识，由于我们的三个分支线程与主线程都在同时执行，且都去访问了打印颜色这个资源，导致了资源的争抢且发生了冲突，为了避免产生资源争抢而产生冲突，我们通常会为线程加锁（操作系统知识，这里不在过多讨论）

下面是显式的异步调用，它与隐式的异步调用一样，同样会发生资源的争抢。

static void Main(string[] args)
{
    Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
    Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Blue };
    Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Yellow };

    Thread thread1 = new Thread(new ThreadStart(stu1.DoHomework));//显式异步调用
    Thread thread2 = new Thread(new ThreadStart(stu1.DoHomework));
    Thread thread3 = new Thread(new ThreadStart(stu1.DoHomework));
  
    for (int i=0;i<5;i++)
    {
        Console.ForegroundColor = ConsoleColor.Magenta;
        Console.WriteLine("Main thread do something{0}", i);
        Thread.Sleep(1000);
    }
    Console.ReadLine();
}

这是我对B站Up主TimothyLiu（刘铁猛老师！！！）与BeaverJoe老师对于委托的学习总结，如有错漏，恳请指出，谢谢！

云卷678

关注

9
点赞
踩
10

收藏

觉得还不错? 一键收藏
2
评论
C # 委托

委托是函数指针的“升级版”，委托是一种类，类是数据类型，所以委托也是一种数据类型//委托的声明// ←（这里声明的委托参数列表为空）//注意！该委托声明在名称空间体内而不是在类体里// ↑ ↑//delegate关键字返回值类型（这里声明的委托返回值类型为空）//该委托就可以指向Log方法，因为Log方法的返回值类型为空，且参数列表为空！委托是需要类型兼容的！类型兼容！类型兼容！//类的声明//方法的声明Console.WriteLine("简单例子");
复制链接

扫一扫