C# 委托

ゝ一世哀愁。 2021-10-14 02:00 383阅读 0赞

## 委托 ##

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

## 泛型委托 ##

将委托方法定义为`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");
            }
    
        }
    }