【.NET Core】委托（Delegate）应用详解

本文介绍: 委托（Del e g a t e）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托（Del e g a t e）类似于C或C++中函数指针。委托是将方法调用者和目标方法动态关联起来，委托是一个类，实质上是一个类，可以通过委托隐藏方法，虽然委托定义方法的参数及其返回值，但是它并不是和方法一个层级的。委托（Del e g ate）可以将方法当作另一个方法的参数来进行传递，这种方法动态地赋给参数的做法，可以避免在程序中大量使用If-Els e(Switch)语句，同时使得程序具有更好的可扩展性。delegate。

委托（Del e g ate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托（Deleg ate）类似于C或C++中函数指针。委托是将方法调用者和目标方法动态关联起来，委托是一个类，实质上是一个类，可以通过委托隐藏方法，虽然委托定义方法的参数及其返回值，但是它并不是和方法一个层级的。

委托（Deleg ate）可以将方法当作另一个方法的参数来进行传递，这种方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

声明一个委托的语法如下：

deletgate <return type> <delegate-name> <parameter list>

声明委托步骤

代码演示

delegate int DegaAdd(int a,int b,int c);
public int add(int a,int b,int c){
    return a+b+c;
}
public static void Main(String[] args){
    DegaAdd degaAdd=new DegaAdd(add);
    int respVal =degaAdd(2,3,4);
    Console.WriteLine(respVal);
}

public class Program 
{
    public delegate void DelegateNoReturn(string param1, string param2);
    public static void NoReturn(string param1, string param2) 
    {
        Console.WriteLine(param1+" "+param2+".");
    }
    public static void Main(string[] args) 
    {
        DelegateNoReturn delegateNoReturn;
        delegateNoReturn = NoReturn;
        delegateNoReturn("Hello", "Delegate");

    }
}

public class Program 
{
    public delegate void DelegateNoReturn(string param1, string param2);
    public delegate string DelegateHaveReturn(string param1, string param2);
    public static void NoReturn(string param1, string param2) 
    {
        Console.WriteLine(param1+" "+param2+".");
    }
    public static string HaveReturn(string param1, string param2) {
      return ("有参数Delegate:"+param1 + " " + param2 + ".");
    }
    public static void Main(string[] args)
    {
        DelegateHaveReturn delegateHaveReturn;
        delegateHaveReturn = HaveReturn;
        string response = delegateHaveReturn("Hello", "Delegate");
        Console.WriteLine(response);
    }
}

多播委托（Multica stDelegate）是指在一个委托中注册多个方法，在注册方法时可以在委托中使用加号运算符或者减号运算符来实现添加或撤销方法。

public class DelegateMethod
{
     public static void Method1()
     {
          Console.WriteLine("委托方法一.");
      }

      public void Method2() 
      {
          Console.WriteLine("委托方法二.");
      }

      public void Method3()
      {
          Console.WriteLine("委托方法三.");
      }
}

public class Program 
{
    public delegate void OrderDelegate();
    public static void Main(string[] args) 
    {
        OrderDelegate orderDelegate = new OrderDelegate(DelegateMethod.Method1);
        orderDelegate += new DelegateMethod().Method2;
        orderDelegate += new DelegateMethod().Method3;
        orderDelegate();
    }
}

委托方法一.
委托方法二.
委托方法三.

匿名方法（Anonymous methods）提供了一种传递代码块作为委托参数的技术。匿名方法是没有名称只有主体的方法。

delegate void ValueChange(int n);
...
ValueChange vchange=delegate(int x)
{
    Console.WriteLine("Anonymous Method:{0}",x);
}

button1.Click+=delegate(Object o,EventArgs e)
{
    Console.WriteLine("Anonymous Method:");
}

public class ActionDemo
{
    public void Operate() 
    {
        Action action1 = new Action(Method1);
        Action<int, int> action2 = new Action<int, int>(Method2);
        action1();
        action2(1, 2);
        Action<int ,string,string> action3= delegate (int i1 ,string i2,string s){
            Console.WriteLine($"这里是三个参数的Action委托，参数1的值是：{i1}，参数2的值是：{i2}，参数3的值是：{s}");
        };
        action3(1,"a","abc");
    }
    public void Method1() 
    {
        Console.WriteLine("This Method1");
    }
     public void Method2(int a,int b) { Console.WriteLine("This Method2"); }
 }

public void Operate() 
{
    // 无参数，只要返回值 
    Func<int> fun1 = new Func<int>(FunWithNoPara);
    int result1 = fun1();
    Console.WriteLine(result1);
    Console.WriteLine("----------------------------");
    Func<int> fun2 = delegate { return 19; };
    int result2 = fun2();
    Console.WriteLine(result2);
    Console.WriteLine("----------------------------");
    Func<int> fun3 = () => { return 3; };
    int result3 = fun3();
    Console.WriteLine(result3);
    Console.WriteLine("----------------------------");
    //有一个参数，一个返回值
    Func<int, int> fun4 = new Func<int, int>(FunWithPara);
    int result4 = fun4(4);
    Console.WriteLine($"这里是一个参数一个返回值的方法，返回值是：{result4}");
    Console.WriteLine("----------------------------");
    // 使用委托
    Func<int, string> fun5 = delegate (int i) { return i.ToString(); };
    string result5 = fun5(5);
    Console.WriteLine($"这里是一个参数一个返回值的委托，返回值是：{result5}");
    Console.WriteLine("----------------------------");
    // 使用匿名委托
    Func<int, string> fun6 = (int i) =>
    {
         return i.ToString();
    };
    string result6 = fun6(6);
    Console.WriteLine($"这里是一个参数一个返回值的匿名委托，返回值是：{result6}");
    Console.WriteLine("----------------------------");
    // 多个输入参数
    Func<int, string, bool> fun7 = new Func<int, string, bool>(FunWithMultiPara);
    bool result7 = fun7(2, "2");
    Console.WriteLine($"这里是有多个输入参数的方法，返回值是：{result7}");
    Console.WriteLine("----------------------------");
    // 使用委托
     Func<int, string, bool> fun8 = delegate (int i, string s)
    {
        return i.ToString().Equals(s) ? true : false;
    };
    bool result8 = fun8(2, "abc");
    Console.WriteLine($"这里是有多个输入参数的委托，返回值是：{result8}");
    Console.WriteLine("----------------------------");
    // 使用匿名委托
    Func<int, string, bool> fun9 = (int i, string s) =>
    {
        return i.ToString().Equals(s) ? true : false;
    };
    bool result9 = fun9(45, "ert");
    Console.WriteLine($"这里是有多个输入参数的匿名委托，返回值是：{result9}");
    Console.ReadKey();
   }
   public int FunWithNoPara()
   {
       return 10;
   }

   public int FunWithPara(int i)
   {
       return i;
   }

   public bool FunWithMultiPara(int i, string s)
   {
       return i.ToString().Equals(s) ? true : false;
   }