整理几种委托的用法Action，Func，匿名，多播，Lambde表达式，event

public static void Main (string[] args)
{
Meet ("China");
Meet ("Japan");
}

public static void SayHelloInChina()
{
Console.WriteLine ("吃了吗？");
}
public static void SayHelloInAmerica()
{
Console.WriteLine ("what is the weather?");
}
public static void SayHelloInJapan()
{
Console.WriteLine ("孔丽西瓦！");
}
public static void SayHelloInHanGuo()
{
Console.WriteLine ("……思密达");
}
public static void SayHelloInAnyCountry(){}

public static void Meet(string s)
{
if (s == "China")
{
SayHelloInChina ();
}
if (s == "America" )
{
SayHelloInAmerica ();
}
if (s == "Japan")
{
SayHelloInJapan ();
}
if (s == "HanGuo") {
SayHelloInHanGuo ();
}
}

public static void Main (string[] args)
{
//通过委托去执行方法
//委托的本质就是将方法作为参数进行引用
Meet(SayHelloInChina);	//直接把需要执行的方法名字传进来，委托会自动匹配
Meet (SayHelloInHanGuo);

}

public static void SayHelloInChina()
{
Console.WriteLine ("吃了吗？");
}
public static void SayHelloInAmerica()
{
Console.WriteLine ("what is the weather?");
}
public static void SayHelloInJapan()
{
Console.WriteLine ("孔丽西瓦！");
}
public static void SayHelloInHanGuo()
{
Console.WriteLine ("……思密达");
}
public static void SayHelloInAnyCountry(){}

public static void Meet (SayHello say)//把委托传进来
{
say ();	//去执行这个委托
}

public delegate void kid();	//声明一个小弟的委托
class MainClass
{
public static void Main (string[] args)
{
//实例化大哥类
Boss boss = new Boss ();
//给委托添加委托的方法
kid kid = new kid (boss.Robe);
kid += boss.Kill;	//委托链，
kid += boss.Fire;

//消除委托的方法
kid -= boss.Kill;
kid -= boss.Fire;
kid -= boss.Robe;

//一般委托会这么用，不然委托里面委托的事件为空的话，会出现空引用的警告
if (kid != null)
{
kid ();	//执行委托
}

}
}

//定义大哥类
public class Boss
{
public void Fire(){
Console.WriteLine ("放火……");
}
public void Kill()
{
Console.WriteLine ("砍他……");
}
public void Robe()
{
Console.WriteLine ("抢劫了，把钱交粗来……");
}
}

/// <summary>
/// 计算器的委托
/// </summary>
public delegate double DlgtCounter (float a,float b);

class MainClass
{
public static void Main (string[] args)
{

Count ct = new Count ();
//			DlgtCounter dcer = new DlgtCounter(ct.Add);
Accountant ac = new Accountant ();
//			Console.WriteLine (ac.Operation (dcer, 4f, 5f));
Console.WriteLine (ac.Operation (ct.Add, 3f, 5f));
Console.WriteLine (ac.Operation (ct.Sub, 3f, 5f));
Console.WriteLine (ac.Operation (ct.Mul, 3f, 5f));
Console.WriteLine (ac.Operation (ct.Divide, 3f, 5f));

}
}

/// <summary>
/// 会计类，里面有操作的方法
/// </summary>
public class Accountant
{
//利用计算器（委托）去计算
public double Operation(DlgtCounter counter,float a, float b)
{
return counter (a, b);

}
}

/// <summary>
/// 计算类，里面有加减乘除的方fgfcr0法
/// </summary>
public class Count
{
public double Add(float a,float b)
{
return a + b;
}
public double Sub(float a,float b)
{
return a - b;
}
public double Mul(float a,float b)
{
return a * b;
}
public double Divide(float a,float b)
{
return a / b;
}
}

public static void Main (string[] args)
{

//Action可以通过泛型去指定Action指向的方法的多个参数类型
//参数的类型必须要与Action声明时后面的参数一致（顺序也不能错）
Action a = PrintHelloWorld;
a ();

Action<string> b = PrintString;
b ("shenmoyisi");

Action<int,int> c = PrintDoubleInt;
c (2, 4);

Action<int,int,string, bool> d = Print;
d (1, 2, "干什么", false);
}

public static void PrintHelloWorld()
{
Console.WriteLine ("Hello World.");
}
public static void PrintString(string str)
{
Console.WriteLine (str);
}
public static void PrintDoubleInt(int a, int b)
{
Console.WriteLine (a+ " "+ b);
}
public static void Print(int a, int b, string c, bool d)
{
Console.WriteLine (a+ " " + b+ " " +c+ " " + d);
}

//Func 代表具有返回值的委托,
//Func中可以跟很多类型，<>中前面的都是参数类型，最后一个是返回值类型
//参数类型必须跟指定方法的参数一致，有0~16个参数
class MainClass
{
public static void Main (string[] args)
{
Func<int> a = Test01;
Console.WriteLine (a ());
Func<string , int> b = Test02;
Console.WriteLine (b ("干什么"));
Func<int,int,int> c = Test03;
int res = c (12,45);
Console.WriteLine (res);
}

public static int Test01(){
return 1;
}
public static int Test02(string str)
{
return 2;
}
public static int Test03(int a,int b)
{
return a + b;
}
}

class MainClass
{
public static void Main (string[] args)
{
Action a = Test01;
a += Test02;

//			a -= Test01;	//消除方法
//			a -= Test02;
if (a != null) {
a ();
}

//当一个委托，没有指向任何一个方法的时候调用会出现空引用异常
//如果方法有返回值，那么多播委托（委托链）只能得到最后一个方法的返回值
//一般我们会把多播委托，的返回值定义成void
//多播委托是一个逐个调用的委托集合
//如果通过委托调用的任何一个方法出现的异常，整个迭代就会停止。

//定义一个委托集合。 得到多播委托里面所有的单个委托
Delegate[] dlgts = a.GetInvocationList();

//遍历所有委托
foreach (Delegate i in dlgts) {
//执行委托
i.DynamicInvoke ();
}
}
public static void Test01()
{
Console.WriteLine ("Test01");
//			throw new Exception ();		//抛出一个异常，执行不了，也就是说，委托连，中有一个异常就会执行不了

}
public static void Test02()
{
Console.WriteLine ("Test02");
}
}

class MainClass
{
public static int Plus(int a,int b)
{
return a + b;
}

public static void Main (string[] args)
{
//不使用匿名方法
Func<int,int,int> f1 = Plus;
int res1 = f1(12, 34);
Console.WriteLine ("通过f1得到： "+res1);

//使用匿名方法,本质上是一个方法，只是没有名字，也不需要写返回值
//任何使用委托方法的地方都能使用匿名方法进行赋值
Func<int,int,int> f2 = delegate (int a, int b) {
return a + b;
};
int res2 = f2 (23, 45);
Console.WriteLine ("通过f2得到： " +res2);

Func<int,int,int> f3 = delegate(int a, int b) {
return a - b;
};
int qwe = f3(4,2);

}
}

public static void Main (string[] args)
{

//匿名方法
Func<int,int,int> f2 = delegate (int a, int b) {
return a + b;
};

//Lambda表达式,用来代替匿名方法，所以表达式中也定义一个方法
//Lambda表达式中的参数是可以不声明类型的
Func<int,int,int> f3 = (arg1, arg2) => {
return arg1 + arg2;
};

//			Func<int,int,int>f3 = (arg1, arg2) => arg1 + arg2;

Console.WriteLine (f3(12,12));

//Lambda表达式中只有一个参数的时候可以不加小括号
//当函数的语句只有一句的时候，可以不加大括号和return；
//如果说多条语句的会必须加
Func<int,int>f4 = arg => 456;
Console.WriteLine ("f4: " + f4(123));

//任何使用委托方法的地方都能使用匿名方法进行赋值
//只要有匿名方法的地方就能使用Lambda表达式
//Lambda表达式,可以用来代替匿名方法

Func<int,int> f5 = arg => ++arg;
Console.WriteLine ("f5 : " + f5(13));
Func <string,int> f6 = asdf => 1234;
int azxc = f6 ("干什么");

}
}

public delegate void MyDelegate();
class MainClass
{
//声明一个委托类型的变量
//		public MyDelegate myDelegate;
//声明一个事件，该怎么用怎么用，没有什么改变，
public event MyDelegate myDelegate;

public static void Main (string[] args)
{
MainClass mc = new MainClass ();
mc.myDelegate = Test;
mc.myDelegate ();

}
public static void Test()
{
Console.WriteLine ("Test");
}

}
public delegate void MyDelegete();
class Test01
{
public event MyDelegate MyDelegete01;
public static void Main01(string[] args01){

Test01 t01 = new Test01 ();
t01.MyDelegete01 = Test02;
t01.MyDelegete01 ();
}
public static void Test02()
{
Console.WriteLine ("干什么");
}

}