此文章非原创,转载自诗人江湖老,原文地址

　　在Git上下载源码
　　在工程中我们少不了要定义类或者结构去储存数据，这些数据将被临时地储存在内存中，现在我们想要对其完成一些类似于查找、过滤等等常见的任务的时候，我们该如何去做呢？
　　我们可以自己写代码去对集合中的每个对象进行遍历，检查变量的每个字段看其是否满足条件。这样的故事已经发生太多次了，微软怎么可能容忍在C#里发生如此弱智的事情呢？于是，C#的设计者决定在C#中集成查询的语法，以最大限度地减少程序员书写类似代码的情况。
　　这也就是我们说的LINQ(Language Intergated Query)也就是语言集成查询，我们可以使用同样的语法访问不同的数据源。

为什么要使用LINQ？

　　几乎所有的应用程序都需要对数据进行处理，大部分的程序都通过自定义的逻辑来完成这些操作。这样做的弊端之意就是，代码逻辑将会跟它处理的数据的结构紧密耦合在一起，如果数据结构发生了改变，也许将会带来海量的代码改动。
　　为了解决这个问题，C#将这些处理数据的代码都抽象出来，提供给了广大开发者。这就是LINQ。
　　LINQ的语法类似于关系和分层查询语言(SQL和XQuery)，我们可以在不更改查询代码的情况下对数据结构进行更改。LINQ比之SQL要更加灵活，可以处理更广泛的逻辑数据结构。当然，这些数据结构都需要实现了IEnumerable或者IEnumerable< T >接口，才可以进行LINQ查询。

LINQ查询表达式语法详解

表达式基础语法

　　LINQ查询表达式以from子句开始，以select或者group子句结束。在这两个子句之间可以跟零个或者多个from、let、where、join或者orderby子句。
　　每个from子句都是一个生成器，该生成器将引入一个包括序列(Sequence)的元素的范围变量(range variable)。每个let子句都会引入一个范围变量，以表示通过前一个范围变量计算的值。每个where子句都是一个筛选器，用于从结果中排除项。每个join子句都将指定的源序列键与其他序列的键进行比较，以产生匹配对。每个orderby子句都会根据指定的条件对各项进行重新排序。而最后的select或者group子句根据范围变量来指定结果的表现形式。最后可以使用into子句来连接查询，将某一查询结果的视为后续查询的生成器。

标准查询操作符

　　在了解LINQ查询表达式之前，怎么能不了解下它的查询操作符呢？下面列表列出了LINQ定义的标准查询操作符。

表1:LINQ标准查询操作符

设置案例背景

　　假设我们有4个类，Customer，Order，Detail，Product，它们的定义如下：

　　假设现在它们各自有一个List集合，分别为Customers，Orders，Details，Products。我们在这基础之上来一步步阐述LINQ查询表达式。
　　customers数据：

　　
　　orders数据：

　　
　　details数据：

　　
　　products数据：

Demo查询表达式

条件筛选

　　使用where子句，可以按照一个或者多个条件筛选集合，where子句的表达式的结果类型应该是布尔类型。
　　筛选在北京且名称以‘小’开头的顾客。

var query = from c in customerswhere c.City == "北京" && c.Name.StartsWith("小")select c;
foreach (Customer item in query)
{Console.WriteLine(item.Name + "\t\t" + item.City);
}
Console.ReadKey();

　　该LINQ查询会返回在北京而且名字以“小”开头的Customer集合。
　　输出结果：
　　
　　

复合from子句筛选

　　当需要根绝对象的一个成员进行筛选，而该成员本身是一个集合或者列表，就可以使用复合的from子句。
　　筛选订单数量大于800的信息。

var query = from c in customersfrom o in c.Ordersfrom d in o.Detailswhere d.Quantity > 800select new { Name = c.Name, Total = d.UnitPrice * d.Quantity };foreach (var item in query)
{Console.WriteLine(item.Name + "\t\t" + item.Total);
}
Console.ReadKey();

　　输出结果：
　　
　　

排序

　　要对序列排序，需要使用orderby子句。
　　按照城市、顾客ID进行排序。　

var query = from c in customersfrom o in c.Ordersorderby c.City, o.CustomerIDselect new { Name = c.Name, City = c.City, OrderID = o.OrderID };foreach (var item in query)
{Console.WriteLine(item.Name + "\t\t" + item.City + "\t\t" + item.OrderID);
}
Console.ReadKey();

　　输出结果：
　　
　　　　

分组

　　要根木一个关键值对查询结果分组，可以使用group子句。
　　统计各个产品的订单数量。　　

var query = from d in detailsgroup d by d.ProductID into gorderby g.Count(), g.Keyselect new { Name = g.Key, Count = g.Count() };
Console.WriteLine("ProductID"+ "\t" + "Count");
foreach (var item in query)
{Console.WriteLine(item.Name + "\t\t" + item.Count);
}
Console.ReadKey();

　　输出结果：
　　
　　

对嵌套的对象分组

　　如果分组的对象包含嵌套的序列，则各个改变select子句创建的匿名类型。
　　统计各个产品的订单数量，并输出各个订单的订货数量。

var query = from d in detailsgroup d by d.ProductID into gorderby g.Count(), g.Keyselect new{Name = g.Key,Count = g.Count(),Quantity =  from d in gorderby d.Quantityselect d.Quantity};Console.WriteLine("ProductID"+"\t"+"Count"+"\t"+"Quantity");
foreach (var item in query)
{Console.Write(item.Name + "\t\t" + item.Count+"\t");foreach (var quantity in item.Quantity){Console.Write("{0};", quantity);}Console.WriteLine();
}
Console.ReadKey();

　　输出结果：
　　
　　

连接

　　使用join子句可以根据特定的条件合并两个数据源，但之前要获得两个要连接的列表。
　　统计各个顾客和其订单的信息。

var query = from r infrom c in customersfrom o in c.Ordersfrom d in o.Detailsselect new { Name = c.Name, City = c.City, Money = d.Quantity * d.UnitPrice, ProductID = d.ProductID }join t infrom p in productsselect pon r.ProductID equals t.ProductIDselect new { Name = r.Name, City = r.City, Money = r.Money, ProductName = t.ProductName };
Console.WriteLine("Name" + "\t" + "City" + "\t" + "Money" + "\t" + "ProductName");
foreach (var item in query)
{Console.WriteLine(item.Name + "\t" + item.City + "\t" + item.Money + "\t" + item.ProductName);
}
Console.ReadKey();

　　输出结果：
　　
　　　　

聚合操作符

　　聚合操作符（包括Count()、Sum()、Min()、Max()、Average()和Aggregate()）它们不返回一个序列，而是返回一个值。
　　Count()方法返回集合中的项数；Sum()方法汇总序列中所有数字，返回这些数字的和；Min()方法返回集合中的最小值；Max()方法返回集合中的最大值；Average()方法计算集合中的平均值；Aggregate()方法，可以传递一个Lambda表达式，该表达式对所有的值进行聚合。
　　这些方法的使用方式类似，都是直接对序列或者集合进行操作。下面用Sum()做一个示例：
　　统计各个顾客总共订单的订货数量。

var query = from r infrom c in customersselect new{Name = c.Name,OrderCount = (  from o in c.Ordersfrom d in o.Detailsselect d.Quantity).Sum()}orderby r.OrderCountselect r;

　　输出结果：
　　

使用扩展方法和Lambda表达式简化LINQ查询

什么是扩展方法

　　当方法的第一个形参包含this修饰符的时候，该方法称为扩展方法。扩展方法只能在非泛型、非嵌套的静态类中声明，扩展方法的第一个形参不能带有除this之外的其他任何修饰符，而且形参类型不能是指针类型。
　　下面的程序是一个扩展方法的示例：

public static class Extensions
{public static void HelloWorld(this string str){Console.WriteLine("{0} 调用了：HellWorld",str);}
}

　　现在就可以调用该方法了:

string str="Jay";
str.HelloWorld();

　　我们可以看到，控制台中输出了“Jay 调用了：HelloWorld”。
　　之所以这样，是因为HelloWorld第一个参数类型为string类型，因此该方法就是string类型的扩展方法，所有的string类型变量都可以调用，而变量的内容就是传递给HelloWorld的参数。
　　上面的程序和下面的代码结果一样：

string str = "Jay";
Extensions.HelloWorld(str);

LINQ扩展方法

　　LINQ为IEnumerable<T>接口提供了各种扩展方法，以便用户在实现了该接口的任意集合上使用LINQ查询。表1中列出的LINQ查询操作符，都有相应的扩展方法实现。
　　使用扩展方法可以和使用LINQ查询表达式获得十分类似甚至是相同的结果，当扩展方法和Lambda表达式结合的时候，会大大简化LINQ查询。
　　

简化LINQ查询

　　前面一节的条件筛选LINQ表达式可以简化为：

var query = customers.Where(c => c.City == "北京" && c.Name.StartsWith("小")).Select(c => c);
1

　　
　　前面一节的条件复合from子句筛选LINQ表达式可以简化为：

var query = customers.SelectMany(c => c.Orders, (c, o) => new { _customer = c, _order = o, _detail = o.Details }).SelectMany(a => a._detail, (a, b) => new { _var = a, Total = b.Quantity * b.UnitPrice, Quantity = b.Quantity }).Where(_nameless => _nameless.Quantity > 800).Select(_annonymous => new { Name = _annonymous._var._customer.Name, Total = _annonymous.Total });
1

　　
　　前面一节的排序LINQ表达式可以简化为：

var query = customers.SelectMany(c => c.Orders, (c, o) => new { _customer = c, _order = o }).OrderBy(_var => _var._customer.City).ThenBy(_var => _var._order.CustomerID).Select(_annonymous => new { Name = _annonymous._customer.Name, City = _annonymous._customer.City, OrderID = _annonymous._order.OrderID });
1

　　
　　前面一节的分组LINQ表达式可以简化为：

var query = details.GroupBy(d => d.ProductID).OrderBy(g => g.Count()).ThenBy(g => g.Key).Select(g => new { Name = g.Key, Count = g.Count() });
1

　　
　　前面一节的对嵌套的对象分组LINQ表达式可以简化为：

var query = details.GroupBy(d => d.ProductID).OrderBy(g => g.Count()).ThenBy(g => g.Key).Select(_var => new { Name = _var.Key, Count = _var.Count(), Quantity = _var.OrderBy(d => d.Quantity).Select(d => d.Quantity) });
1

　　前面一节的连接LINQ表达式可以简化为：

var query = customers.SelectMany(c => c.Orders, (c, o) => new { Name = c.Name, City = c.City, Details = o.Details }).SelectMany(_var => _var.Details, (_var, _detail) => new { Name = _var.Name, City = _var.City, Money = _detail.Quantity * _detail.UnitPrice, ProductID = _detail.ProductID }).Join(products, a => a.ProductID, b => b.ProductID, (a, b) => new { Name = a.Name, City = a.City, Money = a.Money, ProductName = b.ProductName });
1

　　
　　前面一节的聚合操作LINQ表达式可以简化为：

var query = customers.Select(c => new { Name = c.Name, OrderCount = c.Orders.SelectMany(o => o.Details, (o, d) => new { _Quantity = d.Quantity }).Select(_var => _var._Quantity).Sum() }).OrderBy(_var => _var.OrderCount);
1

　　以上利用扩展方法和Lambda表达式的简化后的LINQ查询代码的查询结果，与LINQ查询表达式结果完全一样，证明这样是完全可行的。
　　唯一的问题就是代码看起来比较费解了。

LINQ查询表达式简化转换原则

　　看到这里我们可能要奇怪，为什么我们能用这样的方式来简化LINQ查询表达式呢？
　　关于这个问题，我们将在下一篇文章进行详细讲解。
　　欢迎大家点击阅读。
　　本人还是菜鸟，写的不对的地方还请各位不吝赐教！