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