《C#高级编程》读书笔记（五）：委托

1，委托的概念

当需要把方法传递给其他方法时，需要调用委托。委托只是一种特殊类型的对象，其特殊之处在于，我们之前定义的所有对象都包含数据，而委托包含的只是一个或多个方法的地址。

委托的类型安全性非常高。在定义委托时，必须给出它所表示的方法的签名和返回类型等全部细节。

2，使用委托的场景

给一个方法传递的参数也是方法，而且编译时不知道第二个方法是什么，这个信息只能在运行时得到，所以把第二个方法作为参数传递给第一个方法。

3，简单的例子

        public static string StrAddTwo(string x)
        {
            return x + 2;
        }

        public static string StrAddThree(string x)
        {
            return x + 3;
        }

        public delegate string StrAdd(string x);

        static void Main(string[] args)
        {
            StrAdd strAdd = StrAddTwo;
            Console.WriteLine(strAdd("Test"));
            strAdd = StrAddThree;
            Console.WriteLine(strAdd("Test"));

            Console.ReadKey();
        }

 4，更贴切点的例子

然而，委托并不是为了这些简单的操作而设计的，所以，必须用一个足够复杂的例子才能体现委托的必要。

首先，看一个给int数组进行冒泡排序的方法，代码如下：

        static void Main(string[] args)
        {
            int[] arr = new[] {5, 2, 4, 9, 15};
            Sort(arr);

            Console.ReadKey();
        }

        static void Sort(int[] sortArray)
        {
            bool swapped = true;
            do
            {
                swapped = false;
                for (int i = 0; i < sortArray.Length-1; i++)
                {
                    if (sortArray[i]>sortArray[i+1])
                    {
                        int temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        swapped = true;
                    }
                }
            } while (swapped);

            //查看排序结果
            foreach (var item in sortArray)
            {
               Console.WriteLine(item);
            }
        }

这个方法只适合于int类型，但我们希望Sort()方法能给任何对象排序，那么上面代码中的if (sortArray[i]>sortArray[i+1])就有问题了，因为它需要比较数组中的两个对象，看看哪一个更大。可以对int进行这样的比较，对如何对没有实现“<”运算符的新类进行比较？答案是能识别该类的客户端代码必须在委托中传递一个封装的方法，这个方法可以进行比较。

    public class BuddleSorter
    {
        public static void Sort<T>(IList<T> sortArray, Func<T, T, bool> comparison)
        {
            bool swapped;
            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);
        }
    }

再定义一个类，并实现它的comparison方法：

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

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

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

测试一下：

        static void Main(string[] args)
        {
            Employee[] employees =
             {
                new Employee("Bugs Bunny",20000),
                new Employee("Elmer Fudd",10000),
                new Employee("Daffy",25000),
                new Employee("Wile",100000.38m),
                new Employee("Forhorn",23000),
                new Employee("Road Runner",50000)
            };
            BuddleSorter.Sort(employees, Employee.CompareSalary);
            foreach (var employee in employees)
            {
                Console.WriteLine(employee);
            }

            Console.ReadKey();
        }

输出结果：

Elmer Fudd,￥10,000.00
Bugs Bunny,￥20,000.00
Forhorn,￥23,000.00
Daffy,￥25,000.00
Road Runner,￥50,000.00
Wile,￥100,000.38

5，多播委托

多播委托可以包含多个方法，这样的委托称为多播委托。如果调用多播委托，就可以按照顺序调用多个方法。示例代码：

Action<double> operations = MathOperations.MultiplyByTwo;
            operations += MathOperations.Square;
            ProcessAndDispayNumber(operations, 2.0);
            ProcessAndDispayNumber(operations,7.94);
            ProcessAndDispayNumber(operations,1.414);
            Console.ReadLine();

多播委托的缺点：如果其中一个方法，如果其中一个方法抛出异常，委托迭代将会终止，不会执行后面的方法。这时需要调用Delegate类定义的GetInvocationList()方法，它返回一个Delegate对象数组，现在可以使用这个委托调用与委托直接相关的方法，捕获异常，并继续下一次迭代。

6，匿名方法

匿名方法就是用作委托的参数的一段代码。如下所示：

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

7，lambda表达式以及闭包

double d = 4;
Func<double,  double> oneParams = (x) => x * d;
Console.WriteLine(oneParams(3));
//输出12

 8，使用foreach语句的闭包

var values = new List<int>() {1,2,3};
            var funcs = new List<Func<int>>();

            foreach (var value in values)
            {
                funcs.Add(()=>value);
            }

            foreach (var f in funcs)
            {
                Console.WriteLine(f());
            }

输出：

1

2

3

这和c#4.0是不一样的，需要注意

9，事件

事件基于委托，为委托提供了一种发布/订阅机制。