关于Action<T> 、Func<T>、EventHandler<T>、event、delegate

c# 最初的时候 只有 delegate,之后的版本封装了Action<T> 、Func<T>、EventHandler<T>

关于Action<T>

实际上Action<T> 等同于旧版的

public delegate void Action();
public delegate void Action<T1>(T1 arg1);
public delegate void Action<T1, T2>(T1 arg1, T2 arg2);
public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

新版写法一：

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
//同步执行
Action Action = new Action(writeLine);
Action.Invoke();
//异步执行
Action ActionAsy = new Action(writeLine2);
ActionAsy.BeginInvoke(resual=>Console.WriteLine("异步执行结束"), null);
Console.Read();
}
private static void writeLine()
{
Console.WriteLine("Action同步执行委托");
}
private static void writeLine2()
{
Console.WriteLine("Action异步执行委托");
}

新版写法2（lambda表达式）

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
//同步执行 用Lambda表达式代替writeLine
Action Action = new Action(()=>Console.WriteLine("Action同步执行委托"));
Action.Invoke();
//异步执行 用Lambda表达式代替writeLine2
Action ActionAsy = new Action(()=>Console.WriteLine("Action异步执行委托"));
ActionAsy.BeginInvoke(resual=>Console.WriteLine("异步执行结束"), null);
Console.Read();
}

新版写法3(带参数的)

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
//同步执行 传入一个参数
Action<string> Action = new Action<string>((a)=>Console.WriteLine(string.Format("Action同步执行委托,传入参数：{0}",a)));
Action.Invoke("小李");
//异步执行 传入两个参数
Action<string,int> ActionAsy = new Action<string,int>((a,b)=>Console.WriteLine("Action异步执行委托,传入参数：{0}，{1}",a,b));
ActionAsy.BeginInvoke("小李",12,resual=>Console.WriteLine("异步执行结束"), null);
Console.Read();
}

在上面代码中，同步定义的string类型，必须保证传入的参数a也是string。虽然并没有对a进行类型定义，但是系统默认就是事先泛型中定义的类型。类似的，异步委托也是一样。不然会报错。

关于Func<T>

实际上 Func<T>等同于旧版的

public delegate TResult Func<TResult>();
public delegate TResult Func<T1, TResult>(T1 arg1);
public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);
public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate TResult Func<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

Func<T>委托的定义是相对于Action<T>来说。Action<T>是没有返回值得方法委托，Func<T>是有返回值的委托。返回值的类型，由泛型中定义的类型进行约束。例如：

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
//异步执行
Func<string> FuncAsy = new Func<string>(() =>
{
people tPeo = new people("异步小李", 10);
return tPeo.ToString();
}
);
FuncAsy.BeginInvoke(resual =>
{
//异步执行，从回调函数中获取返回结果
Console.WriteLine(FuncAsy.EndInvoke(resual));
Console.WriteLine("异步执行结束");
}, null);
//同步执行
Func<string> Func = new Func<string>(() =>
{
people tPeo = new people("同步小李", 12);
return tPeo.ToString();
}
);
//同步执行，获取返回结果
Console.WriteLine(Func.Invoke());
Console.Read();
}
public class people
{
public string Name { get; set; }
public int Age { get; set; }
public people(string pName, int pAge)
{
this.Name = pName;
this.Age = pAge;
}
public override string ToString()
{
return string.Format("名称叫{0}，年龄{1}", this.Name, this.Age);
}
}

多参数新版写法：

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
//异步执行 传入一个people类型的参数，返回一个sting类型的结果
Func<people, string> FuncAsy = new Func<people, string>((pPeople) =>
{
return pPeople.Name;
}
);
FuncAsy.BeginInvoke(new people("异步小李", 12), resual =>
{
//异步执行，从回调函数中获取返回结果
Console.WriteLine(FuncAsy.EndInvoke(resual));
Console.WriteLine("异步执行结束");
}, null);
//同步执行 传入一个string，int类型的参数，返回一个people类型的结果
Func<string, int, people> Func = new Func<string, int, people>((pName,pAge) =>
{
people tPeo = new people(pName, pAge);
return tPeo;
}
);
//同步执行，返回结果
Console.WriteLine(Func.Invoke("同步小李",12).ToString());
Console.Read();
}

关于EventHandler<T>

实际上 EventHandler<T> 等同于旧版的

public delegate void CustomEventHandler(object sender, CustomEventArgs a);
public event CustomEventHandler RaiseCustomEvent;

新版写法：

public event EventHandler<CustomEventArgs> RaiseCustomEvent;

1：EventHandler实际上就是一个特殊的委托，它是由.NET预定义好的一个委托,它的形式是固定的。
2：使用EventHandler时，处理函数的返回值必须是Void类型,而使用Deleagate则没有这个限制。
3：Delegate相当于一个函数的指针，用于绑定的函数返回值和参数列表要符合Delegate声明时的要求。

参考资料：http://www.cnblogs.com/cglNet/p/3395954.html