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>.

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