使用Action、Func,EventHandler,params关键字修饰的参数的匿名委托和Lambda表达式

使用Action、Func,EventHandler,params关键字修饰的参数的匿名委托和Lambda表达式

.NET 2.0给我们带来了Action、Func两个泛型委托，.NET3.0给我们带来了Lambda，这一切使得委托的定义和使用变得简单起来。下面的例子 中的委托都使用了Lambda表达式。

　　一.Action系列的泛型委托

　　Action系列的委托定义的是没有返回值(返回值为void)的委托。它有多个版本包括没有输入参数,1个输入参数,2个输入参数,3个输入参数,4个输入参数共5个版本这几个版本的原型如下:

　　1.　　　 没有输入参数返回值为void的委托.

　　Action委托 封装一个 方法 ，该方法不采用参数并且不返回值。

　　可以使用此委托以参数形式传递一个执行某操作的方法，而不用显式声明一个自定义的委托来封装此方法。该封装的方法必须与此委托定义的方法签名相对应。这意味着该方法不得具有参数和返回值。例:

using System;
using System.Windows.Forms;
public class Name
{
　 private string instanceName;//定义变量
　 public Action  ShowName;//定义Action 委托类型的变量ShowName
　 public void  Show()
{
　 If(ShowName != null)
　　ShowName();//调用委托（注意：无参数）
}
　 public Name(string name)//属性
　 {
　　　this.instanceName = name;
　 }
　 public void DisplayToConsole()//方法
　 {
　　　Console.WriteLine(this.instanceName);
　 }
　 public void DisplayToWindow()//方法
　 {
　　　MessageBox.Show(this.instanceName);
　 }
}
public class ActionStudy
{
　 public static void Main()
　 {
　　　Name testName = new Name("Koani");//声明类对象
　　　testName.ShowName = () => testName.DisplayToWindow();//关联方法


           // testName.ShowName = () => testName.DisplayToConsole();//关联方法
　　　testName.Show();
　 }
}

　2.　　　 有1个输入参数返回值为void的委托

　　Action<T>泛型委托封装一个 方法 ，该方法只采用一个参数并且不返回值。

　　可以使用此委托以参数形式传递方法，而不用显式声明自定义的委托。该方法必须与此

　　委托定义的方法签名相对应。也就是说，封装的方法必须具有一个通过值传递给它的参数，并且不能返回值。例:

using System;
using System.Windows.Forms;
　　
public class ActionStudy
{
　 public static void Main()
　 {
　　　Action<string> messageTarget;
　　　if (Environment.GetCommandLineArgs().Length > 1)
　　　　 messageTarget = s => MessageBox.Show(s);
　　　else
　　　　 messageTarget = s => Console.WriteLine(s);
　　
　　　messageTarget("Hello, World!");//注意参数
　 }
}

　　下面的示例演示如何使用 Action(T) 委托来打印 List(T) 对象的内容。在此示例中，使用 Print 方法将列表的内容显示到控制台上。此外，C# 示例还演示如何使用匿名方法将内容显示到控制台上。

using System;
using System.Collections.Generic;
　　
class Program
{
　　static void Main()
　　{
　　　　Action<string> PrintInConsole = s => Console.WriteLine(s);
　　　　Action<string> PrintInDialog = s=>MessageBox.Show(s);
　　　　List<String> names = new List<String>();
　　　　names.Add("Bruce");
　　　　names.Add("Alfred");
　　　　names.Add("Tim");
　　　　names.Add("Richard");
　　　　names.ForEach(PrintInConsole);
　　　　names.ForEach(PrintInDialog);　

               //ForEach（string str in names）PrintInConsole（str）；　　
　　}
}

3.　　　 有2个输入参数返回值为void的委托

　　Action<T1,T2> 封装一个 方法 ，该方法具有两个参数并且不返回值。

　　可以使用 Action(T1, T2) 委托以参数形式传递方法，而不用显式声明自定义的委托。该

　　方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有两个均通过值传递给它的参数，并且不能返回值。

using System;
using System.IO;
　　
public class ActinStudy
{
　 public static void Main()
　 {
　　　string message1 = "The first line of a message.";
　　　string message2 = "The second line of a message.";
　　　Action<string, string> concat;
　　
　　　if (Environment.GetCommandLineArgs().Length > 1)
　　　　 concat = (s1, s2) =>
{
StreamWriter writer = null;
　　　try
　　　{
　　　　 writer = new StreamWriter(Environment.GetCommandLineArgs()[1], false);
　　　　 writer.WriteLine("{0}"n{1}", s1, s2);
　　　}
　　　catch
　　　{
　　　　 Console.WriteLine("File write operation failed...");
　　　}
　　　finally
　　　{
　　　　 if (writer != null) writer.Close();
　　　}
};
　　　else
　　　　 concat = (s1, s2) => Console.WriteLine("{0}"n{1}", s1, s2);
　　
　　　concat(message1, message2);
　 }

　　4.　　　 有3个输入参数返回值为void的委托

　Action<T1,T2,T3>委托,封装一个 方法 ，该方法采用三个参数并且不返回值。

　　可以使用 Action(T1, T2, T3) 委托以参数形式传递方法，而不用显式声明自定义的委托。

　　该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有三个均通过值传递给它的参数，并且不能返回值。

　　5.　　　 有4个输入参数返回值为void的委托

　　Action<T1,T2,T3,T4>委托, 封装一个方法，该方法具有四个参数并且不返回值。

　　可以使用 Action(T1, T2, T3, T4) 委托以参数形式传递方法，而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且不能返回值。

　　二.Func系统的泛型委托

　　Func系列的委托定义的是返回值的委托。它有多个版本包括没有输入参数,1个输入参数,2个输入参数,3个输入参数,4个输入参数共5个版本这几个版本的原型如下:

　　1.　　　 没有输入参数有返回值(返回值不为void)的委托

　　Func<TResult>封装一个不具有参数但却返回 TResult 参数指定的类型值的方法。

　　可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该

　　方法必须与此委托定义的方法签名相对应。这意味着封装的方法不得具有参数，但必须返回值。

　　2.　　　 具有一个输入参数有返回值(返回值不为void)的委托

　　Func<T,TResult>封装一个具有一个参数并返回 TResult 参数指定的类型值的方法。

　　可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有一个通过值传递给它的参数，并且必须返回值。

3.　　　 具有二个输入参数有返回值(返回值不为void)的委托

　　Func<T1,T2,TResult>封装一个具有一个参数并返回 TResult 参数指定的类型值的 方法 。

　　可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有两个均通过值传递给它的参数，并且必须返回值

　　4.　　　 具有三个输入参数有返回值(返回值不为void)的委托

　　Func<T1,T2,T3,TResut>封装一个具有三个参数并返回 TResult 参数指定的类型值的方法。

　　可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有三个均通过值传递给它的参数，并且必须返回值。

　　5.　　　 具有四个输入参数有返回值(返回值不为void)的委托

　　Func<T1,T2,T3,TResult>封装一个具有四个参数并返回 TResult 参数指定的类型值的方法。

　　可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且必须返回值。

　　三. EventHandler(TEventArgs) 泛型委托

　　EventHandler(TEventArgs) 是一种预定义委托，表示事件的事件处理程序方法，它与事件是否生成事件数据无关。如果事件不生成事件数据，则用 EventArgs 替代泛型类型参数；否则，提供自己的自定义事件数据类型并用该类型替代泛型类型参数。

　　使用 EventHandler<(Of <(TEventArgs>)>) 的优点在于，如果事件生成事件数据，则无需编写自己的自定义委托代码。此外，.NET Framework 只需一个实现就能支持 EventHandler<(Of <(TEventArgs>)>)，这与替代泛型类型参数的事件数据类型无关。

　若要将事件与处理事件的 方法 关联，请向事件添加委托的实例。除非移除了该委托，否则每当发生该事件时就调用事件处理程序。

　　我们知道,.NET Framework 中的事件模型基于已有事件委托，该委托将事件与事件处理程序连接。引发事件需要两个元素：

　　①　　 引用向事件提供响应的方法的委托。

　　②保存事件数据的类。

　　下面是MSDN上的一个简单的例子:

　　下面的代码示例声明事件数据和使用该事件数据的 EventHandler<(Of <(TEventArgs>)>) 泛型委托，并演示如何引发该事件。

using System;
using System.Collections.Generic;
　　
//首先定义事件处理参数:这个参数派生于EventArgs
public class MyEventArgs : EventArgs
{
　　private string msg;
　　public MyEventArgs( string messageData ) { msg = messageData;}
　　public string Message {
　　　　get { return msg; }
　　　　set { msg = value; }
　　}
}
//下面定义事件处理类,注意这里用到了EventHandler<T>委托类型
public class HasEvent
{
// Declare an event of delegate type EventHandler of
// MyEventArgs.
　　public event EventHandler<MyEventArgs> SampleEvent;
　　public void DemoEvent(string val)
　　{
　　　　//复制到临时变量,以确保线程安全
　　　　EventHandler<MyEventArgs> temp = SampleEvent;
　　　　if (temp != null)
　　　　　　temp(this, new MyEventArgs(val));
　　}
}

　　如果在以前的老办法则上面的类则应该写为:

//首先得定义一个委托
public delegate void MyEventHandler(Object sender, MyEventArgs args);
public class HasEvent
{
// Declare an event of delegate type EventHandler of
// MyEventArgs.
　　public event MyEventHandler SampleEvent;
　　public void DemoEvent(string val)
　　{
　　　　//复制到临时变量,以确保线程安全
　　　　MyEventHandler temp = SampleEvent;
　　　　if (temp != null)
　　　　　　temp(this, new MyEventArgs(val));
　　}
}

　　可见使用这个泛型委托精简了许多代码.

//-下面的类订阅了上面定义的事件
public class Sample
{
　　public static void Main()
　　{
　　　　HasEvent he = new HasEvent();
　　　　he.SampleEvent +=


    new ventHandler<MyEventArgs>((object src,MyEventArgs mea) =>                                   MessageBox.Show(mea.Message));//    这里使用了Lambda表达式

　　　　he.DemoEvent("Hey there, Bruce!");
　　　　he.DemoEvent("How are you today?");
　　　　he.DemoEvent("I'm pretty good.");
　　　　he.DemoEvent("Thanks for asking!");
　　}
}

　　四.params参数类型的委托

　　在上面介绍的Action和Func系列的委托中,不能够使用由params关键字修改的参数,我本来想用params关键字来实现可变类型的参数,结果发现行不通,这时只能用变通类型的委托,但是请注意在用匿名 方法 绑定具有params关键字修饰的参数的委托时,匿名方法的参数中却不能有params关键字,在匿名方法中只有去掉了params关键字,尽管从匿名方法中去掉了params关键字,但这并不妨碍使用 同样 的语法.

　　例如声明了如下类型的委托

public void delegate DelegateWithParamskeyword(paramsobject[] param);

　　但是你去不能用下面的方法去绑定一个匿名方法:

DelegateWithParamskeyworddwp = delegate(params object[] param)
{
foreach(object o in param)
{
　　Console.WriteLine(o.ToString());
}
}

　　或者

DelegateWithParamskeyword dwpkw = (params object[] param) => {foreach(object o in param) MessageBox.Show(o.ToString());};

　　而应该去掉上面匿名方法中的params关键字.

DelegateWithParamskeyworddwp = delegate(object[] param)
{
foreach(object o in param)
{
　　Console.WriteLine(o.ToString());
}
}

　　或者

　　DelegateWithParamskeyword dwpkw = (object[] param) => {foreach(object o in param) MessageBox.Show(o.ToString());};

　　就像上面说的这并不影响你使用同样的的 语法 来调用委托

　　如: dwp(1,2,”x”,”y”,”dog”,9.28);

　　dwpkw(“dog”,”xy”,10);

　　所以,可以将匿名方法绑定到一个使用params声明的委托,这样一来,就可以在调用时传入你希望的任意数目的参数。