public void Show()
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method.Invoke();
IAsyncResult asyncResult = method.BeginInvoke(null, null);
}
public void Show()
{
int k = 1;
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
{
//anonymous methods
NoReturnNoPara method = new NoReturnNoPara(delegate()
{
Console.WriteLine("this is do nothing in anonymous methods");
});
}
{
//Lambda expression
NoReturnNoPara method = new NoReturnNoPara(() => //"=>" is called goes to.
{
Console.WriteLine("this is do nothing in anonymous methods");
});
}
{
// Lambda expression is not a delegation, or an instance of a delegation. It's a class in another class, a internal method.
NoReturnWithPara method = new NoReturnWithPara((int x, int y) => { });
NoReturnWithPara method1 = new NoReturnWithPara((x, y) => { }); // int could be ignored
NoReturnWithPara method2 = (int x, int y) => { }; //left is decleration, right is a lambda expression
}
}
public void Show()
{
NoReturnNoPara noReturnNoPara = new NoReturnNoPara(DoNothing); //2 委托的实例化
noReturnNoPara.Invoke(); //3 委托实例的调用
{
WithReturnWithPara withReturnWithPara = new WithReturnWithPara(this.DoNothing2);
string result = withReturnWithPara.Invoke(2);
Console.WriteLine(result);
}
{
//多播委托：一个变量保存多个方法，可以增减；invoke的时候可以按顺序执行
//+= 为委托实例按顺序增加方法，形成方法链，Invoke时，按顺序依次执行
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(DoNothingStatic);
method.Invoke();
foreach (NoReturnNoPara item in method.GetInvocationList())
{
item.Invoke();
}
//-= 为委托实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常
method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(DoNothingStatic);
method.Invoke();
}
}
public void Show()
{
// Action 0到16个参数 没有返回值 泛型委托
Action action1 = () => { };
Action <int> action2 = i => Console.WriteLine(i);
Action <int, string, DateTime, ActionFunc> action16 = null;
// Action 0到16个参数 带返回值 泛型委托
Func <int> func1 = () => 1;
Func <int, string> func2 = (i) => i.ToString();
NoReturnNoPara noReturnNoPara = () => { };
this.DoNothing(action1);
//this.DoNothing(noReturnNoPara); //error
// 因为 NoReturnNoPara 和Action 不是同一个类型
// Student Teacher 大家属性都差不多但是实例之间不能替换，因为没有什么关系
// 很多委托长的一样， 参数列表和返回值都相同，但是不能通用
// 在不同框架组件定义各种各样的相同委托就是浪费. 比如 Thread 的 ThreadStart 委托和Action 委托是一样的
// 所以为了统一，就全部使用标准的Action/Func
}
public void Show()
{
int k = 1;
{
//.NET 1.0, 1.1
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
{
// 2.0 匿名方法 访问到调用地方的变量
NoReturnNoPara method = new NoReturnNoPara(delegate()
{
Console.WriteLine("DO Nothing");
Console.WriteLine(k);
});
}
{
// 3.0 lambda 左边是参数列表 goes to 右边是方法体 本质就是一个方法
NoReturnNoPara method = new NoReturnNoPara(() => // goes to
{
Console.WriteLine("DO Nothing");
Console.WriteLine(k);
});
}
{
NoReturnWithPara method = new NoReturnWithPara((int x, int y) =>
{
Console.WriteLine("DO Nothing");
Console.WriteLine(k);
});
}
{
// 可以省略参数类型 自动推算 要么都声明参数类型，要么都不声明
NoReturnWithPara method = new NoReturnWithPara((x, y) =>
{
Console.WriteLine("DO Nothing");
Console.WriteLine(k);
});
}
{
// 方法体只有一行可以省略大括号
NoReturnWithPara method = (x, y) =>
{
Console.WriteLine("DO Nothing");
};
// lambda 表达式是什么？
// 首先不是委托 委托是类型
// 也不是委托的实例
// 只是一个方法 (作用)
// 实际上编译后是一个类中类，里面的一个internal 方法， 然后被绑定到静态委托类型字段
}
}
public void Show()
{
int k = 1;
{
//1.0 1.1
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
{
//2.0 匿名方法
NoReturnNoPara method = new NoReturnNoPara(delegate()
{
Console.WriteLine(k);//能直接用到这里的变量
Console.WriteLine("This is DoNothing1");
});
}
{
//3.0 lambda:左边是参数列表 goes to 右边是方法体 本质就是一个方法
NoReturnNoPara method = new NoReturnNoPara(() =>//goes to
{
Console.WriteLine("This is DoNothing2");
});
}
{
NoReturnWithPara method = new NoReturnWithPara((int x, int y) => { Console.WriteLine("This is DoNothing3"); });
}
{//可以省略掉参数类型 自动推算的
NoReturnWithPara method = new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
}
{//方法体只有一行，可以去掉大括号和分号
NoReturnWithPara method = new NoReturnWithPara((x, y) => Console.WriteLine("This is DoNothing5"));
}
{
//可以省略 编译器推算的
NoReturnWithPara method = (x, y) => Console.WriteLine("This is DoNothing6");
}//lambda表达式是个什么呢？
//首先不是委托 委托是类型
//然后也不是委托的实例 因为这里是省略new 委托()
//只是一个方法(作用)
//实际上是一个类中类，里面的一个internal方法，然后被绑定到静态的委托类型字段
{
NoReturnWithPara method = new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
method += new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
method -= new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
method.Invoke(123, 234);//还是执行2遍 lambda的注册是去不掉的
}
{
Action <int> act = i => { };
}
}
public static void Show()
{
{
NoWithReturnPara method = new NoWithReturnPara(ShowStudent); //实例化委托
method.Invoke(186, "joney"); //调用委托
}
{
NoWithReturnPara method = delegate(int id, string name)//匿名方法
{
Console.WriteLine("id={0},name={1}正在上班。", id, name);
};
method.Invoke(213, "Saly");
}
{
NoWithReturnPara method = (id, name) =>
{
Console.WriteLine("id={0},name={1}正在开会。", id, name);
};
method.Invoke(88, "Jamer");
}
{
NoWithReturnPara method = (id, name) => Console.WriteLine("id={0},name={1}正在执行终极任务。", id, name);
method.Invoke(168, "Hammer");
}
{
NoReturnNoPara method = () => { };
NoWithReturnWithOnePara method1 = i => Console.WriteLine(i);
method1.Invoke(12);
}
{
WithReturnWithPara method = (m, n) => { return(DateTime.Now.Second); };
Console.WriteLine("当前时间second={0}", method.Invoke(1, "jj"));
}
{
WithReturnWithPara method = (m, n) => DateTime.Now.Second;
Console.WriteLine("当前时间second={0}", method.Invoke(1, "kk"));
}
{
Action method = () => { };
Action <int> act1 = i => { };
}
}
public void Show()
{
Student student = new Student()
{
Id = 1,
Name = "Jonty",
Age = 18,
ClassId = 1
};
student.Study();
{
// 把方法包装成变量 invoke时执行方法
NoReturnNoPara methodNoPara = new NoReturnNoPara(this.DoNothing);
// Invoke方法 委托里的方法 委托实例的调用
methodNoPara.Invoke();
// 等同于
methodNoPara();
// 执行
this.DoNothing();
}
{
// 多种实例化方式
NoReturnNoPara noPara = new NoReturnNoPara(this.DoNothing);
NoReturnNoPara noPara1 = new NoReturnNoPara(DoNothingStatic);
NoReturnNoPara noPara2 = new NoReturnNoPara(Student.StudyAdvanced);
NoReturnNoPara noPara3 = new NoReturnNoPara(new Student().Study);
}
{
// 多播委托：一个变量保存多个方法，可以增减，Invoke时按顺序执行
// 不能异步
// +=为委托实例按顺序增加方法 形成方法链 Invoke时按照顺序执行
NoReturnNoPara noPara = new NoReturnNoPara(this.DoNothing);
noPara += new NoReturnNoPara(this.DoNothing);
noPara += new NoReturnNoPara(DoNothingStatic);
noPara.Invoke();
}
}
public void Show()
{
Student student = new Student()
{
Id = 123,
Name = "JASON",
Age = 32,
ClassId = 1
};
student.Study();
{
//NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
//method.Invoke(); //Execute DoNothing method.
//method(); // Same as method.Invoke()
}
//Multicast delegate: a variable holds multiple methods, which can add or subtract.
//The invoke can be executed sequentially
//+= adds methods to the delegate instance in order to form the method chain, and when Invoke, it executes in order
//Milticast delegate could not be async.
Student studentNew = new Student();
Console.WriteLine("+=");
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);//No () for argument method
method += new NoReturnNoPara(DoNothingStatic);
method += new NoReturnNoPara(studentNew.Study);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(this.DoNothing);
method.Invoke();
Console.WriteLine("-=");
//-= removes a method for the delegate instance, matches it from the end of the method chain
//, and when the first one is fully matched, removes and removes only one, no and no exceptions
method -= new NoReturnNoPara(DoNothing);
method -= new NoReturnNoPara(studentNew.Study);
//Go throught a methods list
foreach (NoReturnNoPara item in method.GetInvocationList())
{
item.Invoke();
}
method.Invoke();
}
public void Show()
{
//2.实例化委托
NoReturnNoPara delegateNoParaObj = new NoReturnNoPara(this.DoNothing);
delegateNoParaObj.Invoke();
NoReturnWithPara delegateWithParaObj = new NoReturnWithPara(this.WithParaNothing);
delegateWithParaObj.Invoke(2, "sss");
for (int i = 0; i < 10; i++)
{
delegateWithParaObj.BeginInvoke(i, i.ToString(), delegate(IAsyncResult t)
{
Console.WriteLine("当前线程ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
}, "哈哈哈");
}
}
public void Show()
{
{
NoReturnWithPara func = (x, y) => { };
func += (x, y) => Console.WriteLine("123");;
func.Invoke(3, 4);
}
//System.MulticastDelegate
Student student = new Student()
{
Id = 96,
Name = "Summer"
};
student.Study();
//Predicate<int>
//Func<string>
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);//2 委托的实例化
method.Invoke();//3 委托的调用
method();
//method.BeginInvoke(null, null);
this.DoNothing();
}
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing); //当前类的实例方法
NoReturnNoPara method1 = new NoReturnNoPara(MyDelegate.DoNothingStatic); //当前类的静态方法
NoReturnNoPara method2 = new NoReturnNoPara(student.Study); //其他类的实例方法
NoReturnNoPara method3 = new NoReturnNoPara(Student.StudyAdvanced); //其他类的静态方法
}
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(MyDelegate.DoNothingStatic);
method += new NoReturnNoPara(student.Study);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(new Student().Study);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(() => Console.WriteLine("这里是lambda表达式"));
//+=就是把多个方法按顺序排成列表，invoke时按顺序执行
//method.Invoke();
method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(MyDelegate.DoNothingStatic);
method -= new NoReturnNoPara(student.Study);
method -= new NoReturnNoPara(new Student().Study);
method -= new NoReturnNoPara(Student.StudyAdvanced);
method -= new NoReturnNoPara(Student.StudyAdvanced);
method -= new NoReturnNoPara(() => Console.WriteLine("这里是lambda表达式"));
//-=就是从这个实例上，从后往前挨个匹配，找到第一个完全吻合的移除掉，且只移除一个，找不到不异常
method.Invoke();
//method.BeginInvoke(null, null);
foreach (NoReturnNoPara item in method.GetInvocationList())
{
item.BeginInvoke(null, null);
}
}
}
public void Show()
{
//{
// WithReturnNoPara method1 = new WithReturnNoPara(ToInt);
// int iResult = method1.Invoke();
//}
//Student student = new Student()
//{
// Id = 1,
// Name = "周瑾",
// Age = 25
//};
//student.Study();
//委托的实例化：要求传递一个和委托参数返回值完全一致的方法。
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
//NoReturnNoPara method1 = new NoReturnNoPara(this.ParaReturn);
//method.Invoke();// 就是去调用方法
//method();// 可以省略Invoke
//this.DoNothing(); //和委托Invoke 是做的同一件事
//method.BeginInvoke(null, null);//这里是开启一个新的线程去执行方法
//method.EndInvoke(null);
//1、声明一个委托
//2、委托的实例化
//3、调用
// 系统内置的委托
{
//Action Func 从.Netframework 3.0出现，是系统提供的委托
//Action:没有返回值， 参数可有可无
//Func: 必须有返回值，参数可有可无
//我们其实可以自定义委托呀，那系统为什么还要定义这两个委托呢？
//new Thread(new ThreadStart(DoNothing));
//new Thread(new NoReturnNoPara(DoNothing)); // 是不是重复声明？
////我们的思维来讲：应该是不会报错
//这里为什么不行呢？ 是因为委托是一个类，两个实例肯定不一样啊！
//所以系统提供Action Func 两个委托,系统肯定是希望在以后的封装中能够直接使用这两个委托！
//Action: 没有返回值，最多支持16个泛型参数
//Action act = new Action(this.DoNothing);
//Action<int> actInt = new Action<int>(NoReturn);
//Action<int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object> action = null;
////Func: 有返回值，最多支持16个泛型参数，泛型参数列表的最后一个为委托返回值类型
//Func<int> func1 = new Func<int>(ToInt);
//Func<int, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object, int, string, DateTime, object> Func2 = null;
//int iResult = func1.Invoke();
}
{//多播委托 我们自定义的任何一个委托都是多播委托
//可以通过+=/-= 向委托中增加或者移除方法；
//+=增加方法以后，让委托组成了一个方法链
//-=只能移除同一个实例里的方法，如过没有可以移除的方法，就啥事儿也不发生
NoReturnNoPara method1 = new NoReturnNoPara(this.DoNothing);
var student = new Student();
method1 += this.DoNothing;
method1 += student.Study; //加括号就是调用
method1 -= this.DoNothing;
method1 -= student.Study; //仍然会执行 因为是两个不同的实例
method1.Invoke();
foreach (NoReturnNoPara item in method1.GetInvocationList())
{
item.Invoke();
}
// 如果func 委托在+= 形成一个方法链以后，在执行后，只能获取最后一个方法的返回值
}
//现在是21:55 大家开始提问，21：58开始答疑，期间老师不说话
}
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 void Show()
{
//lambda演变历史
{
//.NetFramework1.0 1.1
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
}
int i = 10;
{
NoReturnWithPara method = new NoReturnWithPara(this.Study);
method.Invoke(123, "董小姐");
}
{
//.NetFramework2.0 匿名方法，delegate关键字
//可以访问局部变量
NoReturnWithPara method = new NoReturnWithPara(delegate(int id, string name)
{
Console.WriteLine(i);
Console.WriteLine($"{id} {name} 学习.Net高级班");
});
method.Invoke(234, "Harley");
}
{
//.NetFramework3.0 把delegate关键字去掉，增加了一个箭头goes to
//lambda表达式 参数列表=>方法体
NoReturnWithPara method = new NoReturnWithPara(
(int id, string name) =>
{
Console.WriteLine($"{id} {name} 学习.Net高级班");
});
method.Invoke(123, "Coder");
}
{
NoReturnWithPara method = new NoReturnWithPara(
(id, name) =>//省略参数类型，编译器的语法糖，虽然没写，编译时还是有的，根据委托推算
{
Console.WriteLine($"{id} {name} 学习.Net高级班");
});
method.Invoke(123, "加菲猫");
}
{
NoReturnWithPara method = new NoReturnWithPara(
(id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班"));
//如果方法体只有一行，可以去掉大括号和分号
method.Invoke(123, "ZJ");
}
{
NoReturnWithPara method = (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班");
method.Invoke(123, "大涛"); //new NoReturnWithPara可以省掉，也是语法糖，编译器自动加上
}
//lambda表达是什么？ lambda只是实力化委托的一个参数，就是个方法
//lambda是匿名方法，但是编译的时候会分配一个名字
//还会产生一个私有sealed类，这里增加一个方法
{
//lambda在多播委托
NoReturnWithPara method = new NoReturnWithPara(this.Study);
method += this.Study;
method += (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班1");
method -= this.Study;
method -= (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班1");
//多播委托里面的lambda无法移除， 不是2个实例，其实是2个不同的方法
method.Invoke(345, "北纬23");
}
{
//匿名方法或者lamdba表达式是不是只能是无返回值的
Action action0 = () => { };
Action <string> action1 = s => Console.WriteLine(s); //参数只有一个 可以省略小括号
Func <int> func0 = () => DateTime.Now.Month; //如果方法体只有一行，去掉大括号分号return
int iResult = func0.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()
{
{
//多播委托有啥用呢？一个委托实例包含多个方法，可以通过+=/-=去增加/移除方法，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 = 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()
{
Console.WriteLine("lambda演变历史");
{
Console.WriteLine(".NetFramework1.0 1.1");
Console.WriteLine("执行无参无返回值委托");
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method.Invoke();
}
{
Console.WriteLine("执行有参无返回值委托");
NoReturnWithPara method = new NoReturnWithPara(this.Study);
method.Invoke(20200316, "2020年3月16日17:56:21");
}
{
Console.WriteLine(".NetFramework2.0 匿名方法，delegate关键字");
//可以访问局部变量
NoReturnWithPara method = new NoReturnWithPara(delegate(int id, string name)
{
Console.WriteLine($"***这是方法***：匿名方法：{id} {name}");
});
method.Invoke(20200316, "2020年3月16日17:02:23");
}
{
Console.WriteLine(".NetFramework3.0 把delegate关键字去掉，增加了一个箭头goes to 也就是：=>");
NoReturnWithPara method = new NoReturnWithPara(
(int id, string name) =>
{
Console.WriteLine($"***这是方法***：{id} {name}");
});
method.Invoke(20200316, "2020年3月16日17:06:31");
Console.WriteLine("Action方法");
Action <string, string> actionA = (string str1, string str2) =>
{
Console.WriteLine($"***这是方法***：参数1：{str1}，参数2：{str2}");
};
actionA.Invoke("ABC", "CBA");
}
{
Console.WriteLine("//省略参数类型，编译器的语法糖，虽然没写，编译时还是有的，根据委托推算");
NoReturnWithPara method = new NoReturnWithPara(
(id, name) =>
{
Console.WriteLine($"{id} {name}");
});
method.Invoke(20200316, "2020年3月16日17:13:11");
Console.WriteLine("Action方法");
Action <int, string> actionB = (int1, str1) =>
{
Console.WriteLine($"***这是方法***：参数1{str1}，参数2：{str1}");
};
actionB.Invoke(20200316, "2020年3月16日17:20:03");
}
{
Console.WriteLine("如果方法体只有一行，可以去掉大括号和分号");
NoReturnWithPara method = new NoReturnWithPara(
(id, name) => Console.WriteLine($"{id} {name}"));
method.Invoke(20200316, "2020年3月16日17:22:59");
}
{
Console.WriteLine("new NoReturnWithPara可以省掉，也是语法糖，编译器自动加上");
NoReturnWithPara method = (id, name) => Console.WriteLine($"{id} {name}");
method.Invoke(123, "大涛");
}
Console.WriteLine("lambda表达是什么？ lambda只是实力化委托的一个参数，就是个方法");
Console.WriteLine("lambda是匿名方法，但是编译的时候会分配一个名字,还会产生一个私有sealed类，这里增加一个方法");
{
Console.WriteLine("lambda在多播委托");
NoReturnWithPara method = new NoReturnWithPara(this.Study);
method += this.Study;
method += (id, name) => Console.WriteLine($"{id} {name}");
method -= this.Study;
method -= (id, name) => Console.WriteLine($"{id} {name}");
Console.WriteLine("多播委托里面的lambda无法移除， 不是2个实例，其实是2个不同的方法,因为在编译的时候，会生成两个方法名不同的方法");
method.Invoke(20200316, "2020年3月16日17:26:12");
}
{
Console.WriteLine("==========有返回值，有参数==========");
Func <int, int, int> funcA = (a, b) =>
{
return(a + b);
};
Console.WriteLine("如果方法体只有一行也可以省略大括号");
Func <int, int, int> funcB = (a, b) => a + b;
int c = funcA.Invoke(12, 13);
int d = funcB.Invoke(10, 30);
Console.WriteLine($"FuncA返回值：{c}");
Console.WriteLine($"FuncB返回值：{d}");
}
}
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);
}
}
}
