C#中的委托是什么

https://www.cnblogs.com/deepalley/p/12150931.html

1.什么是委托？（方法作另一个方法的参数）
delegate void MyDel(int value);    //声明委托类型
和类一样，委托是用户自定义的类型，但是类是数据和方法的集合，而委托是持有一个或多个方法。
delegate可以看做是一个包含有序方法列表的对象，这些方法具有相同的签名和返回类型。
委托保存的方法可以来自任何类或结构
调用列表中的方法可以是实例方法也可以是静态方法
调用委托时，会执行调用列表中的所有方法

2.声明委托类型
delegate    void      MyDel        (int value);委托的是无返回值，且单一int参数的方法
关键字    返回类型    委托类签名      签名

3.创建委托对象
MyDel       delVar;
委托类型     变量
delVar = new MyDel(myInstObj.MyM1);    或    delVar = myInstObj.MyM1;
delVar = new MyDel(sClass.otherM2);    或    delVar = sClass.otherM2;

4.组合委托
MyDel a = myInstObj.myM1;
MyDel b = SClass.OtherM2;
MyDel c = a + b;

5.为委托添加方法+=  同理删除方法： -=
MyDel delVar = inst.myM1;    //创建并初始化
delVar += Scl.m3;
delVar += X.Act;

6.调用委托(从底部函数开始执行)
MyDel delVar = inst.MyM1;
delVar(55);

7.调用带返回值的委托
最后一个方法的返回值就是委托调用返回的值，其他方法的返回值会被忽略

8.调用带引用参数的委托
参数值会根据调用列表中的一个或多个方法的返回值而改变

9.匿名方法
在初始化委托时内联声明的方法
delegate   (Parameters)    {ImplementationCode}
关键字      参数列表        语句块
delegate int OtherDel(int Inparam);
static void Main()
{
    OtherDel del = delegate(int x)
    {
        return x + 20;
    };
}

为什么使用委托：在我们编写程序的时候，程序的上下文是固定的，在某个关键的部分，不确定调用哪个函数，这时候需要让程序更换被调用函数，又不想两个函数耦合性太高，使用委托可实现间接调用，或者可替换调用

 

什么时候该用委托，为什么要用委托，委托有什么好处

我用的最多的是在多线程 访问UI界面控件的时候。
UI控件都由主线程创建和绘制的，如果子线程想访问控件的话，就把这个任务委托给主线程。
比如有个子线程 想要给 form中的label控件赋值 Label.Text="内容"
此时必须用委托让主线程去执行这个赋值语句。
如果不这么做，会出现线程安全的异常。产生多个线程同时访问同一个控件的异常。这是不符合线程安全的要求的

 C#语法——委托，架构的血液

本篇文章主要介绍委托的应用。

委托是大家最常见的语法了，但会用与精通之间的差别是巨大的。

一个程序员如果不能精通委托，那么，他永远无法成为高级程序员。

所以，让我们把委托刻到血液里吧。

这样，你才能称为[Developer]。

委托的定义

什么是委托？

委托实际上是一种类型，是一种引用类型。

微软用delegate关键字来声明委托，delegate与int，string，double等关键字一样。都是声明用的。

下面先看下声明代码，这里声明了两个委托。

1 2	public delegate void TestDelegate(string message); public delegate int TestDelegate(MyType m, long num);

delegate既然是关键字，和int，string一样，那么，为什么delegate后又跟了一个void或者int呢？

如果他们是同等地位的关键字，为什么可以一起使用呢？

很简单，我们把delegate后面的 【void TestDelegate(string message)】理解为一个变量，是不是就清晰明了了一些。

我们把delegate关键字理解为，是用来专门来定义这种复杂的变量的。而这种复杂的变量可以包含一个返回值和任意数目任意类型的传入参数。

有没有感觉，这个复杂的变量特别像一个函数的定义。

没错，官方定义，委托类型的声明与方法签名相似。所以，这个复杂变量，的确，书写的方式就是与函数一样。

那么，为什么这个声明方式如此怪异呢，是因为，我们用delegate定义的变量，只能用函数赋值。赋值方式如下所示：

1 2 3 4 5 6 7 8 9 10

public delegate void TestDelegate(string message); public delegate long TestDelegate2(int m, long num); public static void Excute() {     TestDelegate2 td = Double; } static long Double(int m, long num) {     return m * num; }

委托的基本应用

学会了赋值以后，我开始使用委托。

委托的使用方式如下：

1 2	string result = td(51, 8); Console.WriteLine(result);

这里我们会发现，委托的使用方式与函数调用一样。

没错，它们的确是一样的。因为委托是用函数来赋值的，所以调用方式一样也并不奇怪，不是吗。

换一种说法，就是委托封装了一个函数。

如果委托是封装的函数，并且它又是引用类型。那么委托第一种常规的应用就浮现出来了。

那就是——引用类型的函数。

如果函数是引用类型，那么这个函数只要没被内存回收，就可以被调用。如果是public函数或者是public static函数，那么它能跨越的东西就更多了。

比如可以跨类调用，跨程序集调用等等。而这种用法，就是委托的基本应用。

匿名委托的应用

匿名委托的官方介绍：在 2.0 之前的 C# 版本中，声明委托的唯一方式是使用命名方法。 C# 2.0 引入匿名方法，在 C# 3.0 及更高版本中，Lambda 表达式取代匿名方法作为编写内联代码的首选方式。

看不懂没关系，我们直接来学习使用。代码如下：

1 2 3 4 5 6

delegate string anonymousDelegate(int m, long num); public static void Excute() {     anonymousDelegate ad = delegate (int m, long num) { return m.ToString() + num.ToString(); };//2.0时代的匿名委托     anonymousDelegate ad2 = (m, num) => { return m.ToString() + num.ToString(); };//3.0以后匿名委托 }

如代码所示，匿名委托是Lambda表达式，不懂的同学就当它是有固定写法即可，不用讲什么道理，只要记住并应用即可。

匿名委托虽然减少了一点代码，但还是要求我们自己去声明委托。所有，还能再简写一点吗？

答案当然是，可以的。

Action与Func

Action与Func是微软为我们预先定义好了的，两个委托变量。其中Action是不带返回值的委托，Func是带返回值的委托。

可以说，Action与Func完全包含了，我们日常使用所需的，全部的，委托变量。

也就是说，我们可以不用再去自己手动声明委托了。

下面来看最简单的Action与Func的定义：

1 2	Action a1 = () => { }; Func<int> f1 = () => { return 1; };//必须写 return 1;

Action与Func是泛型委托，各支持16个入参变量。下面代码为一个入参的定义，多参数以此类推。

1 2	Action<int> a1 = (i) =>  { }; Func<string,int> f1 = (str) => {  return 1;//必须写 return 1; };

委托的线程应用

委托的线程应用是委托的第二种用法，分为线程使用委托，和委托的异步应用两种。

我们先看线程使用委托。如下代码所示，一个无入参匿名Action和一个无入参匿名Func。

1 2 3 4 5

Task taskAction = new Task(() => { });//无入参匿名Action taskAction.Start(); Task<int> taskFunc = new Task<int>(() => { return 1; });//无入参匿名Func taskFunc.Start(); int result= taskFunc.GetAwaiter().GetResult();//获取线程返回结果

我们能看到两种委托应用，代码都非常简洁。

下面我们再来看委托的异步应用。首先看最简单的异步调用。

1 2 3 4 5 6 7 8 9 10

Action action = new Action(() => { }); IAsyncResult result = action.BeginInvoke((iar) => { }, null); Func<int> func = new Func<int>(() => { return 1; });  IAsyncResult resultfunc = func.BeginInvoke((iar) => {     var res = func.EndInvoke(iar); }, null);

这里我们使用委托的BeginInvoke方法来开启线程，进行异步调用。如上面代码所示，这里介绍了Action与Func的最基础的异步应用。

委托，架构的血液

委托是架构的血液，如果系统中没有委托，那代码将堆叠到一起，比大力胶粘的都紧密。

就好比一碗汤面倒掉了所有的汤，只要它静放一个阵子，就会变成一坨面球，让你无从下嘴。

所以，委托是架构的血液，是框架的流畅的基石。

那么委托到底是如何流动的呢？

我们先从刚介绍过的委托的线程应用说起。

----------------------------------------------------------------------------------------------------

第一核心应用——随手线程：

我们在做开发的时候，一定接触过父类。父类是干什么的呢？父类通常是用来编写公共属性和函数，方便子类调用的。

那我们的委托的第一个核心应用，就是父类的公共函数，线程随手启动。如何随手开启呢？

首先，我们创建父类代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class BaseDelegateSyntax {     public void AsyncLoad(Action action)     {     }     public void AsyncLoad(Action action, Action callback)     {         IAsyncResult result = action.BeginInvoke((iar) =>         {             callback();         }, null);     }     public void AsyncLoad<T>(Action<T> action, T para, Action callback)     {         IAsyncResult result = action.BeginInvoke(para, (iar) =>         {             callback();         }, null);     }     public void AsyncLoad<T, R>(Func<T, R> action, T para, Action<R> callback)     {         IAsyncResult result = action.BeginInvoke(para, (iar) =>         {             var res = action.EndInvoke(iar);             callback(res);         }, null);     } }

我们看到上面的代码，父类中添加了四个异步委托的调用函数，接下来，我们就可以在继承该类的子类中，随手开启线程了。

子类代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

class ChildDelegateSyntax : BaseDelegateSyntax {     public void Excute()     {         //开启异步方法         base.AsyncLoad(() => { });         //开启异步方法，并且在异步结束后，触发回调方法         base.AsyncLoad(() => { },             ()=>             {                 //我是回调方法             });         //开启异步有入参的方法，传递参数，并且在异步结束后，触发回调方法         base.AsyncLoad<string>((s) => { },"Kiba518",            () =>            {                 //我是回调方法            });         //开启异步有入参的方法，传递字符串参数Kiba518，之后返回int型结果518，         //并且在异步结束后，触发回调方法，回调函数中可以获得结果518         base.AsyncLoad<string,int>((s) => {             return 518;         }, "Kiba518",            (result) =>            {                //我是回调方法 result是返回值518            });     } }

看了上面的父子类后，是否感觉委托让我们繁杂的线程世界变简洁了呢？

----------------------------------------------------------------------------------------------------

第二核心应用——穿越你的世界：

接下来，我们来看委托的第二种核心用法，穿越的应用。

这个应用，是最常见，也最普通的应用了。因为委托是引用类型，所以A类里定义的委托，可以在被内存回收之前，被其他类调用。

我们经常会在各种论坛看到有人发问，A页面如何调用B页面的属性、方法、父页面获取子页面的属性、方法，或者子页面获取父页面的属性、方法。

其实，只要定义好委托，并将委托正确的传递，就可以实现穿越的调用了。

下面我们看下穿越应用的代码。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class FirstDelegateSyntax {     public FirstDelegateSyntax()     {         Console.WriteLine(" First 开始 "  );         SecondDelegateSyntax sds = new SecondDelegateSyntax(()=> {             Console.WriteLine(" First传给Second委托被触发 ");         });         sds.Excute();         Console.WriteLine(" First 结束 ");     } } public class SecondDelegateSyntax {     public Action Action { get; set; }     public SecondDelegateSyntax(Action _action)     {         Console.WriteLine(" Second的构造函数 ");         Action = _action;     }     public void Excute()     {         Console.WriteLine(" Second的Excute被触发 ");         Action();     } }

我们可以看到，我们传递的委托，穿越了自身所属的类。在SecondDelegateSyntax类中被触发了。

运行结果如下：

第三核心应用——回调函数：

世界上本没有回调函数，叫的人多了，也就有了。

请记住，所有的回调函数，都是委托的穿越应用，所有的回调函数；都是委托的穿越应用；所有的回调函数，都是委托的穿越应用。

重要的话要讲三遍。

因为委托是引用类型，所以可以被[址传递]。函数是不可以被传递的。

当你传递函数的时候，其实是匿名传递了一个委托的地址。

结语

委托是我们最常用的语法，它将函数封装成引用类型的变量，供其他单位调用。

因为委托的特质是引用类型，所以决定了委托是可以进行址传递。也就是说，委托是穿梭于我们系统代码中的列车。

我们可以在列车上放很多很多东西，在需要的站点，叫停列车，并将托运的东西搬下来使用。

所以，理论上，只要我们利用好委托，就可以大量减少冗余的代码。

但委托这种列车，是每个程序员都可以定义的，如果一个项目中有十个开发者，每个人都在定义委托，那么，就有可能出现定义了十个相同的委托的情况，这样就出现了撞车的现象。

所以委托在使用的时候，尽量做到有序传递，即预先做好列车的行驶路线，让委托按照路径运行。尽量不要定义可以被任何单位调用的公共委托。

如果需要公共委托，可以采取反射的方式来调用。

模板方法（把委托当作参数传递到方法里去，通过传进的委托参数，它“借用”制定的外部方法，来产生一个结果）

模板方法的好处是什么呢？一旦我们把代码写成了这样只会，我们的GetTopNum方法呢，就不需要去动它了

 我们只需要的是不断扩张，我们之后想比较的成员变量就可以计算出，玩家每个成员中最高的玩家的名字（比如说我们之后增加了【金币数】GetTopNum方法就不用动，只要新增一个小方法，如果用Lambda表达式的话，小方法也可以省去）我们不用去管我们计算的到底是哪个数据，我们只要把方法封装在一个委托类型的变量中，作为参数来传递，传递到我们的模板方法中，我们的模板方法就一定可以计算出。某一个成员变量它的最高值

 

 这里呢，就是初步介绍，如何通过[lambda表达式]当作一个实际参数，传递给方法的参数中