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被忽略，因此相关的集合仍然使用延迟加载加载。

在扩展方法</t>中使用时，DbSet <t> .Include（）会导致SELECT N + 1

1 个答案: