在C# 3.0之前，我们对不同的数据源（数据集合、SQL 数据库、XML 文档等等）进行操作（查询、筛选、投影等等），会使用不同的操作方式。
C# 3.0中提出了LINQ（Language Integrated Query）这个非常重要的特性， LINQ定义了一组标准查询操作符用于在所有基于.NET平台的编程语言中更加直接地声明跨越、过滤和投射操作的统一方式。
关于LINQ中标准操作符的介绍和使用，园子里有很多很好的文章了，所以这里就不介绍LINQ的操作符使用了，主要通过一些概念和例子介绍LINQ是怎么工作的。
LINQ to Objects
首先我们看看LINQ to Objects：
- LINQ to Objects是指直接对任意实现 IEnumerable 或 IEnumerable<T> 接口集合使用 LINQ 查询
- Enumerable静态类封装了对查询IEnumerable或 IEnumerable<T>接口类型的静态扩展方法
- 从Enumerable类的代码可以看到所有的扩展方法中的逻辑表达式都是Func泛型委托，也就是直接使用委托去执行逻辑操作
从上面的概况可以看到，对于实现IEnumerable 或 IEnumerable<T> 接口的集合，我们都可以使用Enumerable中的扩展方法对集合使用LINQ查询。
为了进一步理解这些概念，下面例子中创建了Where和Select扩展方法，模拟了Enumerable中的标准操作符Where和Select：
namespace LINQtoObject { public static class DummyLINQ { public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate) { if (source == null || predicate == null) { throw new ArgumentNullException(); } return WhereImpl<T>(source, predicate); } public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector) { if (source == null || selector == null) { throw new ArgumentNullException(); } return SelectImpl<TSource, TResult>(source, selector); } private static IEnumerable<T> WhereImpl<T>(IEnumerable<T> source, Func<T, bool> predicate) { foreach (var item in source) { if (predicate(item)) { Console.WriteLine(" Where: {0} matches where", item); yield return item; } else { Console.WriteLine(" Where: {0} doesn't match where", item); } } } private static IEnumerable<TResult> SelectImpl<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult> selector) { foreach (var item in source) { Console.WriteLine(" Selcet: select {0}", item); yield return selector(item); } } } class Student { public string Name { get; set; } public int Age { get; set; } public override string ToString() { return String.Format("(Name:{0}, Age:{1})", this.Name, this.Age); } } class Program { static void Main(string[] args) { List<Student> school = new List<Student> { new Student{Name = "Wilber", Age = 28}, new Student{Name = "Will", Age = 25}, new Student{Name = "July", Age = 23}, new Student{Name = "Lucy", Age = 24}, new Student{Name = "Jean", Age = 22}, }; var stus = school.Where(s => s.Age >= 24).Select(s => s.Name); foreach (var stu in stus) { Console.WriteLine(stu); } Console.Read(); } } }
代码的输出为：
上面的代码简单的模拟了LINQ to Objects的工作方式及实现，自定义的Where和Select操作符也按照了我们预期的方式工作。
通过IL代码可以看到，在LINQ to Objects中，所有扩展方法中的逻辑表达式都被编译器转换成了匿名方法。
延迟执行
如果通过单步调试查看上面代码，可以看到当下面语句执行的时候，并没有处理任何数据。
var stus = school.Where(s => s.Age >= 24).Select(s => s.Name);
只有当访问结果IEnumerable<Student>的时候，上面的查询才会被真正的执行，这个就是LINQ的延迟执行，其实这个延迟执行是基于我们前面介绍过的yield return创建的迭代器块。
虽然我们看到了前面例子的输出，但是下面的序列图可以更加清楚的表示上面查询执行的过程：
方法语法（Fluent Syntax）和查询表达式（Query Expression）
有了Enumerable静态类中所有扩展方法的支持，对于所有实现IEnumerable或 IEnumerable<T>接口的集合，我们可以通过扩展方法组成的方法链完成集合的操作。
var stus = school.Where(s => s.Age >= 24).Select(s => s.Name);
在LINQ中，我们还可以通过查询表达是的方式完成LINQ查询：
var stus = from s in school where s.Age >= 24 select s.Name;
CLR并不具有查询表达式的概念，编译器会在程序编译时把查询表达式转换为方法语法，从而进行扩展方法的调用。
OfType 和Cast
前面例子中我们使用的是List<T>集合，当我们对弱类型的集合使用LINQ的时候，我们就需要用到OfType和Cast两个操作符了。
-
OfType 和Cast共同点：
- 都可以处理任意非类型化的序列，并返回强类型的序列
-
不同点：
- Cast把每个元素都转换成目标类型（遇到类型转换错误的时候，就会抛出异常）
- OfType会跳过错误类型的元素，然后对序列进行转换
下面看一个简单的例子：
static void Main(string[] args) { ArrayList list = new ArrayList { "Frist", "Second", "Third" }; IEnumerable<string> stringList1 = list.Cast<string>(); foreach (var str in stringList1) { Console.WriteLine(str); } IEnumerable<string> stringList2 = list.OfType<string>(); foreach (var str in stringList2) { Console.WriteLine(str); } list = new ArrayList { "Frist", "Second", "Third", 1, 2, 3}; //IEnumerable<string> stringList3 = list.Cast<string>(); //foreach (var str in stringList3) //{ // Console.WriteLine(str); //} IEnumerable<int> stringList4 = list.OfType<int>(); foreach (var str in stringList4) { Console.WriteLine(str); } Console.Read(); }
注释掉的代码会产生异常，因为对ArrayList中的int类型数据进行Cast<string>时候会失败。
LINQ to Others
前面看到，对于实现IEnumerable 或 IEnumerable<T> 接口的集合，我们可以直接使用LINQ to Objects。那么当我们碰到其他数据源的时候，我们就需要使用这种数据源特有的LINQ查询了。
如果要对特殊的数据源实现LINQ查询，我们需要知道Queryable类，以及IQueryable<T>和IQueryableProvider<T>接口。
IQueryable<T>和IQueryableProvider<T>
从下面的类图可以看到，IQueryable<T>继承自IEnumerable，IEnumerable<T>和非泛型的IQueryable。
对于IQueryable仅有三个属性：Provider、ElementType和Expression。
对于一个特殊的数据源，如果我们想要使用LINQ进行数据源查询，我们就要自己实现IQueryable<T>、IQueryProvider两个接口的。当使用LINQ查询表达式来查询System.Linq.IQueryable<T>类型对象的话，编辑器会认为我们要查询自定的数据源对象，在执行的时候会调用我们实现的System.Linq.IQueryableProvider<T>接口实现类，该类提供对表达式树的解析和执行。
自己实现的provider把表达式树转换成目标平台的特定类型的查询语句，例如LINQ to SQL的provider就是把表达式树转换成SQL语句，然后有SQL server执行SQL语句返回结果。
Queryable
LINQ to Objects中的数据源总是实现IEnumerable<T>（可能在调用OfType或Cast之后），然后使用Enumerable类中的扩展方法。
类似的，对于实现了IQueryable<T>的数据源，就可以使用Queryable静态类（在System.Linq命名空间中）中的扩展方法。
如果查看代码会发现，System.Linq.Queryable静态类中的所有扩展方法与System.Linq.Enumerable类中的扩展方法的区别是所有的Func类型都被System.Linq.Expressions.Expression<T>类型包装着，也就是说我们的查询表达式（Lambda表达式，匿名方法）在LINQ to Objects中转换成了Func类型的委托，在LINQ to Others中转换成了表达式树。
有了Queryable类中的扩展方法，相当于自定义的数据源也有了统一的操作符，也就是说不同的数据源也可以使用统一的查询方式。当我们使用ILSpy查看"Where"操作符的代码，可以发现这写扩展方法都使用了我们实现的provider。
下面看一个简单的例子，假设我们有一个图书系统，可以通过特定类型的方式（QueryString）进行检索。如果我们想要通过LINQ实现对这种数据源的查询，我们就需要实现一个porvider可以把LINQ查询转换成QueryString。
namespace LINQtoOthers { public class QueryableSource<T> : IQueryable<T> { public IQueryProvider Provider { get; private set; } public Expression Expression { get; private set; } public Type ElementType { get { return typeof(T); } } public QueryableSource() { Provider = new QueryableSourceProvider(); Expression = Expression.Constant(this); } public QueryableSource(QueryableSourceProvider provider, Expression expression) { if (provider == null) { throw new ArgumentNullException("provider"); } if (expression == null) { throw new ArgumentNullException("expression"); } if (!typeof(IQueryable<T>).IsAssignableFrom(expression.Type)) { throw new ArgumentOutOfRangeException("expression"); } Provider = provider; Expression = expression; } public IEnumerator<T> GetEnumerator() { return (Provider.Execute<IEnumerable<T>>(Expression)).GetEnumerator(); } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return this.GetEnumerator(); } } public class QueryableSourceProvider : IQueryProvider { public IQueryable<T> CreateQuery<T>(Expression expression) { return new QueryableSource<T>(this, expression); } public IQueryable CreateQuery(Expression expression) { try { return (IQueryable)Activator.CreateInstance( typeof(QueryableSource<>).MakeGenericType(expression.Type), new object[] { this, expression }); } catch { throw new Exception(); } } public T Execute<T>(Expression expression) { BookInfoExpressionVisitor visitor = new BookInfoExpressionVisitor(); visitor.Visit(expression); Console.WriteLine("QueryString is {0}", visitor.QueryString); return (T)((IEnumerable<BookInfo>)new List<BookInfo> { }); } public object Execute(Expression expression) { return null; } } public class BookInfoExpressionVisitor : ExpressionVisitor { public StringBuilder QueryString { get; set; } public BookInfoExpressionVisitor() { this.QueryString = new StringBuilder(); } protected override Expression VisitMethodCall(MethodCallExpression node) { if (node.Method.Name == "Where") { Console.WriteLine("parsing --- {0}", node); this.Visit((UnaryExpression)node.Arguments[1]); return node; } Console.WriteLine(string.Format("!!!!!Method {0} is not supported", node.Method.Name)); return node; } protected override Expression VisitUnary(UnaryExpression node) { Console.WriteLine("parsing --- {0}", node); this.Visit(node.Operand); return node; } protected override Expression VisitBinary(BinaryExpression node) { Console.WriteLine("parsing --- {0}", node); this.Visit(node.Left); switch (node.NodeType) { case ExpressionType.AndAlso: this.QueryString.Append(" AND "); break; case ExpressionType.OrElse: this.QueryString.Append(" OR "); break; case ExpressionType.Equal: this.QueryString.Append(" = "); break; case ExpressionType.NotEqual: this.QueryString.Append(" <> "); break; case ExpressionType.LessThan: this.QueryString.Append(" < "); break; case ExpressionType.LessThanOrEqual: this.QueryString.Append(" <= "); break; case ExpressionType.GreaterThan: this.QueryString.Append(" > "); break; case ExpressionType.GreaterThanOrEqual: this.QueryString.Append(" >= "); break; default: Console.WriteLine(string.Format("!!!!!Operation type {0} is not supported", node.NodeType)); break; } Console.WriteLine("parsing --- {0}", node.NodeType); this.Visit(node.Right); return node; } protected override Expression VisitMember(MemberExpression node) { Console.WriteLine("parsing --- {0}", node); this.QueryString.Append("[" + node.Member.Name); return node; } protected override Expression VisitConstant(ConstantExpression node) { Console.WriteLine("parsing --- {0}", node); if (node.Type.Name == "String") { this.QueryString.Append("""); this.QueryString.Append(node.Value); this.QueryString.Append(""]"); } else { this.QueryString.Append(node.Value + "]"); } return node; } } public class BookInfo { public string BookName { get; set; } public string Author { get; set; } public int SelledNumber { get; set; } public int year { get; set; } } class Program { static void Main(string[] args) { QueryableSource<BookInfo> queryableSource = new QueryableSource<BookInfo>(); var result = from book in queryableSource where book.BookName == "C# in Depth" && book.year > 2012 select book; foreach (var item in result) { Console.WriteLine(item); } Console.Read(); } } }
通过程序的输出可以看到provider一步步解析表达式树的过程，最终生成了一个QueryString。
总结
本文通过一些概念和例子介绍了LINQ to Objects和LINQ to Others，能够对LINQ有一些基本的认识。
C# 3.0中出现的LINQ极大程度的简化了数据操作的代码，通过LINQ实现的数据操作代码会更加的直观。同时，有了LINQ，即使是不同的数据源，我们也可以使用统一的数据操作方式。
LINQ有很多操作符，这些操作符的使用就不介绍了，请自己在园子中搜搜吧。