LINQ, bridges the gap and strengthens the connection between relational data and the object-oriented world.
—Vidya Vrat Agarwal
《Beginning C# 2008 Database: From Novice to Professional》
引子
这是我在阅读《Pro LINQ in C# 2008》时，在书上所做注释的整理与汇总，同样地是作温故知新所用。
该书全面详尽地讲解了LINQ to Objects、LINQ to XML以及LINQ to SQL的内容，是本不错的书。
P13 OfType与Cast
遍历Collection中的项时，尽量使用OfType而不是Cast。这是鉴于Cast操作，会强行对Collection中的每一项进行强制的类型转换，期间可能会导致异常发生。而OfType则不同，它只会返回同类型的项而主动跳过非相同类型的项，从而避免了异常的发生。
var names = from name in arraylist.Cast<string> select name; var names = from name in arraylist.OfType<string> select name;
P14 Deferred Query
LINQ在其查询结果第一次被使用时才真正开始执行。因此LINQ作为延迟查询，具有“一次定义、反复使用、总是最新”等特点。
P23 筛选方法的三种实现方式
书中使用了一个从整数数组中筛选出奇数的例子，分别采取了如下三种语法方式实现。其本质都是将过滤方法抽象并独立出来，作为一个delegate传递给函数FilterArrayOfInt()，差异仅在于该delegate如何被实现。
// 使用命名方法 int[] result = Common.FilterArrayOfInt(nums, Application.IsOdd); // 使用匿名代理 int[] result = Common.FilterArrayOfInt(nums, delegate(int i){return ((i & 1)==1);}); // 使用lambda表达式 int[] result = Common.FilterArrayOfInt(nums, (i => ((i & 1)==1)));
lambda表达式，以=>为分界线，可以简单地理解为左边为参数，右半为方法实现与返回值。
P24 表达式树
接口IEnumerable<T> 与IQueryable<T>，是LINQ的核心接口。而序列、接口、方法，则是LINQ的三大要素。
IEnumerable<T> 的扩展方法总被直接编译为IL代码，而IQueryable<T>的扩展方法为了保证效率和复用，则被编译为lambda表达式。
// 区别在于两个实现的后半部分 public static IEnumerable<T> Where<T>( this IEnumerable<T> source, Func<T, bool> predicate); public static IQueryable<T> Where<T>( this IQueryable<T> source, System.Linq.Expressions.Expression<Func<int, bool>> predicate);
P25 关键字var
var 的出现，第一感觉是简化了代码录入，在声明变量时省去了冗长的类型名。细究后发现，var的主要作用在于声明匿名变量，提供泛类型化的访问支持和构造临时性对象更便捷的途径。特别是在LINQ环境下，LINQ语句返回的Collection，经常是临时性的，只作一时之用的。此时通过var构造的临时性对象便显得尤其重要了。
var unnamedtypeVariable = new {firstArg = 1, secondArg = "Joe"}; Console.WriteLine(unnamedtypeVariable.firstArg,'.', unnamedtypeVariable.secondArg); //---------------------- // 1.Joe
P30 扩展方法
问题的提出：static方法只能通过class来调用，从而限制了static方法的使用域。书中提到的情形是要查询若干不同类型的对象数目，于是这个Where方法是通过逐一修改所有的类并提供一个实例级的计数方法，亦或是新建一个静态类然后设计特别一个计数的策略？在SQL查询那样复杂的条件下，无论何种实现都显得极其的繁琐，于是提出了扩展方法的概念，在两种不同类之间自由地建立一个互通的桥梁，实现实例调用类的静态方法。
扩展方法，就是在不改变被扩展类的前提下，人为地用一个新的类来构造新的方法，实现对原有的被扩展类的功能扩展和改变。
扩展方法的定义：区别于旧有static方法的地方，在于其参数类型为（this + 被扩展的类型名）。其中this是修饰符。下列代码，即是对string类的一个扩展，为其添加了一个转换为double的扩展方法。
public static class StringConversions { public static double ToDouble(this string s) { return Double.Parse(s); } }
使用范例如下。其中的"3.1415926"是个string对象，却使用了一个属于StringConversions类的静态方法，即此前定义的扩展方法ToDouble()。
// "3.1415926" 是一个string的实例 // ToDouble()是前述StringConversions类的static方法 double pi = "3.1415926".ToDouble();
P34 partial方法
看了半天，感觉就是把方法的实现与方法的声明剥离，类似原来C++的.h与.cpp的关系，把一个类的实现分散到若干个文件里，从而为类的方法提供拆解和替换的捷径。比如选用甲写的某个版本，或者乙的某个版本。关于partial 方法的三个必须：
1. 类必须是partial class
2. 方法必须以partial关键字开始
3. 方法返回类型必须为void
P38 查询表达式的语法图
真象极了SQL语句，只是许多地方的顺序完全反了。
query-expression:
from-clause query-body
from-clause:
from typeopt identifier in expression join-clausesopt
join-clauses:
join-clause
join-clauses join-clause
join-clause:
join typeopt identifier in expression on expression equals
expression
join typeopt identifier in expression on expression equals
expression into identifier
query-body:
from-let-where-clausesopt orderby-clauseopt select-or-group-clause
query-continuationopt
from-let-where-clauses:
from-let-where-clause
from-let-where-clauses from-let-where-clause
from-let-where-clause:
from-clause
let-clause
where-clause
let-clause:
let identifier = expression
where-clause:
where boolean-expression
orderby-clause:
orderby orderings
orderings:
ordering
orderings , ordering
ordering:
expression ordering-directionopt
ordering-direction:
ascending
descending
select-or-group-clause:
select-clause
group-clause
select-clause:
select expression
group-clause:
group expression by expression
query-continuation:
into identifier join-clausesopt query-body
P41 linq语句的转译
作者使用了一张转义符号表，用单个字母替代linq语句中的某个语法元素，并且建议按逆序阅读和理解这个转译的过程。了解编译LINQ的过程，是熟悉LINQ语法的进阶手段。
在这个过程中，他举了许多典型的例子，然后分别用“类sql”和“扩展方法”的语法形式表达。
下列示例中，注释部分为等价的SQL查询语句与个人的注解。
from c in customers group c by c.Country into g select new {Country = g.Key, CustCount = g.Count()} // select Country, count(Coustomerid) from Customers group by Country from c in customers join o in orders on c.customerid equals o.customerid select new {c.contactname, o.orderdate, o.freight} // select c.contactname, o.orderdate, o.freight // from customers as c, orders as o // where c.customerid = o.customerid from c in customers join o in orders on c.customerid equals o.customerid into co select new {c.contactname, summery = co.Sum(o => o.freight)} // 形成1:M的关系，其中1是customers中的一项，M是orders中所有customerid与之相匹配的记录。 // 把 join ... on ... into ...作为一个整体看待，即容易理解了。 // select c.contactname, sum(o.freight) as summery // from customers as c, orders as o // group by o.contactname // select c.contactname, // (select sum(o.freight) from orders as o // where c.customerid = o.customerid) as sumerry // from customers as c