public void Show()
{
//System.MulticastDelegate
Student student = new Student()
{
Id = 123,
Name = "靠谱一大叔",
Age = 32,
ClassId = 1
};
student.Study();
{
//把方法包装成对象，invoke的时候自动执行方法
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing); //2 委托的实例化
method.Invoke(); //3 委托实例的调用
method();
this.DoNothing();
}
//begininvoke
{
WithReturnNoPara method = new WithReturnNoPara(this.GetSomething);
int iResult = method.Invoke();
iResult = method();
var result = method.BeginInvoke(null, null);//异步调用
method.EndInvoke(result);
}
{
//多种途径实例化
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
{
NoReturnNoPara method = new NoReturnNoPara(DoNothingStatic);
}
{
NoReturnNoPara method = new NoReturnNoPara(Student.StudyAdvanced);
}
{
NoReturnNoPara method = new NoReturnNoPara(new Student().Study);
}
}
{
//多播委托：一个变量保存多个方法，可以增减；invoke的时候可以按顺序执行
//+= 为委托实例按顺序增加方法，形成方法链，Invoke时，按顺序依次执行
Student studentNew = new Student();
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(DoNothingStatic);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(new Student().Study);//不是同一个实例，所以是不同的方法
method += new NoReturnNoPara(studentNew.Study);
method.Invoke();
//method.BeginInvoke(null, null);//多播委托是不能异步的
foreach (NoReturnNoPara item in method.GetInvocationList())
{
item.Invoke();
//item.BeginInvoke(null, null);
}
//-= 为委托实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常
method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(DoNothingStatic);
method -= new NoReturnNoPara(Student.StudyAdvanced);
method -= new NoReturnNoPara(new Student().Study);
method -= new NoReturnNoPara(studentNew.Study);
method.Invoke();
}
{
WithReturnNoPara method = new WithReturnNoPara(this.GetSomething);
method += new WithReturnNoPara(this.GetSomething2);
method += new WithReturnNoPara(this.GetSomething3);
int iResult = method.Invoke();//多播委托带返回值，结果以最后的为准
}
}
public static void Show()
{
NoReturnWithPara method = new NoReturnWithPara(Study);//委托实例化，要求传入的方法必须满足委托的约束
method.Invoke("jack", DateTime.Now);
NoReturnWithPara method1 = new NoReturnWithPara(
delegate(string name, DateTime now) {
Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
}); //使用匿名方法，把方法名去掉
method1.Invoke("jack", DateTime.Now);
NoReturnWithPara method2 = new NoReturnWithPara(
(string name, DateTime now) =>
{
Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
}); //Lmabda表达式 把delegate换成了=>
method2.Invoke("jack", DateTime.Now);
NoReturnWithPara method3 = new NoReturnWithPara(
(name, now) =>
{
Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
}); //去掉了参数类型，委托实例化要求传入的方法必须满足委托的约束
method3.Invoke("jack", DateTime.Now);
NoReturnWithPara method4 = (name, now) =>
{
Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
}; //去掉了new NoReturnWithPara();
method4.Invoke("jack", DateTime.Now);
NoReturnWithPara method5 = (name, now) => Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
//去掉了{},条件是方法体只有一行;
method5.Invoke("jack", DateTime.Now);
NoReturnWithPara method10 = (s, b) => Console.WriteLine("{0}{1}正在学习Lambda表达式", s, b);
method10.Invoke("jack", DateTime.Now);
Console.WriteLine("===============================================");
WithReturnWithoPara func = (x, y) => { return(x * y); };
WithReturnWithoPara func1 = (x, y) => x * y;//去掉了{},条件是方法体只有一行,带返回值的话，return就去掉;
func.Invoke(3, 4);
func1.Invoke(3, 4);
Console.WriteLine("===============================================");
NoReturnNoPara action = () => { };
NoReturnNoPara action1 = () => { Console.WriteLine("12345"); };
Console.WriteLine("===============================================");
WithReturnNoPara fun = () => "erfdfa";
Console.WriteLine("===============================================");
//系统自带的各种委托
#region 带返回值的委托
Action act1 = () => { };
//泛型委托
Action <string> act2 = name => { Console.WriteLine(); };//一个参数的话，可以去掉小括号
//最多可以有16个参数
Action <string, int, long, DateTime, char, double, decimal> act3 = (par1, par2, par3, par4, par5, par6, par7) => { };
#endregion
#region 带返回值的委托
Func <string> fun1 = () => "fdafds";
Func <DateTime> fun2 = () => DateTime.Now;
//最多可以有16个参数,带一个返回值
Func <string, int, long, DateTime, char, double, decimal, DateTime> fun3 = (par1, par2, par3, par4, par5, par6, par7) => DateTime.Now;
Func <string, int, long, DateTime, char, double, decimal, Action> fun4 = (par1, par2, par3, par4, par5, par6, par7) => act1;
#endregion
}
public void Show()
{
Student student = new Student()
{
Id = 96,
Name = "小目标一个亿"
};
student.Study();
#region 委托
{
//给委托赋值（参数和返回值要和委托保持一致）
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
Console.WriteLine("==========委托调用==========");
method.Invoke();
Console.WriteLine("==========普通调用==========");
this.DoNothing();
Console.WriteLine("==========可以省略.Invoke==========");
method();
Console.WriteLine("==========委托的BeginInvoke和EndInvoke方法==========");
WithReturnPara withReturnParaMethod = new WithReturnPara(newTask);
//BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。我们可以通过四种方法从EndInvoke方法来获得返回值。
IAsyncResult asyncResult = withReturnParaMethod.BeginInvoke(2000, null, null);
int result = withReturnParaMethod.EndInvoke(asyncResult);
Console.WriteLine(result);
//在运行上面的程序后，由于newTask方法通过Sleep延迟了2秒，因此，程序直到2秒后才输出最终结果（一个随机整数）。如果不调用EndInvoke方法，程序会立即退出，这是由于使用BeginInvoke创建的线程都是后台线程，这种线程一但所有的前台线程都退出后（其中主线程就是一个前台线程），不管后台线程是否执行完毕，都会结束线程，并退出程序。
}
#endregion
#region 返回值、无参的委托
{
Console.WriteLine("==========有返回值、无参的委托==========");
WithReturnNoPara method = new WithReturnNoPara(this.Get);
int i = method.Invoke();
int k = this.Get();
Console.WriteLine("返回值i:" + i);
Console.WriteLine("返回值k:" + k);
//以上委托调用和普通调用运行结果一样
}
#endregion
#region 自定义委托
{
Console.WriteLine("==========自定义委托==========");
//Action Func .NetFramework3.0出现的
//Action 系统提供 0到16个泛型参数 不带返回值 委托
Action action0 = this.DoNothing;//是个语法糖，就是编译器帮我们添加上new Action
Console.WriteLine("执行DoNothing方法");
action0.Invoke();
Action <int> action1 = this.ShowInt;
Console.WriteLine("执行带参数ShowInt方法");
action1.Invoke(20200310);
//Func 系统提供 0到16个泛型参数,如果不够用可以自定义
Action <int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long, int> action16 = null;
//Func 系统提供 0到16个泛型参数 带泛型返回值 委托
Func <int> func0 = this.Get;
int iResult = func0.Invoke();
Console.WriteLine("无参有返回值委托，返回值：" + iResult);
Func <int, string> func1 = this.ToString;
string str = func1.Invoke(20200310);
Console.WriteLine("返回值：" + str);
}
#endregion
#region 使用框架自带的委托
{
Console.WriteLine("==========使用框架自带的委托==========");
Action action0 = this.DoNothing;
NoReturnNoPara method = this.DoNothing;
//为啥框架要提供这种委托呢？ 框架提供这种封装，自然是希望大家都统一使用Action/Func
this.DoAction(action0);
//this.DoAction(method); Action和NoReturnNoPara是不同的类，虽然实例化都可以传递相同的方法，但是没有父子关系,所以会报错，就像Student和Teacher两个类，实例化都是传递id/name，但是二者不能替换的
}
#endregion
#region 多播委托
{
Console.WriteLine("==========多播委托==========");
//多播委托：一个委托实例包含多个方法，可以通过+=/-=去增加/移除方法，Invoke时可以按顺序执行全部动作
//多播委托:任何一个委托都是多播委托类型的子类，可以通过+=去添加方法
//+= 给委托的实例添加方法，会形成方法链，Invoke时，会按顺序执行系列方法
Action method = this.DoNothing;
method += this.DoNothing;
method += DoNothingStatic;
method += new Student().Study;
method += Student.StudyAdvanced;
//method.BeginInvoke(null, null);//启动线程来完成计算 会报错，多播委托实例不能异步
//Console.WriteLine("==========循环执行==========");
//foreach (Action item in method.GetInvocationList())
//{
// item.Invoke();
// //循环可以使用BeginInvoke
// item.BeginInvoke(null, null);
//}
Console.WriteLine("==========一次性调用==========");
method.Invoke();
//-= 给委托的实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除，且只移除一个，如果没有匹配，就啥事儿不发生
method -= this.DoNothing;
method -= DoNothingStatic;
method -= new Student().Study;
Console.WriteLine("==========从委托中减去几个方法==========");
method.Invoke();
//如果中间出现未捕获的异常，直接方法链就结束了
}
#endregion
#region 带返回值的多播委托
{
Console.WriteLine("==========带返回值的多播委托==========");
Func <int> func = this.Get;
func += this.Get2;
func += this.Get3;
func += this.Get4;
int iResult = func.Invoke();
Console.WriteLine("返回结果：" + iResult);
//带返回值的多播委托，返回值以最后一个委托为准
}
#endregion
}
public void Show()
{
{
//多播委托有啥用呢？一个委托实例包含多个方法，可以通过+=/-=去增加/移除方法，Invoke时可以按顺序执行全部动作
//多播委托:任何一个委托都是多播委托类型的子类，可以通过+=去添加方法
//+= 给委托的实例添加方法，会形成方法链，Invoke时，会按顺序执行系列方法
Action method = this.DoNothing;
method += this.DoNothing;
method += DoNothingStatic;
method += new Student().Study;
method += Student.StudyAdvanced;
//method.BeginInvoke(null, null);//启动线程来完成计算 会报错，多播委托实例不能异步
foreach (Action item in method.GetInvocationList())
{
item.Invoke();
item.BeginInvoke(null, null);
}
//method.Invoke();
//-= 给委托的实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除，且只移除一个，如果没有匹配，就啥事儿不发生
method -= this.DoNothing;
method -= DoNothingStatic;
method -= new Student().Study;//去不掉 原因是不同的实例的相同方法，并不吻合
method -= Student.StudyAdvanced;
method.Invoke();
//中间出现未捕获的异常，直接方法链结束了
}
//System.MulticastDelegate
Student student = new Student()
{
Id = 96,
Name = "一生为你"
};
student.Study();
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
//2 委托的实例化 要求传递一个参数类型 返回值都跟委托一致的方法,
method.Invoke(); //3委托实例的调用 参数和委托约束的一致
this.DoNothing(); //效果跟直接调用方法一致
method(); //可以省略.Invoke
method.BeginInvoke(null, null); //启动一个线程完成计算
//method.EndInvoke(null);
//委托就是一个类 为什么要用委托？ 这个类的实例可以放入一个方法，实例Inovke时，就调用方法
//说起来还是在执行方法,为啥要做成三个步骤？ 唯一的差别，就是把方法放入了一个对象/变量
}
{
//WithReturnWithPara method = new WithReturnWithPara(this.ParaReturn);//严格一致
//method += this.ParaReturn;
//method.Invoke(out int a, ref b);
}
{
WithReturnNoPara method = new WithReturnNoPara(this.Get);
int i = method.Invoke();
int k = this.Get();
}
{
//Action Func .NetFramework3.0出现的
//Action 系统提供 0到16个泛型参数 不带返回值 委托
//Action action = new Action(this.DoNothing);
Action action0 = this.DoNothing;//是个语法糖，就是编译器帮我们添加上new Action
Action <int> action1 = this.ShowInt;
Action <int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long> action16 = null;
//Func 系统提供 0到16个泛型参数 带泛型返回值 委托
Func <int> func0 = this.Get;
int iResult = func0.Invoke();
Func <int, string> func1 = this.ToString;
Func <int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long, int, string, DateTime, long, string> func16 = null;
}
{
Action action0 = this.DoNothing;
NoReturnNoPara method = this.DoNothing;
//为啥框架要提供这种委托呢？ 框架提供这种封装，自然是希望大家都统一使用Action/Func
this.DoAction(action0);
//this.DoAction(method);
//委托的本质是类，Action和NoReturnNoPara是不同的类，虽然实例化都可以传递相同的方法，但是没有父子关系，所以是不能替换的
//就像Student和Teacher两个类，实例化都是传递id/name，但是二者不能替换的
//更进一步，框架中出现过N多个委托,委托的签名是一致的，实例化完的对象缺不能通用
//new Thread(new ParameterizedThreadStart()).Start();
//ThreadPool.QueueUserWorkItem(new WaitCallback())
//Task.Run(new Action<object>());
//本身实例化的时候，参数都是一样的，都是id/name，但却是不同的类型，导致没法通用
//Action和Func 框架预定义的，新的API一律基于这些委托来封装
//因为.Net向前兼容，以前的版本去不掉了，保留着，这是历史包袱
//此后，大家就不要再定义新的委托了，包括大家的作业
}
{
//多种途径实例化 实例化的限制就是方法的参数列表&返回值类型必须和委托约束的一致
{
Action method = this.DoNothing;
}
{
Action method = DoNothingStatic;
}
{
Action method = new Student().Study;
}
{
Action method = Student.StudyAdvanced;
}
}
{
Func <int> func = this.Get;
func += this.Get2;
func += this.Get3;
int iResult = func.Invoke();
//结果是3 以最后一个为准，前面的丢失了。。所以一般多播委托用的是不带返回值的
}
}
public void Show()
{
Student student = new Student()
{
Id = 123,
Name = "Ivan",
Age = 32,
ClassId = 1
};
student.Study();
{
//把方法包装成变量， invoke 的时候自动执行方法
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing); // 2. 委托的实例化， 要求传入参数，参数为一个函数，函数必须与委托有同样的函数签名及返回值
{
//3. 委托实例的调用， 相当于把传入的函数执行一遍
method.Invoke(); // Invoke 是delegate IL 中的方法， 相当于调用类的实例方法
method(); // 也可以直接省略Invoke进行调用
}
}
{
// beginInvoke
WithReturnNoPara method = new WithReturnNoPara(this.GetSomething);
int iResult = method.Invoke();
iResult = method();
var result = method.BeginInvoke(null, null);// 异步调用
method.EndInvoke(result);
}
{
// 多途径实例化
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
{
NoReturnNoPara method = new NoReturnNoPara(DoNothingStatic);
}
{
NoReturnNoPara method = new NoReturnNoPara(Student.StudyAdvanced);
}
{
NoReturnNoPara method = new NoReturnNoPara(new Student().Study);
}
}
{
// 多播委托: 一个变量保存多个方法，可以增减;Invoke时候可以按顺序执行
// += 为委托实例按顺序增加方法，形成方法链, Invoke时,是按顺序依次执行
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(DoNothingStatic);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(new Student().Study);// 不是同一个实例， 所以是不同的方法
method += new NoReturnNoPara(student.Study);
method.Invoke();
method.BeginInvoke(null, null); // 多播委托不能异步
foreach (NoReturnNoPara item in method.GetInvocationList())
{
item.Invoke();
}
// -= 为委托实例移除方法， 从方法链的尾部开始匹配,
// 遇到第一个完全吻合的,移除且移除一个，没有也不异常
method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(DoNothingStatic);
method -= new NoReturnNoPara(Student.StudyAdvanced);
method -= new NoReturnNoPara(new Student().Study);
method -= new NoReturnNoPara(student.Study);
method.Invoke();
{
WithReturnNoPara method1 = new WithReturnNoPara(this.GetSomething);
method1 += new WithReturnNoPara(this.GetSomething2);
method1 += new WithReturnNoPara(this.GetSomething3);
int result = method1.Invoke(); //多播委托带返回值,结果以最后的为准
Console.WriteLine(result);
}
}
}
