C# 委托

委托

作用：将多个参数相同的方法，进行委托统一调用，将参数和调用方法传递给委托，由委托调用。
好处：可以将多个方法内相同的部分提取出来，根据参数和方法参数，调用需要的方法部分。
核心：减少代码量，减少冗余重复的代码。

泛型委托

将委托方法定义为T类型（泛型），可以在调用函数时，规定参数的类型，从而达到方法参数多类型适用，减少代码量。

匿名函数

嵌到在参数内的完整函数（包括函数的方法体，从而省去再次声明此函数）

Lamda表达式

更加精简的匿名函数写法

1. 匿名函数：DelOne del = delegate(参数) {...};
   Lamda表达式：DelOne del = (参数) => {...};
2. 匿名函数：DelTwo del = deletgate(string name) { Console.WriteLine(name); };
   Lamda表达式：DelTwo del = (string name) => { Console.WriteLine(name); };

多播委托

委托不仅仅只能指向一个函数，可以同时指向多个函数。
详细理解 请看代码实例。

代码实例

委托：

namespace _11_demo
{
    //声明一个委托类型，指向一个函数，该类型函数参数必须相同
    public delegate void DelSay(string name);
    
    class Program
    {
        static void Main(string[] args)
        {
            Say("张珊", SayEnglish);
            Say("李四", SayChinese);
        }
        /// <summary>
        /// 委托方法
        /// </summary>
        /// <param name="name">名字</param>
        /// <param name="del">方法参数</param>
        public static void Say(string name,DelSay del)
        {
            //调用参数的方法
            del(name);
        }

        public static void SayEnglish(string name)
        {
            Console.WriteLine("Nice to meet you," + name);
        }

        public static void SayChinese(string name)
        {
            Console.WriteLine("很高兴见到你，" + name);
        }
    }
}

匿名函数：

namespace _11_demo
{
    //声明一个委托类型，指向一个函数,参数必须相同
    public delegate void DelSay(string name);
    
    class Program
    {
        static void Main(string[] args)
        {
            //匿名函数，在委托传递方法参数时，就把方法体完成，省去声明函数
            DelSay del1 = delegate (string name) { Console.WriteLine("很高兴见到你，" + name); };
            del1("张珊");
            //匿名函数，在委托传递方法参数时，就把方法体完成
            DelSay del2 = delegate (string name) { Console.WriteLine("Nice to meet you," + name); };
            del2("李四");
        }
        
    }
}

泛型委托：比较大小（同时适用字符和数字，字符比长度，数字比大小）

namespace _13_demo
{
	 //声明一个委托类型，指向一个函数，该类型函数参数必须相同
    public delegate int DelCompare<T>(T o1, T o2);
    
    class Program
    {
        static void Main(string[] args)
        {
            string[] str = { "kasjf", "ahh", "hakfuuwi", "hiawefs" };
            int[] nums = { 1, 5, 6, 3, 4, 8, 5 };
            
            GetMax<string>(str, StringCompare);
            GetMax<int>(nums, NumCompare);
        }
		/// <summary>
        /// 比较数组中的元素，输出最大值
        /// </summary>
        /// <typeparam name="T">泛型</typeparam>
        /// <param name="os">数组</param>
        /// <param name="del">比较的方式</param>
        public static void GetMax<T>(T[] os, DelCompare<T> del)
        {
            T max = os[0];
            for (int i = 0; i < os.Length - 1; i++)
            {
            	//用委托方法调用合适的比较方式
                if (del(max, os[i]) < 0)
                {
                    max = os[i];
                }
            }
            //输出最大元素值
            Console.WriteLine(max);
        }

        /// <summary>
        /// 比较数字的大小
        /// </summary>
        /// <param name="n1">第一个数字</param>
        /// <param name="n2">第二个数字</param>
        /// <returns>第一个数字大，返回正数，第一个数字小，返回负数</returns>
        public static int NumCompare(int n1, int n2)
        {
            return n1 - n2;
        }
        /// <summary>
        /// 比较字符串的长度
        /// </summary>
        /// <param name="s1">第一个字符串</param>
        /// <param name="s2">第二个字符串</param>
        /// <returns>第一个字符串长，返回正数，第一个字符串短，返回负数</returns>
        public static int StringCompare(string s1, string s2)
        {
            return s1.Length - s2.Length;
        }
    }
}

多播委托：

namespace _15_demo
{
    //声明一个委托
    public delegate void DelT();
    class Program
    {
        static void Main(string[] args)
        {
            DelT del = T1;
            //测试一，输出“我是T1”
            del += T2;
            del += T3;
            del += T4;
            del += T1;
            //测试二，输出五句
            del -= T1;
            del -= T1;
            //测试三，输出三句，没有输出T1

            //执行委托
            del();
        }

        static void T1()
        {
            Console.WriteLine("我是T1");
        }
        static void T2()
        {
            Console.WriteLine("我是T2");
        }
        static void T3()
        {
            Console.WriteLine("我是T3");
        }
        static void T4()
        {
            Console.WriteLine("我是T4");
        }

    }
}