C#学习日记11——委托

1.委托的定义：委托就是指向了一个方法

2.声明的委托必须跟指向的方法有同样的签名（相同的返回值类型和参数 ） 委托一般以Del开头
举例

 public delegate void DelSayHello(string name);

调用委托，首先创建委托对象

DelSayHello del=new DelSayHello(chineseHello); //ChineseHello();

最简单的委托语法：

        public delegate void DelSayHello(string name);//声明一个委托
        static void Main(string[] args)
        {
            string name = "张三";
            DelSayHello del = new DelSayHello(ChineseHello);
            del(name);
        }
        public static void ChineseHello(string name)
        {
            Console.WriteLine("你好" + name);
        }
        public static void JapaneseHello(string name)
        {
            Console.WriteLine("o ha yo " +name);
        }

可以看到，调用方法时并不是我们以往的直接使用，而是通过委托调用，不过这样写并没有减少我们的工作量。
再看这个方法的改进版：

            string str = "qweqdasdsadas";
            //创建委托对象指向一个方法
            DelPro del = StrToupper;
           string newStr= Prostr(str, StrToupper);
         
        }
        public static string Prostr(string str,DelPro del)
        {
            string strNew = null;
           char[] chs= str.ToCharArray();
            for (int i = 0; i < str.Length; i++)
            {
                strNew += del(chs[i].ToString());
            }
            return strNew;
        }
        public static string StrToupper(string str)
        {
            return str.ToUpper();
        }
        public static string StrTolower(string str)
        {
            return str.ToLower();
        }
        public static string StrProcess(string str)
        { 
            return @"\"+str+@"\";
        }

这个方法相对于上一个，减少了很多的代码量，而且将委托作为参数传入的方法中，只需要向委托中传入合适的方法，即可。
这个方法依旧有改进版，我们可以使用object类型作为它的参数和返回值

 public delegate int DelCompare(object o1, object o2);
        static void Main(string[] args)
        {
            object[] nums = { "sadasdawqeqeasd","qwewqeqw665465454eqe","wdsadasdwqwq12832183912qweqwasda" };
            DelCompare del = Compare2;
            object o = GetMax(nums, del);
            Console.WriteLine(o);

        }
        public static object GetMax(object[] nums,DelCompare del)
        {
            object max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                if (del(nums[i],max)>0)
                {
                    max = nums[i];
                }
            }
            return max;
        }
        public static int Compare(object o1, object o2)
        {
            int n1 = (int)o1;
            int n2 = (int)o2;
            return n1 - n2;
        }
        public static int Compare2(object o1, object o2)
        {
            string s1 = (string)o1;
            string s2 = (string)o2;
            return s1.Length - s2.Length;
        }

只需要在最开始选择委托指向的方法，即可进行判断。

3.匿名函数
当我们的方法只是用一次时，一般不考虑封装成方法，我们可以选择使用匿名函数。可以看到，这个方法没有名字，而是直接使用委托调用。

  DelTest del = delegate (string name)
            {
                return name;
            };
           string s= del("张三");
            Console.WriteLine(s);

4.泛型委托
这个是上面的升级版

  //代表为泛型委托
        public delegate int DelCompare<T>(T ti,T t2);
        static void Main(string[] args)
        {
            // int[] nums = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
            // DelCompare<int> del = Compare;
            //int a =GetMax<int>(nums, del);
            // Console.WriteLine(a);
            Person[] p = { new Person() { Age = 18 }, new Person { Age = 20 } };
            DelCompare<Person> del = Compare;
            Person a = GetMax<Person>(p, del);
            Console.WriteLine(a.Age);

        }
        public static T GetMax<T>(T[] nums,DelCompare<T> del)
        {
            T max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                if (del(max,nums[i])<0)
                {
                    max = nums[i];
                }
            }
            return max;
        }
        public static int Compare(int n1,int n2)
        {
            return n1 - n2;
        }
        public static int Compare(Person p1, Person p2)
        {
            return p1.Age - p2.Age;
        }
    }
    public class Person
    {
        private int _age;

        public int Age { get => _age; set => _age = value; }
    }

上面的T是我们创建的类型，再调用的时候

 DelCompare<Person> del = Compare;//这个<>里填写什么类型，就会全部转变为该类型。

5.lamda表达式
可以理解为： lamda表达式————》匿名函数————》函数

  //匿名函数

            //  DelTest del = delegate (string name)
            //  {
            //      return name;
            //  };
            //Console.WriteLine(  del("张三"));


            //lamda表达式
            DelTest del = (string name) => { return name; };
            Console.WriteLine(del("张三"));

与上面效果是一样的，不过要注意=后的第一个括号里面是传进去的参数，后面是方法体。
再来几个对应的：

        public delegate void DelTest();
        public delegate void DelTest1(string name);
        public delegate string DelTest2(string name);
        static void Main(string[] args)
        {
            DelTest del=() =>{ };
            DelTest1 del1 = (string name)=> {  };
            DelTest2 del2 = (string name) => { return name; };
        }

没一个表达式，和上面相对的委托都是对应的。

6.多播委托
一个委托执行N个方法

  DelTest del = Test1;
            del += Test2;
            del += Test3;
            del -= Test2;
            del();

用起来Test2Test3Test4会全部执行。