委托的学习总结

1、委托是什么？
委托就是能将方法当作参数传递的东西。举个栗子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyDelegate
{
    public delegate void DelSayHi(string UserName);//这里就定义了一个委托类型，实际编译的时候它是一个类，只不过publc class改成了public delegate,并且多了个返回值（这里是void）夹在中间，然后类名（DelSayHi)，最后就是定义委托的参数签名：它有多少个输入参数，各是什么类型。
    class Program
    {
                static void Main(string[] args)
        {

            //这里实例化了一个委托对象，另外还有一种写法DelSayHi hi=new DelSayHi(SayHiChinese);编辑出来的结果一样一样的。
            DelSayHi hi = SayHiChinese;

            //将这个委托当然参数，传给了Runner函数，就跟一个实例化一个类后，将其传给一个函数；
            Runner("三及弟", hi);



            //这里就进一步简化了，不需要用一个类实例去接装着，再调用，就直接将函数名做参数传过去便可以，换个想法，其实函数
            //SayHiChinese和SayHiEnglish它的返回值，参数个数、参数类型（这三者合起来就叫函数签名）跟定义的委托类型DelSayHi一至
            //那么就可以理解SayHiChinese和SayHiEnglish 本身就是委托类型DelSayHi的实例。
            Runner("柯南", SayHiChinese);
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="delSayhi">我就是一个委托类型的参数：将要执行的函数本身传递了过来</param>
        public static void Runner(string name, DelSayHi delSayhi)
        {
            delSayhi(name);
        }


        public static void SayHiEnglish(string UserName)
        {
            Console.WriteLine("what's up!"+UserName);
        }
        public static void SayHiChinese(string UserName)
        {
            Console.WriteLine("吃了吗!" + UserName);
        }
    }
}

上面代码，只要理解两个想法，就能明白委托本身是什么：
1、为了将函数作为参数，就有了委托
2、委托的实质，也就是一个类。

————————–来一条恶心的分隔线———————–

知道委托是什么后，第一反应应该是这样：然并卵。
1、直接调那个函数不就好了吗？
2、不直接调，有很明显的解耦作用吗？
没解决这两问题，实际开发中还真用不上委托。上面的demo只不过是解释了委托是什么鬼。深入点就慢慢发现有意思的事情了。带着耐心再了解委托的其它知识先：
1、多播委托（完全题外话，先不管了）
2、匿名函数
3、泛型委托
4、lambda表达式

关于《2、匿名函数》
匿名函数，就像是语法糖，上边的代码中，为了使用委托，不得不定义一个以上方法
public static void SayHiEnglish(string UserName)
public static void SayHiChinese(string UserName)
….
利用匿名函数就可以轻松省事了，上代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AnonymousFunction
{
    public delegate string MyDelegate(string input);//定义一个委托，输入参数就一个string，返回也是一个string

    class Program
    {


        /// <summary>
        /// 这个栗子目的是为了对字符串进行处理
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            string input = "2#sdf23fa2FASD2";
            //我要转大写
            string outPut = Runner(input, delegate (string parm) { return parm.ToUpper(); });//直接用delegate关键字，后边的写法就跟函数一样了
            Console.WriteLine(outPut);

            //我要去掉2，因为我不二，更不二百五
            outPut = Runner(input, delegate (string parm) { return parm.Replace("2", ""); });//直接用delegate关键字，后边的写法就跟函数一样了
            Console.WriteLine(outPut);

            Console.ReadLine();
        }

        static string Runner(string input, MyDelegate mydelgate)
        {
            input = input.Trim();
            return mydelgate(input);
        }
    }
}

这段代码应该不用多解释，只不过利用上了delegate关键字，将方法写在调用的参数里头去了。这样省事，省代码，省电，省时间。损失是方法体这样写，就不能像平时的函数一样被其它地方重复调用。

感觉有了delegate关键字，省去再写了个函数的工夫，不足以让人感动，还是不想去用它。还是耐心去看下

关于4、lambda表达式
针对上边的匿名函数，再一改造就成了lambda表达式了，再上代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyLambda
{
    public delegate string MyDelegate(string input);//这句别看了，跟上边的函数名字一样，我复制过来的
    class Program
    {
        static void Main(string[] args)
        {
            string input = "2#sdf23fa2FASD2";


            //我要转大写
            string outPut = Runner(input, (string parm) =>{ return parm.ToUpper(); });//整段代码，只不过就去掉delegate关键字，再在方法体与输入参数括号后加上=>这个符号，微信为这个符号起个名字叫goes to
            Console.WriteLine(outPut);

            //我要去掉2，因为我不二，更不二百五
            outPut = Runner(input, (string parm)=> { return parm.Replace("2", ""); });
            Console.WriteLine(outPut);

            Console.ReadLine();

        }

        /// <summary>
        /// 不用看这里了，也是复制过来的
        /// </summary>
        /// <param name="input"></param>
        /// <param name="mydelgate"></param>
        /// <returns></returns>
        static string Runner(string input, MyDelegate mydelgate)
        {
            input = input.Trim();
            return mydelgate(input);
        }

    }
}

整段代码，只不过就去掉delegate关键字，再在方法体与输入参数括号后加上=>这个符号，微信为这个符号起个名字叫goes to。于是，一真纠结于心的lambda表达式为什么有这样奇怪而不奇葩的写法就快解开了。还剩下Expression

//未完待续。。老板催工作。

本人第一次写blog，纯属学习总结果，不对之前请指出。
转载请指明出处，谢谢！