C# Lambda表达式事例-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

C# Lambda表达式事例

简介:
C# Lambda表达式事例
Lambda表达式语法看上去真的很别扭,其实它就是便变种的匿名方法。其实你不用去管它的语法为什么是这样,你只要记住规则然后通过编写代码和比较慢慢的去体会就可以了,先来看匿名方法:
yuanl注释:首先使用集合初始化语法建立一个整型列表
List list = new List() { 1, 2, 3, 4, 5, 6, 7 };
//你也可以这样:List<int> list =new List<int>(){1, 2, 3, 4, 5, 6, 7};
//匿名方法的使用如下:
List ddNumbers = list.FindAll(
delegate(int i)
{
return (i % 2) != 0;
}

);//匿名方法到此结束,它的作用是筛选数据

foreach (var oddNumber in oddNumbers)//迭代输出数据
{
//输出奇数
Console.WriteLine(oddNumber);
}
上面的匿名方法,我们必须使用delegate来标注,而且还要保证输入参数的类型匹配,这种语法确实还是让人觉得不舒坦。Lambda表达式是如何简化FindAll()方法的:
List ddNumbers = list.FindAll(i => (i % 2) != 0);
//等价于:List ddNumbers = list.FindAll(i =>{if( (i % 2) != 0){return i;}});
解剖Lambda表达式
i => (i % 2) != 0
Lambda表达式的 => 标记(读作 goes to),它的前面是一个参数列表,后面是一个表达式或表达式块。
很明显,前面的参数列表并没有定义参数的类型(由编译器根据上下文推断出i是一个整型),所以它是隐式的。当然,我们也可以显示定义: (int i)=>(i%2)!=0);
我们这里参数列表只有一个参数,所以那个括号可以被省略。

Lambda表达式块语句形式:

List list = new List { 1,2,3,4,5,6,7};
//因为表达式需要多行代码来处理参数切记表达式块的编写规范
var testList=list.FindAll(i=>{
Console.WriteLine("调用FindAll()");
Console.WriteLine("i的值是{0}",i);
bool isOdd=((i%2)!=0);
Console.WriteLine("是否是奇数:"+isOdd);
return isOdd; //Lambda 必须返回满足某个条件的Bool值
});//注意这里的分号
foreach (var a in testList)//var换作int 同样可以(只要符合类型转换规则就好)
{
Console.WriteLine(a);
}
再看下面的例子
使用 .net 2.0 的匿名方法来搜索字符串数组中包含 a 的字符串数组
static void Main(string[] args)
{
string[] list = new string[] { "abc", "12", "java" };//注意字符串数组的初始化规范
string[] yuanl = Array.FindAll(list,
delegate(string s)
{
return s.IndexOf("a") >= 0;
}
//上面等价于:string[] yuanl = list.FindAll(delegate(string s){ return s.IndexOf("a") >= 0;});
foreach (string str in yuanl)
{
Console.WriteLine(str);
}
Console.ReadLine();//这一句主要不同方式的调试环境
}
使用 .net 3.5 的Lambda表达式来搜索字符串数组中包含 a 的字符串数组
static void Main(string[] args)
{
string[] list = new string[] { "abc", "12", "java" };

string[] ll = Array.FindAll(list, s => (s.IndexOf("a") >= 0));
foreach (string str in ll)
{
Console.WriteLine(str);
}
Console.ReadLine();
}

从上述几个例子我们可以看出:
从代码书写角度,代码可读性角度来说:Lambda表达式 比匿名方法更简单了。
而 Lambda表达式 和 匿名方法都是干的同一件事情,让我们少写一个函数定义。函数的调用和函数的实现在一起完成了。
下面有两个参数的 Lambda表达式例子:
注:别看比较复杂,LINQ中实际把 下述代码中的 delegate ,DoSomeThing 替你做了,所以你写代码的时候只需要写
var t = DoSomeThing(7, 8, (x, y) => x * y); 这么一行。
public delegate T yuanl(T t1, T t2);
class Program
{
private static T DoSomeThing(T t1,T t2, yuanl match)//注意yuanl是一T型的委托类型
{
return match(t1, t2);
}
static void Main(string[] args)
{
var t = DoSomeThing(7, 8, (x, y) => x * y);
Console.WriteLine(t);
Console.ReadLine();
}
}
下面这些写法也是对的(你只需要修改Main函数中的代码,其他地方不需要动):
var t = DoSomeThing(7, 8, (int x, int y) => x * y);
var t = DoSomeThing("7", "8", ( x, y) => x + y);//字符串拼接 
或者我们写一个更复杂的: => 右边是一段语句块。
var t = DoSomeThing(7, 8, (x, y) => { if (x < 5) { return (x + 8) * y; } else { return y; } });
最前面的例子是一个参数的例子,我们就不举一个参数的例子了,下面举一个没有参数的例子:
public delegate void yuananl();
class Program
{
private static void DoSomeThing(yuananl match)
{
match();
}

static void Main(string[] args)
{
DoSomeThing(() => Console.WriteLine("jajaja"));
Console.ReadLine();
}
}

同样的,如果一些事件发生的时候我们只想做一点儿简单的事情的话,那么也可用Lambda表达式来实现:
1: System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
2: timer.Interval = 2000;
3: timer.Tick += (sender, e) => { timer.Stop(); MessageBox.Show("Hello, Lambda Expression!"); };

我们来看一段比较完整的代码并以此结束对Lambda表达式的介绍吧:
1: using System;
2: using System.Collections.Generic;
3: 
4: namespace LambdaExpressionDemo
5: {
6: class Program
7: {//定义一List对象_class
8: private static List<StudentData> _class = null;
9: //初始化该对象
10: static void Initialization()
11: {
12: _class = new List<StudentData>();
13: 
14: _class.Add(new StudentData("ZeroCool", 24, GenderType.Male, 87));
15: _class.Add(new StudentData("Michael", 24, GenderType.Male, 93));
16: _class.Add(new StudentData("Frieda", 22, GenderType.Female, 98));
17: _class.Add(new StudentData("Somebody", 23, GenderType.Male, 81));
18: }
19: 
20: static void Main(string[] args)
21: {
22: Initialization();
23: 
24: if (_class == null || _class.Count == 0)
25: {
26: throw new InvalidOperationException("The system initialization was failed.");//抛出异常
27: }
28: //筛选student数据
29: StudentData studentData = _class.Find(student => student.MathScore >= 90 && student.MathScore < 95);
30: RepresentData(studentData);//打印数据
31: //以下几条亦然
32: studentData = _class.Find(student => student.Name.Equals("ZeroCool", StringComparison.InvariantCultureIgnoreCase));
33: RepresentData(studentData);
34: 
35: studentData = _class.Find(student => student.Age < 23);
36: RepresentData(studentData);
37: 
38: Console.ReadLine();
39: }
40: //打印数据方法
41: static void RepresentData(StudentData student)
42: {
43: if (student == null)
44: {
45: Console.WriteLine("No mached student.");
46: 
47: return;
48: }
49: 
50: Console.WriteLine("Name:\t\t" + student.Name);
51: Console.WriteLine("Age:\t\t" + student.Age);
52: Console.WriteLine("Gender:\t\t" + student.Gender.ToString());
53: Console.WriteLine("Math Score:\t" + student.MathScore);
54: Console.WriteLine();
55: }
56: }
57: 
58: public enum GenderType
59: {
60: Male = 0,
61: Female
62: }
63: 
64: public class StudentData
65: {//注意下面字段、属性的定义规范和关联
66: private string _name = String.Empty;
67: public string Name
68: {
69: get { return this._name; }
70: set { this._name = value; }
71: }
72: 
73: private int _age = 0;
74: public int Age
75: {
76: get { return this._age; }
77: set { this._age = value; }
78: }
79: 
80: private GenderType _gender;
81: public GenderType Gender
82: {
83: get { return this._gender; }
84: set { this._gender = value; }
85: }
86: 
87: private int _mathScore = 0;
88: public int MathScore
89: {
90: get { return this._mathScore; }
91: set { this._mathScore = value; }
92: }
93: //无参元的构造方法
94: public StudentData()
95: {
96: }
97: //带有参元的构造方法
98: public StudentData(string name, int age, GenderType gender, int mathScore)
99: {
100: this._name = name;
101: this._age = age;
102: this._gender = gender;
103: this._mathScore = mathScore;
104: }
105: //定义一委托类型
106: public delegate void EmptyDelegate();
107: 委托变量(对象)挂接一方法
108: EmptyDelegate dl = () => Console.WriteLine();
109: }
110: }

表达式树典型的声明形式是:
1: Func<int, int> func = input => input * input;
2: Expression<Func<int, int>> expression = input => input * input;

我们必须要使用的类型是System.Linq.Expressions命名空间中的Expression<T>,而这个T是定义表达式签名的委托的类型,这种把一个Lambda表达式看做一个数据结构而嵌套在另一个Lambda表达式中的做法使得现在的expression不是一个委托而是表达式树的数据结构了。接下来的问题是我们应该如何使用这个表达式树呢?请看完整的代码:
1: static void Main(string[] args)
2: {
3: Func<int, int> func = input => input * input;
4: Console.WriteLine(func(3).ToString());
5: 
6: Expression<Func<int, int>> expression = input => input * input;
7: Func<int, int> fun = expression.Compile();
8: Console.WriteLine(fun(5).ToString());
9: 
10: Console.ReadLine();
11: }

正因为func是可执行代码而expression是数据,所以在使用方式上也会有所差别的,希望以上这些代码可以很好地让你理解Lambda表达式以及表达式树这两个概念。

最后总结一下:从delegate到lambda的演变

先看一个简单的delegate的例子

public static bool IsOdd(int i)
{
return (i & 1) == 1;//判断输入的数据是否为零
}

public delegate bool NumberTester(int i);//声明一委托类型

public static void PrintMatchingNumbers(int from, int to, NumberTester filter)
{
for (int i = from; i <= to; ++i)
{
if (filter(i))//判断
{
Console.WriteLine(i);//输出不为零的数据
}
}
}
调用时只需要执行:

PrintMatchingNumbers(1, 10, new NumberTester(IsOdd));//调用

等价于:PrintMatchingNumbers(1, 10,IsOdd);

很多情况下,我们只要执行只包含一个方法的代理。于是微软在.net 2.0里给我们提供了更方便的anonymous method,比如上面调用IsOdd的过程就能改写成下面这样:

PrintMatchingNumbers(1, 10, delegate(int i)
{
return (i & 1) == 1;
});

如此就避免了IsOdd的声明。微软提供匿名方法的道理是这样的:既然函数IsOdd只在一个地方被调用,那么直接在调用的地方实现岂不更省事儿。这样可以减少我们开发人员的输入。

接着到了3.0,微软更进了一步,他提出了lambda表达式。C#的lambda表达式是这样定义的:参数=> 表达式。于是,我们的代码变的更短:

PrintMatchingNumbers(1, 10, i=>(i & 1) == 1);

也就是说lambda表达式作为一个函数并当作PrintMatchingNumbers的第三个参数来执行,而这个函数只要符合delegate NumberTester的签名就行。理所当然的,lambda表达式可以附值给一个相同签名的delegate:
NumberTester a =new NumberTester();
a += i=>(i & 1) == 1;//注意这里不时数值运算而是方法挂接,a是委托对象

C# 3.0里甚至可以把声明和初始化以及赋值合到一块儿,简写成:

NumberTester a = i=>(i & 1) == 1;

如果我们把NumberTester声明为泛型的delegate,如下:

public delegate U NumberTester<T, U>(T i);

那么这个泛型的delegate应用就太广泛了,涵盖了一切有一个输入参数和一个返回值的函数,所以直接命名为Func更合适,即:
public delegate U Func<T, U>(T i);

其实上面这个类型正是在.net Framework 3.0 中最重要的命名空间 System.Core里定义的。
这样,就可以写成

Func<int,bool> a = i=>(i & 1) == 1;

下面我们再回过头来看看使用这个delegate的PrintMatchingNumbers,应该作相应的更改

public static void PrintMatchingNumbers(int from, int to, Func<int, bool> filter)
{
for (int i = from; i <= to; ++i)
{
if (filter(i))
{
Console.WriteLine(i);
}
}
}

当然,由于泛型的的引入,此处还可以进一步的把类型抽离出来以表达这个意思:在一个范围内的任意的类型的变量,以指定的方式递增,通过判断打印符合条件的值。也就可以得到算法的复用。

完整的例子:

public delegate U Func<T, U>(T i);

public delegate void Func<T>(ref T i);

static void Main(string[] args)

{

DateTime from = DateTime.Parse("2004/06/01");

DateTime to = DateTime.Parse("2005/01/18");

PrintMatchingT<DateTime>(from, to,

delegate(ref DateTime i) { i = i.AddDays(1); },

delegate(DateTime i) { return (i.Month + i.Day == 11);});

Console.WriteLine();

Console.Read();

}

public static void PrintMatchingT<T>(T from, T to, Func<T> incre, Func<T, bool> filter) where T : IComparable<T>
{
for (T i = from; (i.CompareTo(to) < 0); incre(ref i))
{
if (filter(i))
{
Console.WriteLine(i);
}
}
}

这个例子是在指定的时间范围内以天为递增量,判断代表月与日的数字加起来为11的日子。当然具体到这个例子,我们也能把bool改成泛型的,只要保证实际传入的类型能够有效的转化成bool类型的,不然filter(i)是没法放到 if判断中的。
由此可见:混合使用泛型和匿名代理是可以写出很精简的代码,当然这也往往意味着需要写更多的注释来说明你的意图。 









本文转自 xchsp 51CTO博客,原文链接:http://blog.51cto.com/freebird/490291,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章
最新文章
相关文章