委托，Lambda，事件学习

　　委托是寻址方法的.net版本，是类型安全的类，它定义了返回类型和参数的类型，包含方法的引用及多个方法的引用（微软的解释）。

我理解是：就是一个方法的类型（就是有相同参数个数，相同参数类型和返回类型）。

委托的定义：delegate T qiuhe<T>(T a, T b); T 为任何类型

委托实现派生System.MulticastDelegate>System.Delegate

定义委托基本上是定义一个新类，所以可以在定义类的任何相同地方第一委托（可以在另一个类的内部或外部命名空间中定义），可以加访问修饰符：public,private,protected等。

泛型委托：Action<T>,Func<T>,至多可以传递16个参数类型和一个返回类型

例子：对不同类型实体按指定规则排序

class Program
    {
        static void Main(string[] args)
        {
            Employee[] ems = { 
                             new Employee("张三",20000),
                             new Employee("李四",15000),
                             new Employee("杨过",55000),
                             new Employee("小龙女",75000),
                             new Employee("段誉",85000),
                             new Employee("周五",35000),
                             };
            Console.WriteLine("排序前：");
            foreach (var item in ems)
            {
                Console.WriteLine(item);
            }
            Sort<Employee>(ems, Employee.CompareSalary);
            Console.WriteLine("排序后：");
            foreach (var item in ems)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("--------------------------------------");
            MaxSalary<Employee>(ems, Employee.GetSalaryEmployee);
            MinSalary<Employee>(ems, Employee.GetSalaryEmployee);
            Console.WriteLine("----------2---------------------------");
            Action<IList<Employee>, Func<Employee, Employee, bool, Employee>> aa = MaxSalary;
            aa += MinSalary;
            test(aa, ems, Employee.GetSalaryEmployee);
            Console.WriteLine("------------匿名方法------------------");
            niming();
            Console.WriteLine("============Lambda----------------表达式---------");

            lambda(ems);

            Console.ReadLine();
        }

        public static void Sort<T>(IList<T> sortArray, Func<T, T, bool> com)
        {
            bool swapped = true;
            do
            {
                swapped = false;
                for (int i = 0; i < sortArray.Count - 1; i++)
                {
                    if (com(sortArray[i + 1], sortArray[i]))
                    {
                        T temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        swapped = true;
                    }
                }
            }
            while (swapped);
        }

        public static void MaxSalary<T>(IList<T> sortArray, Func<T, T, bool, T> com)
        {
            T temp = sortArray[0];
            for (int i = 0; i < sortArray.Count - 1; i++)
            {
                temp = com(temp, sortArray[i + 1], true);
            }
            Console.WriteLine("最高工资：" + temp.ToString());

        }

        public static void MinSalary<T>(IList<T> sortArray, Func<T, T, bool, T> com)
        {
            T temp = sortArray[0];
            for (int i = 0; i < sortArray.Count - 1; i++)
            {
                temp = com(temp, sortArray[i + 1], false);
            }
            Console.WriteLine("最低工资：" + temp.ToString());
        }

        public static void test(Action<IList<Employee>, Func<Employee, Employee, bool, Employee>> action, IList<Employee> sortArray, Func<Employee, Employee, bool, Employee> com)
        {
            action(sortArray, com);
        }

        public static void niming()
        {
            string str;
            Func<string, string, string> funcdel = delegate(string str1, string str2)
            {
                return str1 + "和" + str2;
            };
            str = funcdel("小龙女", "杨过");
            Console.WriteLine(str);
        }

        public static void lambda(IList<Employee> ems)
        {
            Console.WriteLine("最高工资 " + ems.Max(p => p.Salary));
            
        }
    }

class Employee
    {
        public Employee(string name, decimal salary)
        {
            this.Name = name;
            this.Salary = salary;
        }
        public string Name { get; set; }
        public decimal Salary { get; set; }
        /// <summary>
        /// 重写tostring方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("{0},{1:C}", Name, Salary);
        }
        /// <summary>
        /// 小到大
        /// </summary>
        /// <param name="e1"></param>
        /// <param name="e2"></param>
        /// <returns></returns>
        public static bool CompareSalary(Employee e1, Employee e2)
        {
            return e1.Salary < e2.Salary;
        }
        /// <summary>
        /// 比较大小返回大的对象或小的
        /// </summary>
        /// <param name="e1"></param>
        /// <param name="e2"></param>
        /// <param name="ismax">true 返回大的</param>
        /// <returns></returns>
        public static Employee GetSalaryEmployee(Employee e1, Employee e2, bool ismax)
        {
            if (ismax)
            {
                return e1.Salary < e2.Salary ? e2 : e1;
            }
            return e1.Salary < e2.Salary ? e1 : e2;
        }

    }

多播委托：委托也可以包含多过方法，这种委托称为多播委托

如果调用多播委托，就可以按顺序连续调用多个方法，为此，委托的签名就必须返回void;否则，就只能得到委托调用的最后一个方法的结果。

 Action<IList<Employee>, Func<Employee, Employee, bool, Employee>> aa = MaxSalary;
            aa += MinSalary;
            test(aa, ems, Employee.GetSalaryEmployee);

支持运算符+,+=,-,-=

匿名方法：是用着委托的参数的一段代码

例如：

public static void niming()
        {
            string str;
            Func<string, string, string> funcdel = delegate(string str1, string str2)
            {
                return str1 + "和" + str2;
            };
            str = funcdel("小龙女", "杨过");
            Console.WriteLine(str);
        }

使用匿名方法时，必须遵循两条规则。在匿名方法中不能使用跳转语句（break，goto或continue）跳到该匿名方法的外部，反之亦然：匿名方法外部的跳转语句不能跳到该匿名方法的内部。在匿名方法内部不能访问不安全的代码。另外，也不能访问在匿名方法外部使用的ref和out参数。但可以使用在匿名方法外部定义的其他变量。

如果需要匿名方法多次编写同一个功能，就不要使用匿名方法。

Lambda 表达式

运算符=>

访问外部变量，编译器会创建一个匿名类，它有一个构造函数来传递外部变量。

public static void lambda(IList<Employee> ems)
        {
            Console.WriteLine("最高工资 " + ems.Max(p => p.Salary));    
        }

 第一次写，呵呵