Lambda表达式和查询表达式(1)基本概念

标签：des   style   blog   io   os   使用   ar   for   strong   

Lambda表达式也是一种匿名函数（anonymous function），比匿名方法具有更加简洁的表示形式。它可以包含表达式和语句，并且适用于创建委托和事件。

查询表达式: 是一种使用查询语法表示的表达式，它可以从一个或多个给定的数据源中检索数据，并制定检索结果的表现形式。

Lambda表达式:  由输入参数、Lambda运算符和表达式（或语句块）构成。

它的语法形式如下:

(input parameters) => empression;
  : input parameters : 表示输入参数，它是可选的；  
  : “=>”  为Lambda运算符（读作goes to）；
  : empression : 表示表达式或语句块。

【示例1-1】

m => m * m; 

分析： Lambda表达式计算给定参数m的平方，并返回计算结果。

【示例1-2】 并获取该表达式的值。

int n = (int m) => m * m;   

分析：Lambda表达式计算给定输入参数m的平方，并返回计算结果。 结果将保存为n变量。

1 输入参数:

在Lambda表达式中，输入参数是Lambda运算符的左边部分。它包含参数的数量可以为0、1或者多个。

当输入参数为1时，Lambda表达式左边的一对小括弧才可以省略。

当参数的数量大于或等于2时，Lambda表达式左边的一对小括弧中的多个参数之间使用逗号（,）分隔。

【示例1-3】 它的输入参数的数量为0

() => Console.WritleLine("This is a Lambda empression.");

 分析：由于上述Lambda表达式的输入参数的数量为0，因此，该Lambda表达式的左边部分的一对小括弧不能被省略。

【示例1-4】 它的输入参数包含一个参数：m。该表达式将计算m参数与2的乘积。

m => m * 2;

 分析：上述Lambda表达式的输入参数省略了一对小括弧，它与“(m) => m * 2;” Lambda表达式是等效的。

【示例1-5】 它的输入参数包含两个参数：m和n。该表达式将计算m和n参数的乘积。

(m,n) => m * n; 

表达式或语句块:

Lambda语句块: 多个Lambda表达式构成。

语句块放到运算符的右边，作为Lambda的主体。根据主体不同，Lambda表达式可以分为 表达式Lambda和 语句Lambda。

语句块中可以包含多条语句，并且可以包括循环、方法调用和if语句等。

【示例1-6】 它的右边部分是一个表达式。该表达式计算m参数的平方值。

m => m * m; 

如果Lambda表达式的右边部分是一个语句块，那么该语句块必须被“{”和“}”包围。
【示例1-7】  它的输入参数包括两个参数：m和n。该表达式的右边包含2个表达式：

第一个表达式计算m和n参数的乘积，结果保存为result变量；

第二个表达式显示result变量的值。

(m,n) => { int result = m * n; Console.WritleLine(result); } 

 分析：上述Lambda表达式的右边部分包含2个表达式，因此，该表达式的右边部分必须被“{”和“}”包围。

查询表达式:

查询表达式: 是一种使用查询语法表示的表达式，它用于查询和转换来自任意支持LINQ的数据源中的数据。

查询表达式: 使用许多常见的C#语言构造，易读简洁，容易掌握。它由一组类似于SQL或XQuery的声明性语法编写的子句组成。

每一个子句可以包含一个或多个C#表达式，这些C#表达式本身也可能是查询表达式或包含查询表达式。

查询表达式: 必须以from子句开头，以select或group子句结束。在第一个from子句和最后一个select子句或group子句之间，

可包含一个或多个where子句、let子句、join子句、orderby子句和group子句，

可是from子句。它包括8个基本子句，具体说明如下所示。
from子句：   指定查询操作的数据源和范围变量。
select子句： 指定查询结果的类型和表现形式。
where子句： 指定筛选元素的逻辑条件。
let子句     ： 引入用来临时保存查询表达式中的子表达式结果的范围变量。
orderby子句： 对查询结果进行排序操作，包括升序和降序。
group子句： 对查询结果进行分组。
into子句：  提供一个临时标识符。 join子句、group子句或select子句可以通过该标识符引用查询操作中的中间结果。
join子句：   连接多个用于查询操作的数据源。

【示例1-8】该查询表达式查询arr数组中的每一个元素。

int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
var query1 = from n in arr   select n; 

【示例1-9】该查询表达式查询arr数组中大于6的元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query2 = from n in arr  where n > 6 select n; 

注意：示例1-8的query1或示例1-9中的query2变量只是保存查询操作，而不是查询的结果。

当查询表达式执行查询操作时，才会计算该查询表达式的结果。query1和query2变量的类型都属于集合类型。

from子句:

from子句用来指定查询表达式的数据源和范围变量。它是查询表达式的必有部分，并且它出现在最开始。

数据源: 不但可以包括查询本身的数据源，而且还可以包括子查询的数据源。范围变量用来表示数据源序列中的每一个元素。

注意： from子句指定的数据源的类型必须为IEnumerable、IEnumerable<T>或一种派生类型。

【示例1-10】 该查询表达式查询arr数组中的每一个元素。

在query查询表达式中，arr数组为数据源，n为范围变量。n范围变量的类型为arr数据源的元素类型。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query = from n in arr  select n;       

下面我们来学习数据源和包含不同的from子句查询表达式:

1．数据源 数据源指定数据的来源，

它的形式可以为静态数组、动态数组（ArrayList）、集合、数据集（DataSet）、数据表、MML片段、MML文件等。

如果数据源实现了IEnumerable<T>接口，那么编译器可以推断范围变量的类型为其元素类型。

例如，数据源的类型为IEnumerable<UserInfo>，那么可以推断出范围变量的类型为UserInfo。

【示例1-11】下面创建一个查询表达式query。

该查询表达式查询list泛型数组中的每一个元素。list泛型数组为数据源，u为范围变量。u范围变量的类型为list数据源的元素类型（UserInfo）。

List<UserInfo> list = …       //其初始化代码已经省略 
var query = from u in list    //查询list泛型列表中的每一个元素              
            select u; 

如果当数据源是非泛型IEnumerable类型（如ArrayList等）时，需要显式指定范围变量的类型。

【示例1-12】查询list数组中的每一个元素。list数组为数据源，u为范围变量。u范围变量的类型被指定为list数据源的元素类型（UserInfo）。

ArrayList list = new ArrayList();
list.Add(…);                                         //添加UserInfo类的实例，
代码已经省略 …                                     //其初始化代码已经省略 
var query = from UserInfo u in list        //查询list泛型列表中的每一个元素              
select u;

 2．包含单个from子句的查询表达式

在查询表达式中，from子句至少有一个。当from子句只有一个时，构成的查询表达式被称为包含单个from子句的查询表达式。

一般地，包含单个from子句的查询表达式只包含一个数据源。

【示例1-13】该查询表达式查询arr数组中的每一个元素，它就是一个包含单个from子句的查询表达式。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr               
            select n; //创建一个查询表达式query

3．包含多个from子句的查询表达式，当from子句有两个或两个以上时，构成的查询表达式被称为包含多个from子句的查询表达式。

【示例1-14】该查询表达式包含两个from子句

它们分别查询两个独立的数据源：arr1数组和arr2数组。最后，使用select子句计算当前元素的和。

int[] arr1 = new int[]{0,1,2,3,4,5,6,7,8,9};
int[] arr2 = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from a in arr1   from b in arr2   select a + b;    //包含多个from子句的查询表达式

 4．包含复合from子句的查询表达式
在查询表达式中，有可能查询表达式的数据源中的每一个元素本身也作为该查询表达式的数据源。

那么要查询数据源中的每一个元素中的元素，则需要使用复合from子句。复合from子句类似于嵌套的foreach语句。

【示例1-15】下面创建一个名称为Test的类，

该类包含两个字段：Name和AliasName。

Name字段的类型为string，

AliasName字段的类型为string类型列表。因此，它也可以作为子查询表达式的数据源。

public class Test         
{            
   public string Name;  //名称            
   public List<string> AliasName;       //别名列表        
}

【示例1-16】下面创建一个查询表达式query。该查询表达式包含了一个复合from子句：

第一个from子句查询list泛型集合；

第二个from子句查询list集合中元素的AliasName字段，为第一个from子句的子查询。

最后，使用select子句将u变量的Name属性的值和name变量的值拼接为一个字符串。

List<MUserInfo> list = …                //其初始化代码已经省略 
var query = from u in list              //查询list泛型列表              
            from name in u.AliasName   //查询每一个元素的AliasName属性的值               
            select u.Name + name;

select子句:

select子句用来指定将在执行查询时产生的值的类型。查询表达式必须以select子句或group子句结束。
【示例1-17】该查询表达式查询arr数组中的每一个元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query = from n in arr
            select n;

【示例1-18】该查询表达式查询arr数组中的每一个元素和10的乘积。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr select n * 10;

分析：select子句中的“n * 10”表达式决定了查询结果的表现形式，即计算每一个元素和10的乘积。

【示例1-19】该查询表达式查询arr数组中的每一个元素，查询结果是一个对象的集合。

该对象包含两个属性：ID和Name，它在select子句中由匿名对象初始化器创建。

每一个对象的ID属性的值是当前元素的值、Name属性的值为元素的值的字符串表现形式。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr              
            select new { ID = n, Name = n.ToString()    };                         

分析：“new {ID = n,Name = n.ToString()}”是一个匿名对象初始化，它将创建一个匿名类型的对象。

where子句:

用来指导将在查询表达式中返回数据源中的哪些元素。它将一个布尔条件应用于数据源中的每个元素，并返回指定条件的元素。

查询表达式可以包含一个或多个where子句。

【示例1-20】该查询表达式从arr数组中查询小于3的元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr   where n < 3    select n;

分析：上述where子句只包含一个布尔表达式“n < 3”，该表达式将筛选小于3的元素。

在一个where子句中，也可以包含多个布尔表达式，各个表达式直接使用逻辑运算符（如&&和||）分隔。
【示例1-21】该查询表达式从arr数组中查询大于3且小于6的元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query = from n in arr
            where n > 3 && n < 6
            select n;

分析：上述where子句包含两个布尔表达式“n > 3”和“n < 6”，它们共同指定将筛选大于3且小于6的元素。这两个布尔表达式使用&&运算符联接，即计算这两个布尔表达式的逻辑与。
where子句不但可以包含布尔表达式，而且还可以包含返回布尔值的方法。

【示例1-22】该查询表达式从arr数组中查询为偶数的元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
private bool IsEven(int i) //判断i参数是否为偶数.如果是，则返回true，否则返回false 
{
  return i % 2 == 0 ? true : false; 
} 
var query = from n in arr   where IsEven(n)  select n;

 分析：上述where子句包含一个返回布尔值的方法“IsEven(int i)”。该方法判定元素是否为偶数。如果是，则返回true，否则返回false。

 let子句:

let子句用来创建一个新的范围变量，它用于存储子表达式的结果。

let子句使用编程者提供的表达式的结果初始化该变量。一旦初始化了该范围变量的值，它就不能用于存储其他的值。

【示例18-23】 该查询表达式从arr数组中查询为偶数的元素。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query = from n in arr  let isEven = return n % 2 == 0 ? true : false   //判断n元素是否为偶数。
            where isEven  
            select n; 

 分析：

“return n % 2 == 0 ? true : false” 表达式判断n元素是否为偶数。如果是，则返回true，否则返回false。

“let isEven = return n % 2 == 0 ? true : false”表达式使用let子句创建新的范围变量isEven，用来保存“return n % 2 == 0 ? true : false”表达式的结果。

“where isEven” 表达式使用where子句筛选isEven的值为true的元素。

orderby子句:

orderby子句可使返回的查询结果按升序或者降序排序。升序由关键字ascending指定，而降序由关键字descending指定。
注意：orderby子句默认排序方式为升序。

【示例1-24】 该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n元素对查询结果进行降序排序。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr where n > 1 && n < 6 orderby n descending select n;      

 //创建一个查询表达式query orderby子句可以包含一个或多个排序表达式，各个排序表达式使用逗号（,）分隔。

【示例1-25】

该查询表达式从arr数组中查询大于1且小于6的元素，它使用orderby子句对查询结果进行排序，且包含两个排序关键字，

具体说明如下所示。

n % 2：按照升序排序； n：按照降序排序。 ?

注意：n % 2排序关键字优先级大于n排序关键字。

因此，该查询表达式的结果首先按照n % 2排序关键字升序排序，然后再按照n排序关键字降序排序。

分析：在“orderby n % 2 ascending,n descending”表达式中，第一个排序关键字后的“ascending”可以省略。因为默认排序方式为升序。

group子句:

group子句用来将查询结果分组，并返回一对象序列。这些对象包含零个或更多个与改组的Key值匹配的项，还可以使用group子句结束查询表达式。
注意：每一个分组都不是单个元素，而是一个序列（也属于集合）。

【示例1-26】该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n % 2表达式的值对查询结果进行分组。

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr    where n > 1 && n < 6    group n by n % 2;   

 分析：

query查询表达式的结果是一个序列（类型为IEnumerable<IGrouping<int,int>>），

该序列的元素类型为IGrouping<int,int>。其实，该查询结果中的元素也是一个序列。

【示例1-27】下面使用两个foreach语句显示query查询表达式结果中每一个元素的值。

foreach(var g in query)        //查询query中的元素，该元素也是一个序列，类型为IGrouping<int,int> 
{    
   foreach(var o in g)         //查询每一个分组中的元素，该元素的类型int     
    {        
         Console.WriteLine(o); //显示元素的值     
    }
} ?

注意：使用group子句对查询结果分组后，每一个分组都存在一个键（由Key属性表示）。

通过Key属性可以获取每一个分组的键的值。

into子句:

into子句可以用来创建一个临时标识符，将group、join或select子句的结果存储到这个标识符中。

【示例18-29】该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n % 2表达式的值对查询结果进行分组。

该查询表达式的具体说明如下所示。

where n > 1 && n < 6：     指定筛选大于1且小于6的元素。 
group n by n % 2 into g：  按照n % 2表达式的值对查询结果进行分组，并使用into子句创建临时标识符g。该临时标识符临时保存分组结果。 
from sn in g：             从g标识符指定的每一个分组中查询sn元素。 
select sn：                表示查询sn元素。 

int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9}; 
var query = from n in arr where n > 1 && n < 6   group n by n % 2 into g  from sn in g select sn;          

//创建一个查询表达式query 分析：上述查询表达式的查询结果包括4个元素，依次为2、4、3和5。

join子句:  join子句用来联接两个数据源，即设置两个数据源之间的关系。

3种常见联接方式。
内部联接： 类似于SQL语句中的inner join子句。
分组联接：  包含into子句的join子句。
左外部联接：类似于SQL语句中的left join子句。

1．内部联接:  join子句的内部联接要求两个数据源都必须存在相同的值，即两个数据源都必须存在满足联接关系的元素。

【示例1-30】该查询表达式使用join子句联接了arra和arrb数组，

具体说明如下。

创建arra数组，它包含10个元素（0～9）。 
创建arrb数组，它包含5个元素（0、2、4、6和8）。 
创建query查询

from a in arra：   从arra数组中选择元素，并表示为a。
where a < 7：      从arra数组中选择小于7的元素。 
join b in arrb on a equals b：将arra和arrb数组进行联接，同时满足a和b相等的条件。其中，b元素是arrb数组中的元素。 

select a：选择a元素。
int[] arra = new int[]{0,1,2,3,4,5,6,7,8,9};
int[] arrb = new int[]{0,2,4,6,8}; 
var query = from a in arra where a < 7  join b in arrb on a equals b select a;  

分析：上述查询表达式首先选择小于7的元素（包括0～6），然后再和arrb数组进行联接，并获取既包含在{0,1,2,3,4,5,6}集合中、又包含在arrb数组中的元素。最终，查询表达式的结果包含4个元素（0、2、4和6）。

2．分组联接: join子句的分组连接包含into子句的join子句的联接。它将左数据源与右数据源的元素依次匹配。左数据源的所有元素都出现在查询结果中。若在右数据源中找到匹配项，则使用匹配的数据，否则用空表示。
【示例1-31】下面创建一个查询表达式query。该查询表达式使用join子句联接arra和arrb数组，

具体说明如下：

创建arra数组，它包含10个元素（0～9）。
创建arrb数组，它包含5个元素（0、2、4、6和8）。
创建query查询。
from a in arra：   从arra数组中选择元素，并表示为a。
where a < 7：      从arra数组中选择小于7的元素。
 join b in arrb on a equals b into g：将arra和arrb数组进行联接，同时满足a和b相等的条件。最后，保存为g分组。其中，b元素是arrb数组中的元素。
select new{ID = a, Values = g}：

指定查询结果是一个对象集合: 包含两个属性： ID 和 Values，  它在select子句中由匿名对象初始化器创建。每一个对象的ID属性的值是当前元素的值、Value属性的值为g分组。

分析：上述查询表达式首先选择小于7的元素（包括0～6），然后再和arrb数组进行联接。最终，查询表达式的结果包含7个元素，

具体如下所示。

第1个元素：ID属性的值为0，Values属性的值为一个集合，该集合只包含一个元素0。

第2个元素：ID属性的值为1，Values属性的值为一个空集合。

第3个元素：ID属性的值为2，Values属性的值为一个集合，该集合只包含一个元素2。

第4个元素：ID属性的值为3，Values属性的值为一个空集合。

第5个元素：ID属性的值为4，Values属性的值为一个集合，该集合只包含一个元素4。

第6个元素：ID属性的值为5，Values属性的值为一个空集合。 第7个元素：ID属性的值为6，

Values属性的值为一个集合，该集合只包含一个元素6。

3．左外部联接: join子句的左外部联接将返回左侧数据源序列中的所有元素，就算它们在右侧序列中没有匹配的元素也是这样。
【示例1-32】该查询表达式使用join子句联接arra和arrb数组，

具体说明如下所示。

创建arra数组，它包含10个元素（0～9）。
创建arrb数组，它包含5个元素（0、2、4、6和8）。
创建query查询。
from a in arra：  从arra数组中选择元素，并表示为a。
where a < 7：     从arra数组中选择小于7的元素。
 join b in arrb on a equals b into g： 将arra和arrb数组进行联接，同时满足a和b相等的条件。最后，保存为g分组。其中，b元素是arrb数组中的元素。
select ab：         选择ab元素。

左数据源为: “from a in arra”和“where a < 7”产生的数据源，

右数据源为: arrb数组。

from ab in g.DefaultIfEmpty()： 查询g分组中的每一个元素。如果该分组不存在元素，则返回返回默认值。 ?

注意：如果序列（在此为g）为空，则DefaultIfEmpty()方法返回只包含一个元素的序列，该元素类型的值为默认值（在此为0）。

select ab：选择ab元素。

分析：上述查询表达式

首先选择小于7的元素（包括0～6），然后再和arrb数组进行左联接。该查询表达式的结果包含7个元素（与左数据源中元素的数量相等）。

如果g分组为空，则返回该分组的元素类型的默认值（0），否则返回该元素。

当左数据源中的元素的值为1、3和5时，g分组为空，此时，它将返回默认值0。

当左数据源中的元素的值为0、2、4和6时，g分组不为空。此时，它将返回该元素的值，分别为0、2、4和6。

最终，查询表达式的结果包含7个元素（0、0、2、0、4、0和6）。

Lambda表达式和查询表达式(1)基本概念

标签：des   style   blog   io   os   使用   ar   for   strong   

原文地址：http://www.cnblogs.com/liusj/p/4017296.html