本文隶属于专题系列: LINQ学习系列

写在前面

上篇文章介绍了Lambda的基本概念以及匿名方法,本篇继续介绍Lambda的一些内容,既然学了,就要总结的全面一点。

带有标准查询运算符的Lambda

什么事标准查询运算符?

“标准查询运算符”是组成语言集成查询 (LINQ) 模式的方法。 大多数这些方法都在序列上运行,其中的序列是一个对象,其类型实现了 IEnumerable<T> 接口或 IQueryable<T> 接口。 标准查询运算符提供了包括筛选、投影、聚合、排序等功能在内的查询功能。共有两组 LINQ 标准查询运算符,一组在类型为 IEnumerable<T> 的对象上运行,另一组在类型为 IQueryable<T> 的对象上运行。 构成每组运算符的方法分别是 Enumerable 和 Queryable 类的静态成员。 这些方法被定义为作为方法运行目标的类型的“扩展方法”。 这意味着可以使用静态方法语法或实例方法语法来调用它们。此外,许多标准查询运算符方法运行所针对的类型不是基于 IEnumerable<T> 或 IQueryable<T> 的类型。 Enumerable 类型定义两个此类方法,这些方法都在类型为 IEnumerable 的对象上运行。 利用这些方法(Cast<TResult>(IEnumerable) 和 OfType<TResult>(IEnumerable)),您将能够在 LINQ 模式中查询非参数化或非泛型集合。 这些方法通过创建一个强类型的对象集合来实现这一点。 Queryable 类定义两个类似的方法(Cast<TResult>(IQueryable) 和 OfType<TResult>(IQueryable)),这些方法在类型为 Queryable 的对象上运行。各个标准查询运算符在执行时间上有所不同,具体情况取决于它们是返回单一值还是值序列。 返回单一值的方法(例如 Average 和 Sum)会立即执行。 返回序列的方法会延迟查询执行,并返回一个可枚举的对象。对于在内存中集合上运行的方法(即扩展 IEnumerable<T> 的那些方法),返回的可枚举对象将捕获传递到方法的参数。 在枚举该对象时,将使用查询运算符的逻辑,并返回查询结果。与之相反,扩展 IQueryable<T> 的方法不会实现任何查询行为,但会生成一个表示要执行的查询的表达式树。 查询处理由源 IQueryable<T> 对象处理。可以在一个查询中将对查询方法的调用链接在一起,这就使得查询的复杂性可能会变得不确定。

来自:http://msdn.microsoft.com/zh-cn/library/bb397896.aspx

多数标准查询运算符都有输入参数,其类型是17个.net泛型委托Func<T,TResult>中的一种。

比如:

 1         //
 2         // 摘要: 
 3         //     返回一个数字,表示在指定的序列中满足条件的元素数量。
 4         //
 5         // 参数: 
 6         //   source:
 7         //     包含要测试和计数的元素的序列。
 8         //
 9         //   predicate:
10         //     用于测试每个元素是否满足条件的函数。
11         //
12         // 类型参数: 
13         //   TSource:
14         //     source 中的元素的类型。
15         //
16         // 返回结果: 
17         //     一个数字,表示序列中满足谓词函数条件的元素数量。
18         //
19         // 异常: 
20         //   System.ArgumentNullException:
21         //     source 或 predicate 为 null。
22         //
23         //   System.OverflowException:
24         //     source 中的元素数量大于 System.Int32.MaxValue。
25         public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);

从上面的代码中可以看出Count方法扩展自IEnumerable<TSource>,并且有输入参数Func<TSource, bool> predicate。

一个例子

1.判断输入参数是否大于5,调用myFunc(4),如果大于5返回true,否则返回false。

2.输入一个int类型的整数,并输入一个string类型的字符串,判断拼接后的字符串是否为空,并返回bool类型的结果。

1             //其中 int 是输入参数,bool 是返回值 返回值始终在最后一个类型参数中指定
2             Func<int, bool> myFunc = x => x > 5;
3             bool result = myFunc(4);
4             //其中 int string是输入参数,bool 是返回值 返回值始终在最后一个类型参数中指定
5             //上篇文章中已经指出,在有多个输入参数的情况下,必须使用括号,输入参数以逗号隔开
6             Func<int, string, bool> myFunc2 = (x, y) => string.IsNullOrEmpty(x.ToString() + y);

当参数类型为 Expression<Func> 时,也可以提供 Lambda 表达式,例如在 System.Linq.Queryable 内定义的标准查询运算符中, 如果指定 Expression<Func> 参数,lambda 将编译为表达式目录树。

一个例子

此处列举一个标准查询运算符,Count 方法:

1            //一个整数数组
2             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
3             //计算整数数组中奇数的个数
4             int oddNumbers = numbers.Count(n => n % 2 == 1);
5             Console.WriteLine(oddNumbers);

 在这里你会发现,n直接使用n%2,编译器将推断n的类型为整型。

从上面的定义及例子,发现标准查询运算符,有这样的特点:1,查询什么(集合或者数组,集合和数组有什么特点?要么实现了IEnumerable<T> 接口,要么IQueryable<T> 接口)。

Lambda中类型推断

在编写 lambda 时,通常不必为输入参数指定类型,因为编译器可以根据 lambda 主体、参数的委托类型以及 C# 语言规范中描述的其他因素来推断类型。 对于大多数标准查询运算符,第一个输入是源序列中的元素类型。 因此,如果要查询 IEnumerable<Customer>,则输入变量将被推断为 Customer 对象,这意味着你可以访问其方法和属性:

1 customers.Where(c => c.City == "London");

Lambda的一般规则:

Lambda 包含的参数数量必须与委托类型包含的参数数量相同。Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。Lambda 的返回值(如果有)必须能够隐式转换为委托的返回类型。

Lambda表达式中变量作用域

lambda表达式中变量的作用域在定义 lambda 函数的方法内或包含 lambda 表达式的类型内,lambda 可以引用范围内的外部变量。 以这种方式捕获的变量将进行存储以备在 lambda 表达式中使用,即使在其他情况下,这些变量将超出范围并进行垃圾回收。 必须明确地分配外部变量,然后才能在 lambda 表达式中使用该变量。

一个例子

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading;
 6 using System.Threading.Tasks;
 7 
 8 namespace Wolfy.LinqDemo
 9 {
10     delegate bool D();
11     delegate bool D2(int i);
12 
13     class Program
14     {
15         static D del;
16         static D2 del2;
17         static void Main(string[] args)
18         {
19             //调用TestMethod方法
20             TestMethod(5);
21             // Prove that del2 still has a copy of
22             // local variable j from TestMethod.
23             //证明del2仍保留方法TestMethod中变量j的副本。
24             bool result = del2(10);
25             //输出true
26             Console.WriteLine(result);
27             Console.ReadKey();
28         }
29         static void TestMethod(int input)
30         {
31             int j = 0;
32             // 使用lambda表达式初始化del.
33             // Note access to 2 outer variables.
34             // del will be invoked within this method(del将在这个方法内部执行).
35             del = () => { j = 10; return j > input; };
36             // del2 will be invoked after TestMethod goes out of scope.
37             //del2将在TestMethod外部执行。
38             del2 = (x) => { return x == j; };
39             // Demonstrate value of j:
40             //展示j的值
41             // Output: j = 0 
42             //输出j=0
43             // The delegate has not been invoked yet.
44             //委托仍没有执行
45             Console.WriteLine("j = {0}", j);      
46             // Invoke the delegate.
47             //委托执行
48             bool boolResult = del();
49             // Output: j = 10 b = True
50             //输出j=10 b=True
51             Console.WriteLine("j = {0}. b = {1}", j, boolResult);
52         }
53 
54     }
55 }

在执行TestMethod中的以下代码时:

1             // Invoke the delegate.
2             //委托执行
3             bool boolResult = del();
4             // Output: j = 10 b = True
5             //输出j=10 b=True
6             Console.WriteLine("j = {0}. b = {1}", j, boolResult);

 调用del()修改了j的值为10,在Main方法中调用del2(10),此时仍保留方法TestMehod中j的副本。所以此时输出为:

适用于 lambda 表达式中的变量范围的规则

捕获的变量将不会被作为垃圾回收,直至引用变量的委托符合垃圾回收的条件。在外部方法中看不到 lambda 表达式内引入的变量。Lambda 表达式无法从封闭方法中直接捕获 ref 或 out 参数。Lambda 表达式中的返回语句不会导致封闭方法返回。如果跳转语句的目标在块外部,则 lambda 表达式不能包含位于 lambda 函数内部的 goto 语句、break 语句或 continue 语句。 同样,如果目标在块内部,则在 lambda 函数块外部使用跳转语句也是错误的。

异步Lambda

通过使用 async 和 await 关键字,你可以轻松创建包含异步处理的 lambda 表达式和语句。

一个例子

在winform的单击事件,异步的方式调用方法ExampleMethodAsync。

1        private async void button1_Click(object sender, EventArgs e)
2         {
3             await ExampleMethodAsync();
4         }
5         async Task ExampleMethodAsync()
6         {
7             // 下面模拟一个任务返回的异步进程。
8             await Task.Delay(1000);
9         }

 如果使用异步Lambda,你可以这样写,注意在lambda前加上async关键字。

1  button1.Click += async (sender, e) =>
2         {
3             await ExampleMethodAsync();
4         };
5   async Task ExampleMethodAsync()
6     {
7         await Task.Delay(1000);
8     }

 看上去更简洁。 

总结

本篇文章介绍了lambda标准查询运算符,变量范围,类型推断,异步等概念。其他的还好理解,唯有变量范围太绕了,也只有做个记录慢慢体会了。

参考文章

http://msdn.microsoft.com/zh-cn/library/bb397896.aspx

http://msdn.microsoft.com/zh-cn/library/bb397687.aspx

你可能感兴趣的内容
Linq之Lambda表达式初步认识 收藏,1950 浏览
0条评论

dexcoder

这家伙太懒了 <( ̄ ﹌  ̄)>
Owner