亲们，委托你们是否已忘记

   委托和事件是.Net 框架的重要组成部分，在GUI程序开发中，大量使用了事件处理，但是亲们，对于委托，我们是否还记得曾经在书上看到的详细内容。委托的使用注意事项是什么？我们会使用委托和事件，但是我们不了解事件背后的原理，亲们，我们忘记委托了吗？反正我是忘记了。

   委托是方法调用的指针，也称为函数指针，是一种特殊的对象类型，包含的是方法的地址。注意是地址，在.Net 中，委托不同于c++中的函数指针，在C#中 委托是类型安全的操作，这意味着什么呢？这意味着我们定义的方法签名必须和委托的定义类型以及返回值一致，否则会出现编译错误的提示信息。

  如何定义一个委托：

 delegate int AddDelegate(int x,int y);  委托的定义和类的定义一致，在任何可以定义类的地方都可以定义委托，另外，委托 的实现是继承自MulticastDelegate 类的，也就是说定义一个委托，基本上等价于定义一个新类。委托类似于方法的定义，但是没有方法体，只有方法签名，另外在方法签名的前面添加了delegate关键字。

  定义一个简单的委托实例：

 

  class Program
    {
        static void Main(string[] args)
        {
            Test t = new Test();
            t.Execute(3, 5);
            Console.Read();
        }
    }

    public class Test
    {
        /// <summary>
        /// 在类的内部定义了一个委托
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        delegate int AddDelegate(int x, int y);
        /// <summary>
        /// 实例方法Add1 和委托具有相同的方法签名
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Add1(int x, int y)
        {
            Console.WriteLine("Add1计算得到的值为" + (x + y));
            return x + y;
        }
        /// <summary>
        /// 静态方法Add2 和委托具有相同的方法签名
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Add2(int x, int y)
        {
            Console.WriteLine("Add2计算得到的值为" + (x + y * 2));
            return x + y * 2;
        }

        public void Execute(int x, int y)
        {
            AddDelegate addDelegate = new AddDelegate(Add1);
            addDelegate += Add2;   //通过+=  多播委托 ，表示一个委托实例具有多个方法，多播委托不能保证方法的执行顺序。
            addDelegate(x, y);
        }
        /// <summary>
        /// 多播委托在其中一个调用方法出现异常时会停止迭代，我们优先采用下面方法，即逐个的调用 方法列表执行，可以避免由于某个调用方法出现异常，导致其他调用方法无法执行的问题
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void Execute3(int x, int y)
        {
            AddDelegate addDelegate = new AddDelegate(Add1);
            addDelegate += Add2;   //通过+=  多播委托 ，表示一个委托实例具有多个方法，多播委托不能保证方法的执行顺序。
            if (addDelegate != null)
            {
                 Delegate[] addArr = addDelegate.GetInvocationList();//获取多播委托的调用列表
                 if (addArr != null)
                 {
                     foreach (var item in addArr)
                     {
                         ((AddDelegate)item)(x, y);
                     }
                 }
            }
        }
        public void Execute1(int x, int y)
        {
            AddDelegate addDelegate = Add1;//直接为委托实例赋值方法签名   称为委托推断   .Net 编译器会识别委托签名
            addDelegate += Add2;
            addDelegate(x, y);
        }
    }

实例总结：

1. addDelegate =Add1 这种为委托实例赋值的方式称为 委托推断，是由.Net 编译器自动推断方法签名是否符合委托。
2. 委托可以通过+= 来实现一个委托实例具有多个调用方法执行，请注意，多播委托的执行不能保证顺序，即不能保证方法注册的次序和调用次序一致。2.多播委托在执行过程中，如果某个调用方法出现异常，则整个多播委托的调用方法列表都会停止执行，我们可以采用Execute3 展示的那样，逐个手动执行调用方法列表，避免由于某个调用方法出现异常，导致其他调用方法不会执行的问题。
3. 委托实例的方法即可以是实例方法，又可以是静态方法，只要保证方法签名一致就可以正常的调用。
4. 委托可以作为参数传递，下面我们会展示一个通过将委托作为实例，来实现排序的功能。
5.  委托可以具有访问修饰符public、protected以及private等。
6. 可以通过委托的简便方式，匿名方法来直接定义一个方法到委托实例，.Net 编译器会帮助我们生成一个随机的方法名称，只是我们不需要。
7.  lambda 也可以应用到委托中，通过lambda表达式生成的是匿名方法，或者说是匿名委托。
   
   

我们来定义一个将委托作为参数传递，实现排序的功能。目前我们的需求是创建一个通用类库，其中有一个可以将数组中的内容按升序排列，但是数组的数据类型我们可以自定义，也就是说，我们不能指定数组的数据类型为某一种具体类型，可以为int、double ，也可以为类。

  

 class Program
    {
        static void Main(string[] args)
        {
            //Test t = new Test();
            //t.Execute(3, 5);
            List<string> listInt = new List<string>();
            
            List<Employee> listEmployee = new List<Employee>();
            for (int i = 10; i >= 0; i--)
            {
                listInt.Add(i.ToString());
                Employee employee = new Employee()
                {
                    Name = i.ToString(),
                    Salary = i
                };
                listEmployee.Add(employee);
            }
            Test1 test1 = new Test1();
            Employee[] arrEmployee = listEmployee.ToArray();
            test1.Sort(arrEmployee, test1.CompareEmployee);

            foreach (var item in arrEmployee)
            {
                Console.WriteLine(item.Salary);
            }
           
            string[]arrInt=listInt.ToArray();
            test1.Sort(arrInt, test1.CompareInt);
            foreach (var item in arrInt)
            {
                Console.WriteLine(item);
            }



            Console.Read();
        }
    }
    public class Test1
    {

        /// <summary>
        /// 委托 比较两个值的大小 x>y 返回true
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
      public  delegate bool Compare(object x, object y);

        public void Sort(object[] arrObj, Compare compare)
        {
            for (int i = 0; i < arrObj.Length; i++)
            {
                for (int j = i+1; j < arrObj.Length; j++)
                {
                    if (compare(arrObj[i], arrObj[j]))
                    {
                        object temp = arrObj[i];
                        arrObj[i] = arrObj[j];
                        arrObj[j] = temp;
                    }
                }
            }
        }


        public bool CompareEmployee(object em1, object em2)
        {
            if (em1 != null && em2 != null)
            {
                return ((Employee)em1).Salary > ((Employee)em2).Salary;
            }
            return false;
        }

        public bool CompareInt(object x, object y)
        {
            return Convert.ToInt32(x) > Convert.ToInt32(y);
        }

    }
    /// <summary>
    /// 员工类
    /// </summary>
    public class Employee
    {
        /// <summary>
        /// 员工姓名
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 员工工资
        /// </summary>
        public int Salary { get; set; }
    }

总结：

1.  将委托作为参数进行传递，实现了泛型委托可以实现的功能。
2. 可以在子类实现具体的功能，然后传递到对应的方法执行，可以有效的实现可扩展性，同时避免对其他功能的干扰。

委托作为事件的基础，本身 只具有简单的一些概念，但是我觉得要真正的在实际项目中可以灵活的使用，还是需要深入思考，做个好梦