当前位置: 澳门新濠3559 > 编程 > 正文

澳门新濠3559你可以通过委托实例调用方法,委托

时间:2019-12-08 22:39来源:编程
C# 知识回顾 - 委托 delegate 【博主】反骨仔 【原文】 Use 委托 委托是安全封装方法的类型,类似于C 和 C++ 中的函数指针。与 C函数指针不同的是,委托是面向对象的、类型安全的和可靠

C# 知识回顾 - 委托 delegate

【博主】反骨仔    【原文】

Use 委托

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

    //该委托可以封装 “,参数类型 string,返回类型 void” 的方法 
    public delegate void MyDel(string message);

 

  委托对象通常通过提供委托将封装的方法的名称或使用匿名方法构造。对委托进行实例化后,委托会将对其进行的方法调用传递到该方法。调用方传递到委托的参数将传递到该方法,并且委托会将方法的返回值(如果有)返回到调用方。这被称为调用委托。实例化的委托可以按封装的方法本身进行调用。例如:

 1     //该委托名为 MyDel,可以封装 “参数类型 string,返回值类型 void” 的方法 
 2     public delegate void MyDel(string message);
 3 
 4     class Program
 5     {
 6         static void Main(string[] args)
 7         {
 8             //实例化委托
 9             MyDel del = Print;
10             //调用委托
11             del("Hi");
12 
13             Console.Read();
14         }
15 
16         /// <summary>
17         /// 打印文本
18         /// </summary>
19         /// <remarks>这是一个可用于 MyDel 委托的方法</remarks>
20         /// <param name="message"></param>
21         private static void Print(string message)
22         {
23             Console.WriteLine(message);
24         }
25     }

异步回调,是在长进程完成时通知调用方的常用方法。当以这种方式使用委托时,使用委托的代码不需要知道要使用的实现方法。功能类似于封装接口提供的功能。       回调的另一个常见用途是定义自定义比较方法并将该委托传递到短方法。  它允许调用方的代码成为排序算法的一部分。  以下示例方法使用 Del 类型作为参数:  

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             MyDel del = Print;
 6             CallbackMethod(100, 150, del);  //将委托传递到 CallbackMethod 方法
 7 
 8             Console.Read();
 9         }
10 
11         /// <summary>
12         /// 回调方法
13         /// </summary>
14         /// <param name="m"></param>
15         /// <param name="n"></param>
16         /// <param name="del"></param>
17         private static void CallbackMethod(int m, int n, MyDel del)
18         {
19             del((m + n).ToString());
20         }
21 
22         private static void Print(string message)
23         {
24             Console.WriteLine(message);
25         }
26     }

委托不知道除其所封装方法以外的实例类型,因此委托可以引用任何类型的对象,只要该对象上有与委托签名匹配的方法。当委托构造为封装静态方法时,委托仅引用方法。  请考虑以下声明:  

 1     //该委托可以封装 “名 MyDel,参数类型 string,返回值类型 void” 的方法 
 2     public delegate void MyDel(string message);
 3 
 4     class MyClass
 5     {
 6         public void Print1(string message)
 7         {
 8             Console.WriteLine($"{message} - {nameof(Print1)}");
 9         }
10 
11         public void Print2(string message)
12         {
13             Console.WriteLine($"{message} - {nameof(Print2)}");
14         }
15     }
16 
17     class Program
18     {
19         static void Main(string[] args)
20         {
21             var myClass = new MyClass();
22             MyDel del1 = myClass.Print1;
23             MyDel del2 = myClass.Print2;
24             MyDel del3 = Print;
25 
26             var del = del1 + del2;
27             del += del3;    //这里使用 +=
28             del("Hi!");
29 
30             Console.Read();
31         }
32 
33         private static void Print(string message)
34         {
35             Console.WriteLine($"{message} - {nameof(Print)}");
36         }
37     }

多播。若要向委托的方法列表(调用列表)添加其他方法,只需使用加法运算符或加法赋值运算符(“+”或“+=”)添加两个委托。

  此时,del 的调用列表中包含三个方法,分别为 Print1、Print2 和 Print。原有的三个委托(del1、del2 和 del3)保持不变。调用 allMethodsDelegate 时,将按顺序调用所有三个方法。如果委托使用引用参数,引用将按相反的顺序传递到所有这三个方法,并且一种方法进行的任何更改都将在另一种方法上见到。当方法引发未在方法内捕获到的异常时,该异常将传递到委托的调用方,并且不会调用调用列表中的后续方法。如果委托具有返回值和/或输出参数,它将返回上次调用方法的返回值和参数。若要删除调用列表中的方法,请使用减法运算符或减法赋值运算符(“-”或“-=”)。  例如:  

 1         static void Main(string[] args)
 2         {
 3             var myClass = new MyClass();
 4             MyDel del1 = myClass.Print1;
 5             MyDel del2 = myClass.Print2;
 6             MyDel del3 = Print;
 7 
 8             var del = del1 + del2;
 9             del += del3;    //使用 +=
10             del("Hi!");
11 
12             Console.WriteLine("======分割线======");
13 
14             del -= del2;    //使用 -=
15             del("Hi!");
16 
17             Console.Read();
18         }

1 static void Main(string[] args) 2 { 3 var myClass = new MyClass(); 4 MyDel del1 = myClass.Print1; 5 MyDel del2 = myClass.Print2; 6 MyDel del3 = Print; 7 8 var del = del1 + del2; 9 del += del3; //使用 += 10 //del("Hi!"); 11 12 var count = del.GetInvocationList().Length; //获取委托调用列表中方法的数量 13 Console.WriteLine(count); 14 15 Console.WriteLine("======分割线======"); 16 17 del -= del2; //使用 -= 18 //del("Hi!"); 19 20 count = del.GetInvocationList().Length; //获取委托调用列表中方法的数量 21 Console.WriteLine(count); 22 23 Console.Read(); 24 }

 


【参考】微软官方文档

] C# 知识回顾, C# 知识回顾 - 委托 delegate 【博主】反骨仔 【原文】 目录 What's 委托 委托的属性概述...

C#之委托,

  如果要给方法传递一个方法参数时,就可以使用委托。要传递方法,就必须把方法的细节封装在一钟新类型的对象中,即委托。委托是一种特殊类型的对象,其特殊之处在于,我们以前定义的所有对象都包含数据,而委托只包含一个或多个方法的地址。

  .NET版本中,委托指向方法的地址。在C++中,函数指针是一个指向内存位置的指针,但它不是类型安全的。开发者无法判断这个指针实际指向什么,像参数和返回值等项就更不知道了。

  .NET委托是类型安全的类,它定义了返回类型和参数的类型。委托类不仅包含对方法的引用,也可以包含对多个方法的引用。
1.声明委托

  使用委托和使用类一样,也需要经过定义和实例化两个步骤。首先必须定义要使用的委托,对于委托,定义它就是告诉编译器这种类型的委托表示哪种类型的方法。然后,必须创建该委托的一个或多个实例才能使用。编译器在后台将创建表示该委托的一个类。
  定义委托的语法:
  delegate void IntMethod(int x);//定义了一个委托IntMethod,指定该委托的每个实例都可以包含一个或多个方法的引用,引用的方法必须带有一个int参数,并返回void.

  因为定义委托基本上是定义一个新类,所以可以在定义类的任何地方定义委托。也可以在委托的定义上使用修饰符:public,private,protected等。

  委托派生自基类System.MulticastDelegate,MulticastDelegate又派生自基类System.Delegate.

  类有两个不同的术语:“类”表示广义的定义,“对象”表示;类的实例。但委托只有一个术语。在创建委托的实例时,所创建的实例仍称为委托。必须从上下文中确定委托的具体含义。

2.使用委托

  定义好委托之后,就可以创建它的一个实例,从而用它存储特定方法的细节。  

                delegate void IntMethod(int x);

        static void Fun(int x)
        {
            Console.WriteLine(x);
        }

        static void Main()
        {
          int x = 40;
          IntMethod intMethod = new IntMethod(Fun);
          intMethod(x);
          Console.ReadKey();

        }

  委托在语法上总是接受一个参数的构造函数,这个参数就是委托引用的方法。这个方法必须匹配最初定义委托时的签名。

  使用委托实例的名称,后面加上圆括号,如果需要参数就必须在圆括号内加上参数。
澳门新濠3559你可以通过委托实例调用方法,委托是一种特殊类型的对象。   给委托实例提供圆括号和调用委托类的Invoke()方法完全相同:
  intMethod(x);
  intMethod.Invoke(x);

  为了减少输入量,只需要给委托实例传递方法地址的名称就可以,这称为委托推断。
  IntMethod intMethod = new IntMethod(Fun);
  IntMethod intMethod =Fun;

  委托推断可以在需要委托实例的任何地方使用。委托推断也可以用于事件,因为事件基于委托。(事件后面文章有介绍)

  注意,使用委托可以调用任何类型对象的方法,不管是静态方法还是实例方法。

3.使用委托数组

  

          //先在一个类中定义两个方法:
          class MathOperations
          {
            public static double MultiplyByTwo(double value)
            {
              return value * 2;
            }

            public static double Square(double value)
            {
              return value * value;
            }
          }

            //定义一个返回double类型且带有double类型参数的委托
          delegate double DoubleOp(double x);


          class Program
          {
            static void Main()
            {
              //实例化委托数组,和实例化类的数组一样
              DoubleOp[] operations =
              {
                MathOperations.MultiplyByTwo,
                MathOperations.Square
              };

              //遍历数组,使用数组中的每个委托实例
              for (int i = 0; i < operations.Length; i++)
              {
                Console.WriteLine("Using operations[{0}]:", i);
                //将委托实例作为参数传递给ProcessAndDisplayNumber方法
                ProcessAndDisplayNumber(operations[i], 2.0);
                ProcessAndDisplayNumber(operations[i], 7.94);
                ProcessAndDisplayNumber(operations[i], 1.414);
                Console.WriteLine();
              }
            }

            static void ProcessAndDisplayNumber(DoubleOp action, double value)
            {
              //在ProcessAndDisplayNumber中调用委托,执行委托实例引用的方法
              double result = action(value);
              Console.WriteLine(
                 "Value is {0}, result of operation is {1}", value, result);
            }
          }

 

4.Action<T>和Func<T>委托

  除了为每个参数和返回类型定义一个委托类型之外,还可以使用Action<T>和Func<T>委托。

  泛型Action<T>委托表示引用一个void返回类型的方法。这个委托类存在不同的变体,可以传递最多16种不同的参数类型。没有泛型参数的Action类调用没有参数的方法。Action<in T>调用带一个参数的方法,Action<in T1,in T2>调用带两个参数的方法,依次类推。

  Func<T>委托允许调用带返回类型的方法。与Action<T>类似,Func<T>也存在不同的变体,可以传递最多16种不同的参数类型和一个返回类型。Func<out TResult>委托类型可以调用无参数且带返回类型的方法。

  下面使用Func<T>委托实现一个不使用委托很难编写的一个功能:给对象数组排序,如果对象是int或string这样值类型的对象会容易排序,如果是要排序很多自定义的类型的对象,需要编写大量代码。使用委托会减少代码量。
  定义包含比较方法的类:
  BubbleSorter类实现了一个泛型方法 Sort<T>,第一个参数是要排序的对象数组,第二个是一个委托,传递比较两个对象的方法。这样可以给Sort<T>方法,传递自定义的比较方法。

  

           class BubbleSorter
          {
            static public void Sort<T>(IList<T> sortArray, Func<T, T, bool> comparison)
            {
              bool swapped = true;
              do
              {
                swapped = false;
                for (int i = 0; i < sortArray.Count - 1; i++)
                {
                  //调用委托中引用的方法,比较两个对象
                  if (comparison(sortArray[i + 1], sortArray[i]))
                  {
                    T temp = sortArray[i];
                    sortArray[i] = sortArray[i + 1];
                    sortArray[i + 1] = temp;
                    swapped = true;
                  }
                }
              } while (swapped);


            }
          }

 

  定义自定义的一个类

      class Employee
          {
            public Employee(string name, decimal salary)
            {
              this.Name = name;
              this.Salary = salary;
            }

            public string Name { get; private set; }
            public decimal Salary { get; private set; }

            public override string ToString()
            {
              return string.Format("{0}, {1:C}", Name, Salary);
            }

            public static bool CompareSalary(Employee e1, Employee e2)
            {
              return e1.Salary < e2.Salary;
            }
          }

  客户端代码:

  

       Employee[] employees =
          {
            new Employee("Bugs Bunny", 20000),
            new Employee("Elmer Fudd", 10000),
            new Employee("Daffy Duck", 25000),
            new Employee("Wile Coyote", 1000000.38m),
            new Employee("Foghorn Leghorn", 23000),
            new Employee("RoadRunner", 50000)
          };
            //Sort执行了自定义的Employee.CompareSalary方法
          BubbleSorter.Sort(employees, Employee.CompareSalary);

          foreach (var employee in employees)
          {
            Console.WriteLine(employee);
          }

 

 

5.多播委托

  前面介绍的每个委托只包含一个方法的调用,委托也可以包含多个方法。这种委托称为多播委托。

  如果调用多播委托,就可以按顺序调用多个方法,但如果委托的签名不是返回void,就只能得到委托调用的最后一个方法的结果。
  使用+=添加方法,-=删除方法。

  

    static void Main()
        {
          Action<double> operations = MathOperations.MultiplyByTwo;
          operations += MathOperations.Square;

          ProcessAndDisplayNumber(operations, 2.0);
          ProcessAndDisplayNumber(operations, 7.0);
          Console.WriteLine();
        }

        static void ProcessAndDisplayNumber(Action<double> action, double value)
        {
          Console.WriteLine();
          Console.WriteLine("ProcessAndDisplayNumber called with value = {0}", value);
          action(value);

        }


        class MathOperations
          {
            public static void MultiplyByTwo(double value)
            {
              double result = value * 2;
              Console.WriteLine("Multiplying by 2: {0} gives {1}", value, result);
            }

            public static void Square(double value)
            {
              double result = value * value;
              Console.WriteLine("Squaring: {0} gives {1}", value, result);
            }
          }

  每次调用ProcessAndDisplayNumber方法,都会按顺序调用action委托实例中的两个方法。
  输出:
  ProcessAndDisplayNumber called with value = 2
  Multiplying by 2: 2 gives 4
  Squaring: 2 gives 4

  ProcessAndDisplayNumber called with value = 7
  Multiplying by 2: 7 gives 14
  Squaring: 7 gives 49

  委托还可以使用+,-运算符:
  Action<double> operations1 = MathOperations.MultiplyByTwo;
  Action<double> operations2 = MathOperations.Square;
  Action<double> operations = operations1 + operations2;
  operations = operations - operations2;

  多播委托包含一个逐个调用的委托集合。如果其中一个方法抛出异常,整个迭代就会停止。
  static void One()
  {
    Console.WriteLine("One");
    throw new Exception("Error in one");
  }

  static void Two()
  {
    Console.WriteLine("Two");
  }

  static void Main()
  {
    Action d1 = One;
    d1 += Two;

    try
    {
      d1();
    }
    catch (Exception)
    {
      Console.WriteLine("Exception caught");
    }

  }

  委托只调用了第一个方法。因为第一个方法抛出异常,委托的迭代停止,不再调用Two()方法。

  避免这个问题,可以使用Delegate类定义的GetInvocationList()方法,它返回一个Delegate对象数组:
  Action d1 = One;
  d1 += Two;

  Delegate[] delegates = d1.GetInvocationList();
  foreach (Action d in delegates)
  {
    try
    {
      d();
    }
    catch (Exception)
    {
      Console.WriteLine("Exception caught");
    }
  }

  输出:
  One
  Exception caught
  Two

  使用GetInvocationList()方法可以为委托的每个方法传递不同的参数,获取每个方法的返回值。
  static int One(int x)
  {
    return x;
  }

  static int Two(int x)
  {
    return x;
  }

  static void Main()
  {

    Func<int,int> d1 = One;
    d1 += Two;

    Delegate[] delegates = d1.GetInvocationList();
    Func<int, int> d2 = (Func<int, int>)delegates[0];
    Console.WriteLine( d2(1));

    Func<int, int> d3 = (Func<int, int>)delegates[1];
    Console.WriteLine(d3(2));

    Console.ReadKey();
  }
  输出:
  1
  2

6.匿名方法
  使用匿名方法可以将方法体直接赋给委托实例,而不需要定义一个方法。
  static void Main()
  {
    string mid = ", middle part,";

    Func<string, string> anonDel = delegate(string param)
    {
      param += mid;
      param += " and this was added to the string.";
      return param;
    };
    Console.WriteLine(anonDel("Start of string"));

  }

  上面代码不是把方法名赋给委托变量anonDel,而是一段代码,它前面是关键字delegate和参数列表。在使用匿名方法时,可以使用外部变量。

  匿名方法的优点是减少了代码量。使用匿名方法,代码执行速度并没有加快。编译器仍定义了一个方法,该方法只有一个自动指定的名称。

  使用匿名方法,必须遵守两条规则:

  (1).在匿名方法中不能使用跳转语句(break,goto,continue)调到匿名方法的外部,外部的代码也不能调到匿名方法内部。

  (2).匿名方法内部不能访问不安全的代码。也不能在匿名方法使用ref和out

  如果需要匿名方法多次编写同一个功能时,就不要用匿名方法了。

如果要给方法传递一个方法参数时,就可以使用委托。要传递方法,就必须把方法的细节封装在一钟新类型的对象中,即委托。...

What's 委托

  delegate 一种自定义的引用类型,它包含了特定的参数列表和返回类型。

  使用委托时,只需要对应的方法的签名和返回类型兼容即可,无论是实例方法,抑或是静态方法。通过调用委托的实例就相当于调用方法本身,因为委托存储的是一个方法列表,调用委托的实例就相当于依次调用方法列表的内容。委托它将方法作为参数进行传递给了其它方法,我们常用的事件处理程序就是通过委托调用的方法,也是一种观察者模式的体现。

 

  下面的示例演示了一个委托声明:

public delegate int Del(int x, int y);

  

  使用委托的要求是:方法签名与返回类型兼容。可以是静态方法,也可以是实例方法。  

 

  【备注】方法的签名不包括返回值。

 

[C#] C# 知识回顾,

委托的特点

  • 类型安全,类似于 C 和 C++ 中的函数指针。

  • 可将方法作为参数进行传递。

  • 可用于定义回调方法。

  • 委托可以链接在一起;例如,可以对一个事件调用多个方法。

  • 方法不必与委托类型完全匹配。

 

委托的属性概述

  • 类似于 C 和 C++ 中的函数指针,但它们是类型安全的。

  • 允许将方法作为参数进行传递。

  • 可用于定义回调方法。

  • 委托可以链接在一起;例如,可以对一个事件调用多个方法。

  • 方法不必与委托类型完全匹配。

 

使用委托

  委托,一种类型,它是安全的,自定义的,委托的名称就决定了这个委托是什么类型。

    //该委托可以封装 “,参数类型 string,返回类型 void” 的方法 
    public delegate void MyDel(string message);

 

  委托的实例对象通常使用两种方式进行构建,直接使用类的方法名,或者使用 Lambda 表达式,当然匿名方法也可以。

  在调用委托的时刻,我们将传递到委托的参数会继续传递到委托列表的方法中。如果委托列表中包含返回值的话,会将最后一个返回值返回给调用方。也就是该委托对象调用完毕的返回值。

 1     //该委托名为 MyDel,可以封装 “参数类型 string,返回值类型 void” 的方法 
 2     public delegate void MyDel(string message);
 3 
 4     class Program
 5     {
 6         static void Main(string[] args)
 7         {
 8             //实例化委托
 9             MyDel del = Print;
10             //调用委托
11             del("Hi");
12 
13             Console.Read();
14         }
15 
16         /// <summary>
17         /// 打印文本
18         /// </summary>
19         /// <remarks>这是一个可用于 MyDel 委托的方法</remarks>
20         /// <param name="message"></param>
21         private static void Print(string message)
22         {
23             Console.WriteLine(message);
24         }
25     }

澳门新濠3559 1

  委托的关键字是 delegate,它派生自 Delegate 类,也是 sealed,即密封类,不能作为基类再继续派生。

  异步回调:允许以方法的形式作为参数形式进行传递,并在稍后进行该委托的调用。通过这个形式使用的委托,调用方不需要知道方法的具体实现,只是简单的把它当做一个功能即可,这类似接口的封装。

 

  简单的异步回调方法演示:

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             MyDel del = Print;
 6             CallbackMethod(100, 150, del);  //将委托传递到 CallbackMethod 方法
 7 
 8             Console.Read();
 9         }
10 
11         /// <summary>
12         /// 回调方法
13         /// </summary>
14         /// <param name="m"></param>
15         /// <param name="n"></param>
16         /// <param name="del"></param>
17         private static void CallbackMethod(int m, int n, MyDel del)
18         {
19             del((m + n).ToString());
20         }
21 
22         private static void Print(string message)
23         {
24             Console.WriteLine(message);
25         }
26     }

澳门新濠3559 2

 

  在这里的 CallbackMethod 作用是,调用委托,因为它包含的是 Print() 方法的调用,所以只需要传递对应的 string 类型作为参数即可。

 

  我们在创建委托的时候,你可以选择使用的是实例方法或者是静态方法。当你使用的是实例方法时,该委托对象会同时引用该实例的对象及它的方法。委托并不关心应用引用对象的类型,它关心的是,方法签名和返回值兼容,即可。不过,如果你创建委托对象包含的是静态方法的时候,它是只引用该方法的。

  使用 += 可以把多个方法添加到一个委托对象的调用列表中,调用一次委托,相当于一次性调用一堆方法。

 1     //该委托可以封装 “名 MyDel,参数类型 string,返回值类型 void” 的方法 
 2     public delegate void MyDel(string message);
 3 
 4     class MyClass
 5     {
 6         public void Print1(string message)
 7         {
 8             Console.WriteLine($"{message} - {nameof(Print1)}");
 9         }
10 
11         public void Print2(string message)
12         {
13             Console.WriteLine($"{message} - {nameof(Print2)}");
14         }
15     }
16 
17     class Program
18     {
19         static void Main(string[] args)
20         {
21             var myClass = new MyClass();
22             MyDel del1 = myClass.Print1;
23             MyDel del2 = myClass.Print2;
24             MyDel del3 = Print;
25 
26             var del = del1 + del2;
27             del += del3;    //这里使用 +=
28             del("Hi!");
29 
30             Console.Read();
31         }
32 
33         private static void Print(string message)
34         {
35             Console.WriteLine($"{message} - {nameof(Print)}");
36         }
37     }

澳门新濠3559 3

   委托对象 del,他内部存储的是一个包含三个方法的调用列表(Print1、Print2 和 Print),在你调用 del 对象时,调用列表中的方法会依次调用。

  

  多播委托:一个委托对象调用多个方法,使用 +=。

  若要从委托对象的调用列表中移除方法,需要使用 -=。

 

 1         static void Main(string[] args)
 2         {
 3             var myClass = new MyClass();
 4             MyDel del1 = myClass.Print1;
 5             MyDel del2 = myClass.Print2;
 6             MyDel del3 = Print;
 7 
 8             var del = del1 + del2;
 9             del += del3;    //使用 +=
10             del("Hi!");
11 
12             Console.WriteLine("======分割线======");
13 
14             del -= del2;    //使用 -=
15             del("Hi!");
16 
17             Console.Read();
18         }

澳门新濠3559 4

 

  你也可以编写一些方法获取调用列表中方法的数量:

 1         static void Main(string[] args)
 2         {
 3             var myClass = new MyClass();
 4             MyDel del1 = myClass.Print1;
 5             MyDel del2 = myClass.Print2;
 6             MyDel del3 = Print;
 7 
 8             var del = del1 + del2;
 9             del += del3;    //使用 +=
10             //del("Hi!");
11 
12             var count = del.GetInvocationList().Length; //获取委托调用列表中方法的数量
13             Console.WriteLine(count);
14 
15             Console.WriteLine("======分割线======");
16 
17             del -= del2;    //使用 -=
18             //del("Hi!");
19 
20             count = del.GetInvocationList().Length; //获取委托调用列表中方法的数量
21             Console.WriteLine(count);
22 
23             Console.Read();
24         }

澳门新濠3559 5

 

  多播委托派生自 MulticastDelegate,也是继承自 Delegate的,常用于事件处理中。

 

目录

  • What's 委托
  • 委托的属性概述
  • Use 委托

 

目录

  • What's 委托
  • 委托的特点
  • 使用委托

 

What's 委托

  delegate 是表示对具有特定参数列表和返回类型的方法的引用的类型。在实例化委托时,你可以将其实例与任何具有兼容签名和返回类型的方法相关联。你可以通过委托实例调用方法。委托用于将方法作为参数传递给其他方法。事件处理程序就是通过委托调用的方法。你可以创建一个自定义方法,当发生特定事件时,某个类(如 Windows 控件)就可以调用你的方法。

  下面的示例演示了一个委托声明:

public delegate int Del(int x, int y);

  可将任何可访问类或结构中与委托类型匹配的任何方法分配给委托。该方法可以是静态方法,也可以是实例方法。这样便能通过编程方式来更改方法调用,还可以向现有类中插入新代码。

  【备注】在方法重载的上下文中,方法的签名不包括返回值。但在委托的上下文中,签名包括返回值。换句话说,方法和委托必须具有相同的返回类型。

  将方法作为参数进行引用的能力使委托成为定义回调方法的理想选择。例如,对比较两个对象的方法的引用可以作为参数传递到排序算法中。由于比较代码在一个单独的过程中,因此可通过更常见的方式编写排序算法。

 

传送门

  《C# 知识回顾 - 序列化》

  《C# 知识回顾 - 表达式树 Expression Trees》

  《C# 知识回顾 - 特性 Attribute》、《剖析 AssemblyInfo.cs - 了解常用的特性 Attribute》

 

 


【参考】

【参考】微软官方文档

C# 知识回顾 - 委托 delegate

【博主】反骨仔    【原文】

编辑:编程 本文来源:澳门新濠3559你可以通过委托实例调用方法,委托

关键词: