c语言中void action1,使用Action、Func和Lambda表达式

使用Action、Func和Lambda表达式

在.NET在,我们经常使用委托,委托的作用不必多说，在.NET 2.0之前,我们在使用委托之前,得自定义一个委托类型，再使用这个自定义的委托类型定义一个委托字段或变量。.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;

public 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.Show();

}

}

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

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

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

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

using System;

using System.Windows.Forms;

public class ActionStudy

{

public static void Main()

{

ActionmessageTarget;

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

{

ActionPrintInConsole = s => Console.WriteLine(s);

ActionPrintInDialog = s=>MessageBox.Show(s);

Listnames = new List();

names.Add("Bruce");

names.Add("Alfred");

names.Add("Tim");

names.Add("Richard");

names.ForEach(PrintInConsole);

names.ForEach(PrintInDialog);

}

}

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

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

可以使用 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.";

Actionconcat;

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委托,封装一个方法，该方法采用三个参数并且不返回值。

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

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

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

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

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

二.Func系统的泛型委托

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

三，Lambda表达式

C#2.0介绍了一个新特性--匿名方法，允许研发者在线(inline)声明自己的函数代码而无须使用委托函数(delegate function)。C#3.0中提供了一个新特性--Lambda表达式，他提供了完成相同目标的更加简洁的格式。让我们在讨论Lambda表达式以前仔细研究一下匿名方法。

匿名方法

假设你需要创建一个按钮，当点击他的时候更新ListBox里的内容。在C#1.0和1.1里，你要这样做：

public MyForm()

{

listBox = new ListBox(...);

textBox = new TextBox(...);

addButton = new Button(...);

addButton.Click += new EventHandler(AddClick);

}

void AddClick(object sender, EventArgs e)

{

listBox.Items.Add(textBox.Text);

}

在C#2.0里，你需要这样做：

public MyForm()

{

listBox = new ListBox(...);

textBox = new TextBox(...);

addButton = new Button(...);

addButton.Click += delegate

{

listBox.Items.Add(textBox.Text);

};

就像你看到的相同，你不必要特别的声明一个新方法来将他连接到一个事件上。你能在C#2.0里使用匿名方法来完成同样的工作。C#3.0里介绍了一种更加简单的格式，Lambda表达式，你能直接使用"=>"来书写你的表达式列表，后面跟上一个表达式或语句块。

Lambda表达式中的参数

Lambda表达式中的参数能是显式或隐式类型的。在一个显式类型参数列表里，每个表达式的类型是显式指定的。在一个隐式类型参数列表里，类型是通过上下文推断出来的：

(int x) => x + 1 // 显式类型参数

(y,z) => return y * z; // 隐式类型参数

Lambda演算实例

下面的例子给出了两种不同的方法来打印出一个list中长度为偶数的字符串。第一种方法AnonMethod使用了匿名方法，第二种LambdaExample则是通过Lambda演算实现：

// Program.cs

using System;

using System.Collections.Generic;

using System.Text;

using System.Query;

using System.Xml.XLinq;

using System.Data.DLinq;

namespace LambdaExample

{

public delegate bool KeyValueFilter(K key, V value);

static class Program

{

static void Main(string[] args)

{

Listlist = new List();

list.Add("AA");

list.Add("ABC");

list.Add("DEFG");

list.Add("XYZ");

Console.WriteLine("Through Anonymous method");

AnonMethod(list);

Console.WriteLine("Through Lambda expression");

LambdaExample(list);

DictionaryvarClothes= new Dictionary();

varClothes.Add("Jeans", 20);

varClothes.Add("Shirts", 15);

varClothes.Add("Pajamas", 9);

varClothes.Add("Shoes", 9);

var ClothesListShortage = varClothes.FilterBy((string name,

int count) => name == "Shoes" && count < 10);

// example of multiple parameters

if(ClothesListShortage.Count > 0)

Console.WriteLine("We are short of shoes");

Console.ReadLine();

}

static void AnonMethod(Listlist)

{

ListevenNumbers = list.FindAll(delegate(string i)

{ return (i.Length % 2) == 0; });

foreach (string evenNumber in evenNumbers)

{

Console.WriteLine(evenNumber);

}

}

static void LambdaExample(Listlist)

{

var evenNumbers = list.FindAll(i =>(i.Length % 2) == 0); // example of single parameter

foreach(string i in evenNumbers)

{

Console.WriteLine(i);

}

}

}

public static class Extensions

{

public static DictionaryFilterBy(this Dictionaryitems, KeyValueFilterfilter)

{

var result = new Dictionary();

foreach(KeyValuePairelement in items)

{

if (filter(element.Key, element.Value))

result.Add(element.Key, element.Value);

}

return result;

}

}

}

如果你安装了Visual Studio 2005 and LinQ Preview，你能使用编辑器来编译程式。如果没有的话，能使用命令行方式：

C:＼Program Files＼LINQ Preview＼Bin＼Csc.exe

/reference:"C:＼Program Files＼LINQ Preview＼Bin＼System.Data.DLinq.dll"

/reference:C:＼WINDOWS＼Microsoft.NET＼Framework＼v2.0.50727＼System.Data.dll

/reference:C:＼WINDOWS＼Microsoft.NET＼Framework＼v2.0.50727＼System.dll

/reference:"C:＼Program Files＼LINQ Preview＼Bin＼System.Query.dll"

/reference:C:＼WINDOWS＼Microsoft.NET＼Framework＼v2.0.50727＼System.Xml.dll

/reference:"C:＼Program Files＼LINQ Preview＼Bin＼System.Xml.XLinq.dll"

/target:exe Program.cs

中间语言结果显示

打开ILDASM我们来查看一下程式，你将看到如图1所示的内容：

图1

双击AnonMethod函数你将看到C#编译器产生的中间语言代码：

.method private hidebysig static void AnonMethod(class

[mscorlib]System.Collections.Generic.List`1list)

cil managed

{

// Code size 96 (0x60)

.maxstack 4

.locals init ([0] class [mscorlib]System.Collections.Generic.List

`1evenNumbers,

[1] string evenNumber,

[2] valuetype [mscorlib]System.Collections.Generic.List

`1/EnumeratorCSCODE_REPLACEMENT 000,

[3] bool CSCODE_REPLACEMENT 001)

IL_0000: nop

IL_0001: ldarg.0

IL_0002: ldsfld class [mscorlib]System.Predicate

`1LambdaExample.Program::

`<>9__CachedAnonymousMethodDelegate1

IL_0007: brtrue.s IL_001c

IL_0009: ldnull

IL_000a: ldftn bool LambdaExample.Program::

`b__0(string)

IL_0010: newobj instance void class [mscorlib]System.Predicate

`1::.ctor(object, native int)

IL_0015: stsfld class [mscorlib]System.Predicate`1LambdaExample.Program::

`<>9__CachedAnonymousMethodDelegate1

IL_001a: br.s IL_001c

IL_001c: ldsfld class [mscorlib]System.Predicate`1LambdaExample.Program::<>

9__CachedAnonymousMethodDelegate1

IL_0021: callvirt instance class [mscorlib]System.Collections.

Generic.List`1 class [mscorlib]System.

Collections.Generic.List`1::

FindAll(class [mscorlib]System.Predicate`1)

IL_0026: stloc.0

IL_0027: nop

IL_0028: ldloc.0

IL_0029: callvirt instance valuetype [mscorlib]System.Collections.

Generic.List`1/Enumerator class

[mscorlib]System.Collections.Generic.List`1

::GetEnumerator()

IL_002e: stloc.2

.try

{

IL_002f: br.s IL_0042

IL_0031: ldloca.s CSCODE_REPLACEMENT 000

IL_0033: call instance !0 valuetype [mscorlib]System.

Collections.Generic.List`1/Enumerator

::get_Current()

IL_0038: stloc.1

IL_0039: nop

IL_003a: ldloc.1

IL_003b: call void [mscorlib]System.Console::

WriteLine(string)

IL_0040: nop

IL_0041: nop

IL_0042: ldloca.s CSCODE_REPLACEMENT 000

IL_0044: call instance bool valuetype [mscorlib]System.

Collections.Generic.List`1/Enumerator

::MoveNext()

IL_0049: stloc.3

IL_004a: ldloc.3

IL_004b: brtrue.s IL_0031

IL_004d: leave.s IL_005e

} // end .try

finally

{

IL_004f: ldloca.s CSCODE_REPLACEMENT 000

IL_0051: constrained. valuetype [mscorlib]System.Collections.

Generic.List`1/EnumeratorIL_0057: callvirt instance void [mscorlib]System.

IDisposable::Dispose()

IL_005c: nop

IL_005d: endfinally

} // end handler

IL_005e: nop

IL_005f: ret

} // end of method Program::AnonMethod

这里我们能看到，实际上匿名方法和lambda表达式生成了相同的中间代码，并且他们的执行也是类似的。

多参数的Lambda表达式

Lambda表达式能带上多个参数，比如你能声明一个Dictionary类型：

Clothing Type

Count

Shirts

15

Jeans

12

Shoes

9

Pajamas

9

如果你有一个匿名方法(FilterBy)来通过键和值来过滤字典，按么你能传递多个参数给lambda表达式来调用这个匿名方法。附带的代码完成了这个FilterBy的功能：

var ClothesListShortage = clothesList.FilterBy((string name, int count)

=> name == "Shoes" && count < 10);