澳门至尊网站-首页

您的位置:澳门至尊网站 > 软件综合 > params关键字修饰的参数的匿名委托和Lambda表达式

params关键字修饰的参数的匿名委托和Lambda表达式

2019-10-22 08:54

委托

原为出处:

委托与事件,经常拿来就用,往往忘记其实现原理,对其使用方式也越来越局限。周家安老师在《C# 6.0 学习笔记》中对委托和事件的讲解,深入浅出,清晰明了,故特意摘抄一篇随笔,勤看勤思。

在.NET在,我们经常使用委托,委托的作用不必多说,在.NET 2.0之前,我们在使用委托之前,得自定义一个委托类型,再使用这个自定义的委托类型定义一个委托字段或变量。.NET 2.0给我们带来了Action、Func两个泛型委托,.NET3.0给我们带来了Lambda,这一切使得委托的定义和使用变得简单起来。下面的例子中的委托都使用了Lambda表达式。

首先,委托是一种形式上与方法签名相似的类型。

一.Action系列的泛型委托

定义一个委托:

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

public delegate void DoSome(string msg);

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

 

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

使用关键字 delegate, 类型名称为 DoSome(string msg).

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

 

using System;

 

using System.Windows.Forms;

创建一个DoSome(string msg)委托类型对象,并实例化。

public class Name

 1 static void TestDo(string str)
 2 {
 3      // ToDo
 4 }
 5 
 6 
 7 DoSome d1 = new DoSome(TestDo);
 8 
 9 
10 // 或者
11 
12 DoSome  d2;
13 
14 d2 = TestDo;

{

 委托列表

   private string instanceName;

 1 public delegate void DoSome(string msg);
 2 static void Main(string[] args)
 3 {
 4     DoSome d = new DoSome(TestDo);
 5     d("Hello");
 6     Console.WriteLine("--------------------------------------");
 7     d += new DoSome(Test1);
 8     d("123");
 9     Console.WriteLine("--------------------------------------");
10     d += TDo2;
11     d("world");
12     Console.WriteLine("--------------------------------------");
13     d -= TestDo;
14     d("nihao");
15 }
16 
17 static void TestDo(string str)
18 {
19     Console.WriteLine(str);
20 }
21 
22 static void Test1(string str)
23 {
24     Console.WriteLine("Test1 + " + str);
25 }
26 static void TDo2(string str)
27 {
28     Console.WriteLine("TDo2 + " + str);
29 }

   public Action ShowName;

输出:

   public Show()

图片 1

{

 

   If(ShowName != null)

事件

    ShowName();

 事件自身就是委托类型。

}

 1     class MyApp
 2     {
 3         public delegate void SpaceKeyPressedEventHandler();
 4 
 5         // 声明事件
 6         public event SpaceKeyPressedEventHandler SpaceKeyPressed;
 7 
 8         // 通过该方法引发事件
 9         protected virtual void OnSpaceKeyPressed()
10         {
11 
12             if (this.SpaceKeyPressed != null)
13             {
14                 // 将事件分发
15                 SpaceKeyPressed();
16             }
17         }
18 
19         // 启动事件监听的接口
20         public void StartRun()
21         {
22             // 监听事件
23             while (true)
24             {
25                 ConsoleKeyInfo keyinfo = Console.ReadKey();
26                 if (keyinfo.Key == ConsoleKey.Spacebar)
27                 {
28                     // 引发事件
29                     OnSpaceKeyPressed();
30                 }
31 
32                 if (keyinfo.Key == ConsoleKey.Escape)
33                 {
34                     // 跳出循环
35                     break;
36                 }
37             }
38         }
39     }
40 
41     class Program
42     {
43        
44         static void Main(string[] args)
45         {
46             MyApp app = new MyApp();
47             // 订阅事件,指定处理事件的方法
48             app.SpaceKeyPressed += app_SpaceKeyPressed;
49             app.SpaceKeyPressed += app_SecondEventHandler;
50 
51             // 启动事件监听
52             app.StartRun();
53         
54         }   
55 
56         // 事件处理1
57         private static void app_SpaceKeyPressed()
58         {
59             Console.WriteLine("{0} 按下空格键。", DateTime.Now.ToLongTimeString());
60         }
61         // 事件处理2
62         private static void app_SecondEventHandler()
63         {
64             Console.WriteLine("事件的第二个处理方法。");
65         }
66 
67     }

   public Name(string name)

通常,作为事件委托,有两个参数,一个是Object类型,表示引发事件的对象,即是谁引发了事件的,多数情况下在调用事件时是把类的当前实例引用(this)传递过去。另一个参数是从System.EventArgs派省的类的实例。这是一个标准的事件处理程序的签名,为了规范事件的处理,.NET类库已经定义好一个System.EventHandler委托,用于声明事件。它的原型如下:

   {

1 public delegate void EventHandler(object sender, EventArgs e);

      this.instanceName = name;

 引发事件的对象实例将传递给sender参数,而与事件相关的数据则传递给e参数。如果不需要传递过多的数据,可以通过System.EventArgs.Empty静态成员返回一个空的EventArgs对象类传递。

   }

但是,由于不同的事件要传递的参数不同,更多时候是从EventArgs类派生的子类的实例,显然一个EventHandler委托是不能满足各种情况的。如果针对不同的事件也顶一个一个对应的委托,水量一旦多起来,既混乱,也不好管理。为了解决这个问题,.NET类库又提供了一个带有泛型参数的事件处理委托。原型如下:

   public void DisplayToConsole()

1 public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);

   {

TEventArgs 是一个泛型参数,应该是System.EventArgs类或者System.EventArgs类的派生类型。

      Console.WriteLine(this.instanceName);

泛型参数的事件,实例:

   }

 1     // EventArgs 派生类
 2     // 创建泛型参数  KeyPressedEventArgs 类
 3     public class KeyPressedEventArgs : EventArgs
 4     {
 5         public ConsoleKey pressedKey { get; private set; }
 6         public KeyPressedEventArgs(ConsoleKey key)
 7         {
 8             pressedKey = key;
 9         }
10     }
11 
12     public class MyApp
13     {
14         // 捕捉按键的事件 声明一个泛型参数KeyPressedEventArgs类型的
15         public event EventHandler<KeyPressedEventArgs> KeyPressed;
16 
17         // 通过该方法引发事件
18         protected virtual void OnKeyPressed(KeyPressedEventArgs e)
19         {
20             if (this.KeyPressed != null )
21             {
22                 this.KeyPressed(this, e);
23             }
24         }
25 
26         // 事件监听端口启动
27         public void Start()
28         {
29             while (true)
30             {
31                 ConsoleKeyInfo keyInfo = Console.ReadKey();
32                 // 如果按下了ESC键,则退出循环
33                 if (keyInfo.Key == ConsoleKey.Escape)
34                 {
35                     break;
36                 }
37                 // 引发事件
38                 OnKeyPressed(new KeyPressedEventArgs(keyInfo.Key));
39             }
40         }
41     }
42 
43 
44     class Program
45     {
46        
47         static void Main(string[] args)
48         {
49             
50             MyApp app = new MyApp();
51             // 订阅事件,指定处理事件的方法
52             app.KeyPressed += app_KeyPressed;
53             // 启动事件监听
54             app.Start();
55         }   
56 
57         // 事件处理
58         private static void app_KeyPressed(Object sender, KeyPressedEventArgs e)
59         {
60             Console.WriteLine("已按下 {0} 键", e.pressedKey.ToString());
61         }
62         
63     }

   public void DisplayToWindow()

 

   {

      MessageBox.Show(this.instanceName);

   }

}

public class ActionStudy

{

   public static void Main()

   {

      Name testName = new Name("Koani");

      testName.ShowName  = () => testName.DisplayToWindow();

      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);      

    }

}

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(params object[] param);

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

DelegateWithParamskeyword dwp = 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关键字.

DelegateWithParamskeyword dwp = 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声明的委托,这样一来,就可以在调用时传入你希望的任意数目的参数。

本文由澳门至尊网站发布于软件综合,转载请注明出处:params关键字修饰的参数的匿名委托和Lambda表达式

关键词: