C#中的委托怎么聲明和使用

這篇“C#中的委托怎么聲明和使用”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“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();

        }

委托在語法上總是接受一個參數的構造函數，這個參數就是委托引用的方法。這個方法必須匹配最初定義委托時的簽名。
使用委托實例的名稱，后面加上圓括號，如果需要參數就必須在圓括號內加上參數。
給委托實例提供圓括號和調用委托類的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

如果需要匿名方法多次編寫同一個功能時，就不要用匿名方法了。

以上就是關于“C#中的委托怎么聲明和使用”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。