EF学习笔记28：如何实现自己的预先加载（Eager Loading)策略

背景: 在过去的两年中，很对开发者都抱怨EF中预先加载的执行方式。

下面是你经常会使用的预先加载的方式：

var results = from b in ctx.Blogs.Include(“°Posts”±)
where b.Owner == “°Alex”±
select b;

上面代码的意思很明确，要求EF预先加载所有符合要求的Blog的相关的Posts，代码会很好的执行。

但是问题是这里使用了"Posts”这样的字符串的方式，这对于已经习惯于在常规的Linq语句或者Linq to SQL语句中使用强类型的我们来说，用string的这样类型不安全的方式显然不是我们所希望的，我们希望的形式或许是这样的：

var results = from b in ctx.Blogs.Include(b => b.Posts)
where b.Owner == “°Alex”±
select b;
上面这样的方式是类型安全的，很多人也尝试着这样做。

下面的方式或许更好:

var strategy = new IncludeStrategy<Blog>();
strategy.Include(b => b.Owner);

var results = from b in strategy.ApplyTo(ctx.Blogs)
where b.Owner == “°Alex”±
select b;

上面这样的方式可以让你在不同的数据检索之间重用strategies。

设计目标:

根据上面的想法，我打算扩展我的思路来支持这里的strategies。

 

下面是我想做的针对Blog的Stretegy方式的类的实力：

var strategy = Strategy.NewStrategy<Blog>();
strategy.Include(b => b.Owner)
.Include(p => p.Comments); //sub includes
strategy.Include(b => b.Posts);    //multiple includes

上面的类将支持子类继承：
public class BlogFetchStrategy: IncludeStrategy<Blog>
{
public BlogFetchStrategy()
{
this.Include(b => b.Owner);
this.Include(b => b.Posts);
}
}

有了上面的类，你可以像下面这样来使用：

var results = from b in new BlogFetchStrategy().ApplyTo(ctx.Blogs)
where b.Owner == “°Alex”±
select b;

实现:

下面我们来实现上面的这个stretegy类:

1) 创建 IncludeStrategy<T> 类:

public class IncludeStrategy<TEntity>
where TEntity : class, IEntityWithRelationships
{
private List<string> _includes = new List<string>();

public SubInclude<TNavProp> Include<TNavProp>(
Expression<Func<TEntity, TNavProp>> expr
) where TNavProp : class, IEntityWithRelationships
{
return new SubInclude<TNavProp>(
_includes.Add,
new IncludeExpressionVisitor(expr).NavigationProperty
);
}

public SubInclude<TNavProp> Include<TNavProp>(
Expression<Func<TEntity, EntityCollection<TNavProp>>> expr
) where TNavProp : class, IEntityWithRelationships
{
return new SubInclude<TNavProp>(
_includes.Add,
new IncludeExpressionVisitor(expr).NavigationProperty
);
}

public ObjectQuery<TEntity> ApplyTo(ObjectQuery<TEntity> query)
{
var localQuery = query;
foreach (var include in _includes)
{
localQuery = localQuery.Include(include);
}
return localQuery;
}
}

从上面的代码中我们注意到，代码使用了一个string数组来存储我们要添加的Includes，同时还有ApplyTo(…)方法允许调用者

可以将所有符合T类型的ObjectQuery<T>, 绑定到Includes中来。

淡然代码主要的功能实在两个Include(..) 方法中，之所以要有两个重载方法，其中第一个是为了加载References引用，另一个是为了加载数组。这样的实现是针对.NET 3.5 SP1的，所以我可以依赖于那些实现了IEntityWithRelationships接口，并具有relationships的类（可以对包含Include的类进行检测）。有趣的是真毒载入数组的Include方法，每一个Expression语句都被设置成isExpression<Func<TEntity, EntityCollection<TNavProp>>> ，而在创建Sub-includes的时候返回的类型却是TNavProp，这样的做法让我们避免在使用的时候使用如下的代码：

Include(b => b.Posts.SelectMany(p => p.Author));

同时也可以避免下面的写法:

Include(b => b.Posts.And().Author);

取而代之的是下面的更简洁和合理的写法:

Include(b => b.Posts).Include(p => p.Author);

上面的实现方式更简单，这也是整个设计中的核心部分。

2) 类IncludeExpressionVisitor 派生自ExpressionVisitor这个实例，你可以在这里找到它，这个实例其实非常简单，或许用在这里有些有过度设计的感觉，但我喜欢在这里采用正确的是寂寞死来实现这个功能。

public class IncludeExpressionVisitor : ExpressionVisitor
{
private string _navigationProperty = null;

public IncludeExpressionVisitor(Expression expr)
{
base.Visit(expr);
}
public string NavigationProperty
{
get { return _navigationProperty; }
}

protected override Expression VisitMemberAccess(
MemberExpression m
)
{
PropertyInfo pinfo = m.Member as PropertyInfo;

if (pinfo == null)
throw new Exception(
"You can only include Properties");
if (m.Expression.NodeType != ExpressionType.Parameter)
throw new Exception(
"You can only include Properties of the Expression Parameter");
_navigationProperty = pinfo.Name;

return m;
}

protected override Expression Visit(Expression exp)
{
if (exp == null)
return exp;
switch (exp.NodeType)
{
case ExpressionType.MemberAccess:
return this.VisitMemberAccess(
(MemberExpression)exp
);
case ExpressionType.Lambda:
return this.VisitLambda((LambdaExpression)exp);
default:
throw new InvalidOperationException(
"Unsupported Expression");
}
}
}

从上面的代码中你可以看到，vistor仅仅是起了一个约束的作用，它仅仅能够识别LambdaExpressions和MemberExpressions。

当使用MemberExpression的时候，visitor将确认进入的成员是一个属性（Property），并把这个成员直接绑定到其参数中（Parameter)中（比如p.Property可以，但是p.Property.SubProperty不可以）如果出现这种情况，visitor将会记录下NavigationProperty的名字。

3)当我们知道NavigationProperty的名字，IncludeStrategy.Include 方法会创建一个SubInclude<T> 对象，它将用来注册NavigationProperty，并为串联多个sub-includes提供相关的机制。

类SubInclude<T>的代码如下：

public class SubInclude<TNavProp>
where TNavProp : class, IEntityWithRelationships
{

private Action<string> _callBack;
private string[] _paths;
internal SubInclude(Action<string> callBack, params string[] path)
{
_callBack = callBack;
_paths = path;
_callBack(string.Join(".", _paths));
}

public SubInclude<TNextNavProp> Include<TNextNavProp>(
Expression<Func<TNavProp, TNextNavProp>> expr
) where TNextNavProp : class, IEntityWithRelationships
{
string[] allpaths = _paths.Append(
new IncludeExpressionVisitor(expr).NavigationProperty
);
return new SubInclude<TNextNavProp>(_callBack, allpaths);
}

public SubInclude<TNextNavProp> Include<TNextNavProp>(
Expression<Func<TNavProp, EntityCollection<TNextNavProp>>> expr
) where TNextNavProp : class, IEntityWithRelationships
{
string[] allpaths = _paths.Append(
new IncludeExpressionVisitor(expr).NavigationProperty
);
return new SubInclude<TNextNavProp>(_callBack, allpaths);
}
}

4) 现在还遗留的一点东西是一个用于附加其他元素到array数组中的扩展方法，代码如下：

public static T[] Append<T>(this T[] initial, T additional)
{
List<T> list = new List<T>(initial);
list.Add(additional);
return list.ToArray();
}

有了上面的代码，你就可以以你自己的方式非常容易的实现与预先加载，你所需要做的就是继承类IncludeStrategy<T>.

但是要注意的是，这个方案只是我的个人方案，并不是微软的官方解决方案，它没有经过严格测试。你可愿意在这里下载到完整代码。