委托的学习总结

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，纯属学习总结果，不对之前请指出。

转载请指明出处，谢谢！