C#：委托

委托是一個類，它定義了方法的類型，使得可以將方法當作另一個方法的參數來進行傳遞，這種將方法動態地賦給參數的做法，可以避免在程序中大量使用If-Else（Switch）語句，同時使得程序具有更好的擴展性。

與使用一個類相似，在使用委托時，也需要經過兩個步驟：

• 定義要使用的委托。對於委托，定義它就是告訴編譯器這種類型的委托代表了哪種類型的方法(在定義委托是，必須給出它所代表的方法簽名和返回類型等全部細節。理解委托的一種好方式是把委托當作給方法簽名和返回類型指定名稱。)

delegate void IntMethodInoker(int x);

• 創建委托的一個或多個實例

using System;

namespace ConsoleApplication25
{
    class Program
    {
        private delegate string GetAString();
        static void Main(string[] args)
        {
            int x = 40;
            GetAString firstStringMethod = new GetAString(x.ToString);
            Console.WriteLine("String is {0}",firstStringMethod());
            Console.ReadLine();
        }
    }

    
}

提示：給定委托的實例可以表示任何類型的任何對象上的實例方法或靜態方法--只要方法的簽名匹配於委托的簽名即可。
下面的示例，讓firstStringMethod委托在另一個對象上調用其他兩個方法，其中一個是實例方法，另一個是靜態方法。

using System;

namespace ConsoleApplication26
{
    class Program
    {
        private delegate string GetAString();
        static void Main(string[] args)
        {
            Currency balance = new Currency(34, 50);

            // firstStringMethod references an instance method
            GetAString firstStringMethod = new GetAString(balance.ToString);
            Console.WriteLine("String is {0}", firstStringMethod());

            // firstStringMethod references a static method
            firstStringMethod = new GetAString(Currency.GetCurrencyUnit);
            Console.WriteLine("String is {0}", firstStringMethod());

            Console.ReadLine();
        }
    }

    struct Currency
    {
        public uint Dollars;
        public ushort Cents;
        public Currency(uint dollars, ushort cents)
        {
            this.Dollars = dollars;
            this.Cents = cents;
        }

        public override string ToString()
        {
            return string.Format("${0}.{1,-2:00}", Dollars, Cents);
        }

        public static string GetCurrencyUnit()
        {
            return "Dollar";
        }

        public static explicit operator Currency(float value)
        {
            checked
            {
                uint dollars = (uint)value;
                ushort cents = Convert.ToUInt16((value - dollars) * 100);
                return new Currency(dollars, cents);
            }
        }

        public static implicit operator float(Currency value)
        {
            return value.Dollars + (value.Cents / 100.0f);
        }

        public static implicit operator Currency(uint value)
        {
            return new Currency(value, 0);
        }

        public static implicit operator uint(Currency value)
        {
            return value.Dollars;
        }
    }
}

示例2：

using System;

namespace ConsoleApplication28
{
    class Program
    {
        delegate double DoubleOp(double x);
        static void Main(string[] args)
        {
            DoubleOp[] operations = { MathsOperation.MultiplyByTwo, MathsOperation.Square };
            for (int i = 0; i < operations.Length; i++)
            {
                Console.WriteLine("Using operations[{0}]:", i);
                ProcessAndDisplayNumber(operations[i], 3.0);
            }
            Console.ReadLine();
        }

        static void ProcessAndDisplayNumber(DoubleOp action, double value)
        {
            double result = action(value);
            Console.WriteLine("Value is {0}, result of the operation is {1}", value, result);
        }
    }

    class MathsOperation
    {
        public static double MultiplyByTwo(double value)
        {
            return value * 2;
        }

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

示例2的關鍵一行是把委托傳遞給ProcessAndDisplayNumber（）方法

ProcessAndDisplayNumber(operations[i], 3.0);

其中傳遞了委托名，但不帶任何參數，假定operations[i]是一個委托，其語法是：

• operations[i]表示“這個委托”。換言之，就是委托代表的方法
• operations[i](2.0)表示“調用這個方法，參數放在括號中”。

示例3：

using System;

namespace ConsoleApplication29
{
    delegate bool Comparison(object x, object y);
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] employees = { new Employee("a", 20000), new Employee("b", 10000), new Employee("c", 15000) };
            BubbleSorter.Sort(employees, new Comparison(Employee.CompareSalary));
            foreach (var employee in employees)
            {
                Console.WriteLine(employee);
            }
            Console.ReadLine();
        }
    }

    class BubbleSorter
    {
        static public void Sort(object[] sortArray, Comparison comparison)
        {
            for (int i = 0; i < sortArray.Length; i++)
            {
                for (int j = i; j < sortArray.Length; j++)
                {
                    if (comparison(sortArray[j], sortArray[i]))
                    { 
                        object temp=sortArray[i];
                        sortArray[i]=sortArray[j];
                        sortArray[j]=temp;
                    }
                }
            }
        }
    }

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

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

        public static bool CompareSalary(object x, object y)
        {
            Employee e1 = (Employee)x;
            Employee e2 = (Employee)y;
            return (e1.salary < e2.salary);
        }
    }
}

輸出：

 

多播委托：當一個委托只包含一個方法調用，調用委托的次數與調用方法的次數相同，如果調用多個方法，就需要多次顯示調用這個委托。委托也可以包含多個方法，這種委托成為多播委托。

如果調用多播委托，就可以按順序連續調用多個方法。為此，委托的簽名就必須返回void，否則就只能得到委托調用的最后一個方法的結果。

using System;

namespace ConsoleApplication30
{
    delegate void DoubleOp(double value);
    class Program
    {
        static void Main(string[] args)
        {
            DoubleOp operations = new DoubleOp(MathOperations.MultiplyByTwo);
            operations += MathOperations.Square;
            ProcessAndDisplayNumber(operations, 3.0);
            Console.ReadLine();
        }

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

    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);
        }
    }
}

注意：如果使用多播委托，就應注意對同一個委托調用方法鏈的順序並未正式定義，一次應避免編寫依賴於以特定順序調用方法的代碼。
通過一個委托調用多個方法還有一個問題，多播委托包含一個諸葛調用的委托集合，如果通過委托調用的一個方法拋出了異常，整個迭代就會停止。例如：

using System;

namespace ConsoleApplication31
{
    public delegate void DemoDelegate();
    class Program
    {
        static void Main(string[] args)
        {
            DemoDelegate dl = new DemoDelegate(One);
            dl += Two;
            try
            {
                dl();
            }
            catch(Exception)
            {
                Console.WriteLine("Exception caught");
            }
            Console.ReadLine();
        }

        static void One()
        {
            Console.WriteLine("One");
            throw new Exception("Error in one");
        }

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

輸出：
委托只調用了第一個方法，第一個方法拋出了異常，所以委托的迭代會停止，不再調用Two（）方法。

為了避免這個問題，應手動迭代方法列表。Delegate類定義了方法GetInvocationList（），它返回一個Delegate對象數組。

using System;

namespace ConsoleApplication31
{
    public delegate void DemoDelegate();
    class Program
    {
        static void Main(string[] args)
        {
            DemoDelegate dl = new DemoDelegate(One);
            dl += new DemoDelegate(Two);
            Delegate[] delegates = dl.GetInvocationList();
            for (int i = 0; i < delegates.Length; i++)
            {
                DemoDelegate d = (DemoDelegate)delegates[i];
                try
                {
                    d();
                }
                catch (Exception)
                {
                    Console.WriteLine("Exception caught");
                }
            }
            Console.ReadLine();
        }

        static void One()
        {
            Console.WriteLine("One");
            throw new Exception("Error in one");
        }

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

輸出：

匿名方法：到目前為止，要想使委托工作，方法必須已經存在。但是使用委托還有另外一種方式：即通過匿名方法。匿名方法是用做委托參數的一個代碼塊。

用匿名方法定義委托的語法和前面的定義並沒有區別，但是實例化委托時就有區別了。

using System;

namespace ConsoleApplication32
{
    class Program
    {
        delegate string DelegateTest(string val);
        static void Main(string[] args)
        {
            string mid = ", middle part,";
            DelegateTest anonDel = delegate(string param)
            {
                param += mid;
                param += " and this was added to the string.";
                return param;
            };

            Console.WriteLine(anonDel("Start of string"));
            Console.ReadLine();
        }
    }
}

在Main方法中，定義anonDel時，不是傳送已知的方法名，而是使用一個簡單的代碼塊。
在使用匿名方法是，必須遵循兩個規則：在匿名方法中不能使用跳轉語句調到該匿名方法的外部；反之亦然：匿名方法外部的跳轉語句不能調到該匿名方法的內部。

• 在匿名方法內部不能訪問不完全的代碼
• 不能訪問在匿名方法外部使用的ref和out參數，但可以使用在匿名方法外部定義的其他變量
• 如果需要用匿名方法多次編寫同一個功能，就不要使用匿名方法，而編寫一個指定的方法比較好，因為該方法只能編寫一次，以后可通過名稱引用它

l表達式 ： 為匿名方法提供了的一個新語法。

using System;

namespace ConsoleApplication33
{
    class Program
    {
        delegate string DelegateTest(string val);
        static void Main(string[] args)
        {
            string mid = ", middle part,";
            DelegateTest anonDel = param =>
                {
                    param += mid;
                    param += " and this was added to the string.";
                    return param;
                };
            Console.WriteLine(anonDel("Start of the string"));
            Console.ReadLine();
        }
    }
}

運算符=>的左邊列出了匿名方法需要的參數。有幾種編寫方式：

1. 在括號中定義類型和變量名：

(string param) =>

2. 省去變量類型：

(param) =>

3. 如果只有一個參數，就可以刪除括號：

DelegateTest anonDel = param =>

表達式的右邊列出了實現代碼。如果實現代碼只有一行，也可以刪除花括號和return語句。

利用l表達式 來寫前面的多播委托示例，優點是它刪除了類：

using System;

namespace ConsoleApplication34
{
    class Program
    {
        delegate double DoubleOp(double value);
        static void Main(string[] args)
        {
            DoubleOp multByTwo = val => val * 2;
            DoubleOp square = val => val * val;

            DoubleOp[] operations = { multByTwo, square };

            for (int i = 0; i < operations.Length; i++)
            {
                Console.WriteLine("Using operations[{0}]", i);
                ProcessAndDiaplayNumber(operations[i], 3.0);
            }

            Console.ReadLine();
        }

        static void ProcessAndDiaplayNumber(DoubleOp action, double value)
        {
            double result= action(value);
            Console.WriteLine("The result of the value: {0} is {1}", value, result);
        }
    }
}

 返回類型協變：方法的返回類型可以派生於委托定義的類型。在下面的示例中，委托MyDelegate1定義為返回DelegateReturn類型。賦予委托實例d1的方法Method1返回DelegateReturn2類型，DelegateReturn2派生於DelegateReturn，因此滿足了委托的需求，這成為返回類型協變。

namespace ConsoleApplication35
{
    public class DelegateReturn
    {
    }

    public class DelegateReturn2 : DelegateReturn
    {
    }

    public delegate DelegateReturn MyDelegate1();

    class Program
    {
        static void Main()
        {
            MyDelegate1 d1 = Method1;
            d1();
        }

        static DelegateReturn2 Method1()
        {
            DelegateReturn2 d2 = new DelegateReturn2();
            return d2;
        }
    }
}

 

參數類型協變：表示委托定義的參數可能不同於委托調用的方法。這里是返回類型不同，因為方法使用的參數類型可能派生自委托定義的類型。

namespace ConsoleApplication36
{
    public class DelegateParam
    { }

    public class DelegateParam2 : DelegateParam
    { }

    public delegate void MyDelegate2(DelegateParam2 p);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate2 d2 = Method2;
            DelegateParam2 p = new DelegateParam2();
            d2(p);
        }

        static void Method2(DelegateParam p)
        { }
    }
}