在扩展方法中使用时,DbSet <T> .Include()会导致SELECT N + 1

Question

我在IQueryable上有一个扩展,允许传递分隔的属性名称字符串,当使用时会导致查询不构造JOIN并有效地导致SELECT N + 1问题.

我注意到的是,如果我直接从DbSet调用本机EF扩展名.Include("property"),一切正常.但是,如果我使用我的扩展(我甚至简化它只是调用.Include("property")SELECT N + 1发生...

我的问题是为什么？我究竟做错了什么？

这是调用方法(来自服务)

public MyModel[] GetAll(int page, out int total, int pageSize, string sort, string filter)
{
    return _myModelRepository
        .Get(page, out total, pageSize, sort, filter, "PropertyOnMyModelToInclude")
        .ToArray();
}

这是使用扩展的存储库方法

public virtual IQueryable<T> Get(int page, out int total, int pageSize, string sort, string filter = null, string includes = null)
{
    IQueryable<T> query = DatabaseSet;
    if (!String.IsNullOrWhiteSpace(includes))
    {
        //query.IncludeMany(includes); // BAD: SELECT N+1
        //query.Include(includes); // BAD: SELECT N+1
    }
    if (!String.IsNullOrWhiteSpace(filter))
    {
        query.Where(filter);
    }
    total = query.Count(); // needed for pagination
    var order = String.IsNullOrWhiteSpace(sort) ? DefaultOrderBy : sort;
    var perPage = pageSize < 1 ? DefaultPageSize : pageSize;

    //return query.OrderBy(order).Paginate(page, total, perPage); // BAD: SELECT N+1 (in both variations above)
    //return query.IncludeMany(includes).OrderBy(order).Paginate(page, total, perPage); // BAD: SELECT N+1
    return query.Include(includes).OrderBy(order).Paginate(page, total, perPage);     // WORKS!
}

这是扩展名(简化为调用Include()以说明问题)

public static IQueryable<T> IncludeMany<T>(this IQueryable<T> query, string includes, char delimiter = ',') where T : class
{
    // OPTION 1
    //var propertiesToInclude = String.IsNullOrWhiteSpace(includes)
    //                              ? new string[0]
    //                              : includes.Split(new[] {delimiter}, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray();
    //foreach (var includeProperty in propertiesToInclude)
    //{
    //    query.Include(includeProperty);
    //}
    // OPTION 2
    //if (!String.IsNullOrWhiteSpace(includes))
    //{
    //    var propertiesToInclude = includes.Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries).AsEnumerable(); //.Select(p => p.Trim());
    //    propertiesToInclude.Aggregate(query, (current, include) => current.Include(include));
    //}

    // OPTION 3 - for testing
    query.Include(includes);

    return query;
}

Answer 1

我认为这里的根本问题在于您使用Include方法的方式,以及偶然的Where方法.与LINQ扩展方法一样,这些方法不会修改调用它们的对象.相反,它们返回一个新对象,该对象在应用运算符后表示查询.因此,例如,在此代码中:

var query = SomeQuery();
query.Include(q => q.Bing);
return query;

Include方法基本上什么都不做,因为Include返回的新查询被丢弃了.另一方面,这个:

var query = SomeQuery();
query = query.Include(q => q.Bing);
return query;

将Include应用于查询,然后使用Include返回的新查询对象更新查询变量.

它不在您发布的代码中,但我认为您仍然看到N + 1与您的代码,因为Include被忽略,因此相关的集合仍然使用延迟加载加载.