一、委托
委托是一种用于封装命名和匿名方法的引用类型。
把方法当参数，传给另一个方法（这么说好理解，但实际上方法不能当参数，传入的是委托类型），委托是一种引用类型，委托里包含很多方法的引用
创建的方法和声明的委托返回值类型相同，参数个数相同，参数类型相同时。 这个方法就满足属于这个委托（创建的方法是 public 或者是static 都没影响，只要前三项满足即可）
用普通方式创建一个委托
//声明委托(声明委托的位置也可以在class内部) public delegate string del(double a, double b); class Program { //定义一个求和方法 public string sumResult(double a, double b) { double sum = a + b; string str1 = Convert.ToString(sum); string str2 = "结果等于" + str1; return str2; } //定义一个乘积方法 public string multiplyResult(double a, double b) { double sum = a * b; string str1 = Convert.ToString(sum); string str2 = "结果等于" + str1; return str2; } static void Main(string[] args) { Program p = new Program(); //加载一个相加方法 del sr = new del(p.sumResult);
//可以简便方式加载一个方法 del mr = p.multiplyResult; //调用委托对象传入参数，用string类型接收结果 string str1 = sr(2, 3); string str2 = mr(2, 3); Console.WriteLine(str1); Console.WriteLine(str2); Console.ReadKey(); } }
引用静态方法的方式
//声明委托 public delegate string del(double a, double b); //定义一个静态方法 public static string sumResult(double a, double b) { double sum = a + b; string str1 = Convert.ToString(sum); string str2 = "结果等于" + str1; return str2; } static void Main(string[] args) { //用普通方式创建一个委托对象 del sr = sumResult; //用string类型接收结果 string str = sr(2.5, 3.5); Console.WriteLine(str); Console.ReadKey(); }
把多个方法存到一个数组，利用循环来调用不同方法
//定义个委托，传入一个double参数，返回一个double。 delegate int delInt(int a); class Program { static void Main(string[] args) { //定义并初始化一个数组。数组的类型为委托类型 --没想到还以用委托当类型 delInt[] delArray = { sumMethod.addTwo, sumMethod.XTwo}; for (int i = 0; i < delArray.Length; i++) { Console.WriteLine("循环{0}",i); display(delArray[i], 5); display(delArray[i], 10); } Console.ReadKey(); } //显示的方法 static void display(delInt del,int a) { int result = del(a); Console.WriteLine("传入{0}，计算结果为{1}", a, result); } } //计算类 class sumMethod { //加2 public static int addTwo(int a) { return a + 2; } //乘2 public static int XTwo(int a) { return a * 2; } }
结果
到此为止以上的例子不能说明委托的意义，这些例子都能在不适用委托的情况下编写。
代表委托用法的例子
...
...
...
二、委托的多播
包含多个方法的委托叫做多播。
委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。
调用多播可以按顺序连续调用多个方法，委托的返回类型必须是void，否则只能得到委托调用最后一个方法的结果。
delegate void del(int sum);//声明一个委托
class MyClass
{
public void shuchuB(int x)
{
Console.WriteLine(10 * x);
Console.ReadLine();
}
}
class Program
{
static void shuchuA(int x)
{
Console.WriteLine(20 * x);
Console.ReadLine();
}
static void Main(string[] args)
{
MyClass mc = new MyClass();
del a = shuchuA; //创建一个委托实例，持有一个静态方法
del b = mc.shuchuB; //持有一个实例方法
del c = a + b; //持有以上两个方法
c(5);
}
}
如果
del c = b+a+b;
则
还有自加自的方式，如果一个del里有两个相同的方法，他会优先删除后进的。（后进先出）
del b += a;
del b -= a;
多播委托可能遇到的问题
如果委托调用的其中一个方法抛出异常，整个迭代就会停止
static void Main(string[] args) { //当一个委托没有参数也没有返回值时，就可以直接使用Action委托，无需声明 Action action = one; action += two; try { action(); } catch (Exception) { Console.WriteLine("exception"); } Console.ReadKey(); } static void one() { Console.WriteLine("one"); throw new Exception("Error"); } static void two() { Console.WriteLine("two"); }
为避免此问题，需要迭代方法列表
static void Main(string[] args) { //当一个委托没有参数也没有返回值时，就可以直接使用Action委托，无需声明 Action action = one; action += two; //委托的GetInvocationList方法会按照加入顺序返回一个委托数组 Delegate[] dels = action.GetInvocationList(); foreach (Action act in dels) { try { act(); } catch (Exception) { Console.WriteLine("exception"); } } Console.ReadKey(); }
三、泛型委托
1
2.
Action 简化了delegate的写法
Action返回类型必须是void，可以1-16任意参数类型<参数类型1，参数类型2，..>
也可以传不同参数类型
用var快速定义
3.有返回类型用Func
最后一个参数类型为返回类型
三、匿名函数
匿名方法有两种：匿名方法、Lambda表达式
在 2.0 之前的 C# 版本中，声明委托的唯一方法是使用命名方法。
C# 2.0 引入了匿名方法，而在 C# 3.0 及更高版本中,Lambda 表达式取代了匿名方法，作为编写内联代码的首选方式.
1.匿名方法
匿名方法比普通的委托写起来简练易读，在只一次调用方法时使用起来比较方便
语法：在创建委托实例的同时紧接着用花括号写入方法
public delegate string del(参数1，参数2，...); A a =new A(参数1，参数2，...) { ..... ..... return string类型; };
注意几点：
（1）A 是一个委托
（2）创建委托实例时参数的个数和类型都必须与声明委托时一致
（3）花括号里的返回类型必须要与声明的返回类型一致
（4）末尾别忘加 ;
用匿名方式创建一个委托对象
class Program { //也可以外部声明 public delegate string del(double a, double b); static void Main(string[] args) { Program p =new Program(); //用匿名方式创建一个委托对象 del sr = delegate(double a, double b) { double sum = a + b; string str1 = Convert.ToString(sum); string str2 = "结果等于" + str1; return str2; }; //用string类型接收结果 string str = sr(2.5, 3.5); Console.WriteLine(str); Console.ReadKey(); } }
2、用lambda方法实现
通过使用 lambda 表达式，可以写入可作为参数传递或作为函数调用值返回的本地函数。 Lambda 表达式对于编写 LINQ 查询表达式特别有用。
调用时声明的方法，用一次就没。不用再单独声明个方法
格式：
若要创建 lambda 表达式，需要在 Lambda 运算符 =>左侧指定输入参数（如果有），然后在另一侧输入表达式或语句块。
例如，lambda 表达式 x => x * x 指定名为 x 的参数并返回 x 的平方值
单行lambda 表达式
class Program { public delegate double del(double a, double b); static void Main(string[] args) { Program p = new Program(); //用lambda表达式的方法 del sr = (a, b) => a + b; //传入多个参数要加括号，如果是一个参数可以写成 //del sr = a => a * a; //开头注意声明的类型和下面这个接收的变量都是double double d = sr(2.5, 3.5); Console.WriteLine(d); Console.ReadKey(); } }
多行lambda 表达式
单行表达式省略了return、花括号和分号。用多行表达式时都要补充上。
Program p = new Program(); del sr = (a, b) => { return a + b; };
泛型Lambda，可以重用
语法糖可省略 lambda参数类型
语法糖 不需要再创建实例，省略了 new Func<int,int,int>
这个是最常用的方式
进阶
泛型委托类型推断，省略了 <int>
3.闭包
。。。。。
委托隐式异步调用
使用接口取代委托减少复杂性和安全性（java没有委托，就是用接口的方式）
四、事件
事件是一种类似于订阅/发布的机制。
把订阅当成一个方法，每次一订阅就会存一个方法进入委托中。等到发布的时候，一次性的发消息给哪些订阅。
例如：
日本丰田公司2017年生产了三款新车，（汉兰达2018，凯美瑞2018，雷凌2018）。
家住天津王兰庄附近的‘大刘’和‘小明’从网上看到消息后给王兰庄广汽丰田4S点打电话了解这三款车
4S点销售员告诉他们新车还没到货，让他们留下联系方式，等车到店了给你们发短信通知他们来店里看实车。
创建一个控制台程序
再新建一个事件发布类：ReleaseEventArgs
再新建一个事件监听类：Consumer
class ReleaseEventArgs : EventArgs { public ReleaseEventArgs(string car) { this.Car = car; } public string Car { get; set; } public class Shop { // public event EventHandler<ReleaseEventArgs> NewCarClass; public void NewCar(string car) { Console.WriteLine("{0}",car); raise(car); } protected virtual void raise(string car) { EventHandler<ReleaseEventArgs> newCarClass = NewCarClass; if (newCarClass != null) { newCarClass(this, new ReleaseEventArgs(car)); } } } }
class Consumer { private string name; public Consumer(string name) { this.name = name; } public void CarArriving(object sender, ReleaseEventArgs e) { Console.WriteLine("尊敬的{0},王兰庄4S点提示您:{1}到货了",name,e.Car); } }
class Program { static void Main(string[] args) { var shop = new ReleaseEventArgs.Shop(); var daliu = new Consumer("大刘"); var xiaoming = new Consumer("小明"); shop.NewCarClass += daliu.CarArriving; shop.NewCarClass += xiaoming.CarArriving; shop.NewCar("汉兰达2018"); shop.NewCarClass -= daliu.CarArriving; shop.NewCar("凯美瑞2018"); var zhoujie = new Consumer("周杰"); shop.NewCarClass += zhoujie.CarArriving; shop.NewCar("雷凌2018"); Console.ReadKey(); } }
https://www.cnblogs.com/gq0324/p/8177799.html
事件
using System; namespace ConsoleApp4 { class Program { static void Main(string[] args) { Business bus = new Business(); bus.Price = 11; bus.Changed += Test_Changed; bus.Price = 22; bus.Price = 33; Console.WriteLine("Hello World!"); void Test_Changed(object sender, ChangeEventArgs e) { if ((e.newPrice - e.oldPrice) > 10) { Console.WriteLine("大于10"); } } } } //标准事件模式 //一个继承事件类的子类 public class ChangeEventArgs : EventArgs { public int oldPrice; public int newPrice; //ctor + tab public ChangeEventArgs(int oldPrice, int newPrice) { this.oldPrice = oldPrice; this.newPrice = newPrice; } } public class Business { int price; public event EventHandler<ChangeEventArgs> Changed; protected virtual void OnChange(ChangeEventArgs e) { Changed?.Invoke(this, e); } public int Price { get { return price; } set { if (price == value) return; int oldPrice = price; price = value; OnChange(new ChangeEventArgs(oldPrice, price)); } } } }
------------------------------------------------
为什么要用委托？
//定义 public delegate void del(int value);
实际上相当于：定义了一个类
public class del:System.MulticastDelegate { //构造函数 public del(Object @object, IntPtr method); // public virtual void Invoke(Int32 value); //回调方法的异步回调 public virtual IAsyncResult BeginInvoke(Int32 value, AsyncCallback callback, Object @object); //回调方法的异步回调 public virtual void EndInvoke(IAsyncResult result); }
异步调用完成时执行回调方法
异步启动委托， 参数与要执行的方法的参数相同，另加两个可选参数
第一个参数是一个 AsyncCallback 委托，此委托引用在异步调用完成时要调用的方法。
第二个参数是一个用户定义的对象，该对象将信息传递到回调方法。
BeginInvoke 将立即返回，而不会等待异步调用完成。
BeginInvoke 返回可用于监视异步调用的进度的 IAsyncResult。
委托对象.BeginInvoke();
EndInvoke 方法用于检索异步调用的结果，它可以在调用 BeginInvoke之后的任意时间调用
如果异步调用尚未完成，那么 EndInvoke 将阻止调用线程，直到完成异步调用
---------------------------------------