当我们知道了Linq查询要用到的数据库信息之后。接下就是生成对应的表达式树。在前面的章节里面笔者就已经介绍过。生成表达式树是事实离不开IQueryable<T>接口。而处理表达式树离不开IQueryProvider接口。LinqToDB框架跟这俩个接口有关系的有三个类：Table<T>类、ExpressionQuery<T>类、ExpressionQueryImpl<T>类。其中最重要的是ExpressionQuery<T>类。他是Table<T>和ExpressionQueryImpl<T>类的父类。而本章就是围绕这三个类进行的。
IQueryable<T>接口和IQueryProvider接口
ExpressionQuery<T>类是一个抽象类。他实现于IExpressionQuery接口。IExpressionQuery接口却同时继续了IQueryable<T>接口和IQueryProvider接口。所以ExpressionQuery<T>类实际上同时实现了俩个接口。而同时自己增加一个属性SqlText和一个跟IQueryable接口一样子的Expression属性。SqlText属性是用于获得当前表达式对应的SQL语句。这个属性显然在开发过程非常有用。而Expression属性是用于生成表达式树的。
public interface IExpressionQuery<out T> : IOrderedQueryable<T>, IQueryProvider
{
new Expression Expression { get; set; }
string SqlText { get; }
}
从前面的章节里面，我们可以知道实现IQueryable<T>接口和IQueryProvider接口的类有俩个部分的职责。一是帮助生成表达式树，二是用于Linq To SQL的数据源的入口。作者也相应的设计了俩个类。就是上面讲到的Table<T>和ExpressionQueryImpl<T>类。ExpressionQueryImpl<T>类用于前者，而Table<T>类用于后者。
var query = from p in dbContext.Products where p.ProductID == select p;
上面这段Linq查询中的dbContext.Products。事实上是通过IDataContext的静态扩展方法GetTable<T>来实现的。当然事情并没有这么简单。从源码中笔者看到这一个过程还离不开DataContextInfo类。DataContextInfo类是里面存放了关于DataContext类实例的信息。从代码量我们可以知道一个信息——DataContextInfo类必须有。
protected void Init(IDataContextInfo dataContextInfo, Expression expression)
{
DataContextInfo = dataContextInfo ?? new DefaultDataContextInfo();
Expression = expression ?? Expression.Constant(this);
}
我们都知道在生成表达式树的时候，实现俩个CreateQuery方法的重要性。LinqToDB框架也离不开这一点。CreateQuery<TElement>方法直接新建一个ExpressionQueryImpl<TElement>类。而CreateQuery方法用反射来实现(笔者认为这地方只有这里有看点其他的真的没有)。关于ExpressionQueryImpl<TElement>类真的没有什么可说的。笔者也就不提他了。
泛型CreateQuery方法:
IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
{
if (expression == null)
throw new ArgumentNullException("expressionreturn new ExpressionQueryImpl<TElement>(DataContextInfo, expression);
}
普通CreateQuery方法:
IQueryable IQueryProvider.CreateQuery(Expression expression)
{
if (expression == null)
throw new ArgumentNullException("expression"); var elementType = expression.Type.GetItemType() ?? expression.Type; try
{
return (IQueryable)Activator.CreateInstance(typeof(ExpressionQueryImpl<>).MakeGenericType(elementType), new object[] { DataContextInfo, expression });
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
}
从这里面笔者就是感觉出来IQueryable<T>接口更多只是帮助我们生成相应的表达式树。当然这里面离不开IQueryProvider接口的CreateQuery方法的帮忙。正因为CreateQuery方法我们可以知道每一个表达树节点都会新建一个对象。这个对象就是ExpressionQueryImpl<TElement>类。而这个对象里面的Expression属性就是当前节点的表达式。所以每新建一个对象都会把expression参数传入。
Query类
Linq查询的难点就是处理表达式。上面笔者粗略的讲了一些生成表达式。主要是因为前面章节中已经讲过这一部分的内容。而且LinqToDB框架关于这一点又没有做出什么特色的设计。但是关于处理表达式树的设计内容笔者感觉还有可以学习和介见的。所有处理表达树的类都在LinqToDB.Linq.Builder命名空间下。更是以XxxxBuilder的命名规则来新建相应的类。但是在讲处理表达树之前，笔者还是先讲一下关于Query类的内容。事实上从ExpressionQuery<T>的性属中我们就可以找到Query类的影子。
abstract class ExpressionQuery<T> : IExpressionQuery<T>
{
[NotNull]
public Expression Expression { get; set; }
[NotNull]
public IDataContextInfo DataContextInfo { get; set; } internal Query<T> Info;
internal object[] Parameters;
}
那么Query类到底是什么角色呢？又有什么作用呢？从《LinqToDB 源码分析——轻谈Linq查询》章节中我们能知道最后执行的方法有俩个Execute方法和GetEnumerator方法。所以Query类对应也有俩个方法跟他们相应。
ExpressionQuery类的Execute方法：
TResult IQueryProvider.Execute<TResult>(Expression expression)
{
return (TResult)GetQuery(expression, false).GetElement(null, DataContextInfo, expression, Parameters);
}
ExpressionQuery类的GetEnumerator方法：
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
IEnumerable<T> result = Execute(DataContextInfo, Expression);
IEnumerator<T> iEnumerator = result.GetEnumerator();
return iEnumerator;
}
GetEnumerator方法里面的Execute方法：
IEnumerable<T> Execute(IDataContextInfo dataContextInfo, Expression expression)
{
return GetQuery(expression, true).GetIEnumerable(null, dataContextInfo, expression, Parameters);
}
从源码中我们可以看到Query类的GetElement方法和GetIEnumerable方法各自对应一个最终执行方法。GetElement方法对应ExpressionQuery类的Execute方法，而GetIEnumerable方法对应ExpressionQuery类的GetEnumerator方法。不过，GetElement方法和GetIEnumerable方法都是Func类型。
class Query<T> : Query
{
//......
//......
//......
public Func<QueryContext, IDataContextInfo, Expression, object[], object> GetElement;
public Func<QueryContext, IDataContextInfo, Expression, object[], IEnumerable<T>> GetIEnumerable;
//......
//......
//...... }
从这里我们就能感觉到一点那就是好像最后执行会在Query类里面做。笔者只能说没有错。事实上关于Query类现在笔者也很难去形容他。这个类设计到底是一个什么样子的存在。相信也只有作者才能搞清楚。总之从代码上来看的话，他有一点像是保妈一样子。负责各个类之间的引导工作。
处理表达式树的工作并不是由Query类来做的。而由一个叫ExpressionBuilder类来做的(下一章会讲到)。但是Query类最后会负责接受ExpressionBuilder类产生的结果。Query类会拿着结果去找DataContext类来处理执行生成数据库结果。然后Query类在拿数据库结果去找MapInfo类生成对应的最终结果。看看。像不像保妈一样子。关于Query类的具体内容还是要接合ExpressionBuilder类才能介绍清楚。笔者后面会讲到。现在主要让我们看一下Query类是什么样子由来的。ExpressionQuery<T>类中有一个方法GetQuery方法。上面讲到的最后执行的方法(Execute方法和GetEnumerator方法)都会去调用他。Query类又调用自己本身的静态方法GetQuery。一切也就是从这里开始的。
ExpressionQuery<T>类的GetQuery方法：
Query<T> GetQuery(Expression expression, bool cache)
{
if (cache && Info != null)
return Info; var info = Query<T>.GetQuery(DataContextInfo, expression); if (cache)
Info = info; return info;
}
Query的静态方法GetQuery：
public static Query<T> GetQuery(IDataContextInfo dataContextInfo, Expression expr)
{
var query = FindQuery(dataContextInfo, expr); if (query == null)
{
lock (_sync)
{
query = FindQuery(dataContextInfo, expr); if (query == null)
{
if (Configuration.Linq.GenerateExpressionTest)
{
var testFile = new ExpressionTestGenerator().GenerateSource(expr);
DataConnection.WriteTraceLine(
"Expression test code generated: '" + testFile + "'.",
DataConnection.TraceSwitch.DisplayName);
} try
{
query = new ExpressionBuilder(new Query<T>(), dataContextInfo, expr, null).Build<T>();
}
catch (Exception)
{
if (!Configuration.Linq.GenerateExpressionTest)
{
DataConnection.WriteTraceLine(
"To generate test code to diagnose the problem set 'LinqToDB.Common.Configuration.Linq.GenerateExpressionTest = true'.",
DataConnection.TraceSwitch.DisplayName);
} throw;
} if (!query.DoNotChache)
{
query.Next = _first;
_first = query;
}
}
}
} return query;
}
我们可以明显的看到想要获得Query类，就必须通过ExpressionBuilder类来获得。这里的内容就多了。而除了这一点之外，作者也为Query类做了小缓存。ExpressionQuery<T>的性属Info是为了Query类本身的缓存。而FindQuery方法是为了所有的Query类缓存的。
1.Query类本身的缓存。如下，第一次用query变量的时候要加载实例化Query类。第二次在用query变量的时候就不必了。
static void Main(string[] args)
{
using (AdoContext dbContext = new AdoContext())
{
var query = from p in dbContext.Products where p.ProductID == select p;
List<Products> catalogsList = query.ToList();
List<Products> catalogsList1 = query.ToList();
}
}
2.所有的Query类缓存的。下面中query和query1、query3是一样子的。所以query1,query2是不会在加载实例Query类的。FindQuery方法用的缓存方式有一点像链接队列——只是笔者忘记了专业的名称。如果链接缓存中哪一个query被用最后会放到链接的最前面。如果在链接缓存中没有找到，就接在最后面。
static void Main(string[] args)
{
using (AdoContext dbContext = new AdoContext())
{
var query = from p in dbContext.Products where p.ProductID == select p;
var query1 = from p in dbContext.Products where p.ProductID == select p;
var query2 = from p in dbContext.Products where p.ProductName == "Aomi" select p;
var query3 = from p in dbContext.Products where p.ProductID == select p;
List<Products> catalogsList = query.ToList();
List<Products> catalogsList11 = query.ToList();
List<Products> catalogsList1 = query1.ToList();
List<Products> catalogsList2 = query2.ToList();
List<Products> catalogsList3 = query3.ToList();
}
}
LinqToDB框架是轻量级的ORM框架。所以笔者也很喜欢作者这样子设计缓存——简单而又实用。
好了。有于工作的原因。笔者本单只能介绍到这里了。