实体框架 linq 查询 Include() 多个子实体

Question

这可能是一个非常基本的问题，但是在编写跨越三个（或更多）级别的查询时，包含多个子实体的好方法是什么？

即我有 4 个表：Company、Employee、Employee_Car 和 Employee_Country

公司与员工是一对一的关系。

Employee 与 Employee_Car 和 Employee_Country 都有 1:m 关系。

如果我想编写一个返回所有 4 个表的数据的查询，我目前正在编写：

Company company = context.Companies
                         .Include("Employee.Employee_Car")
                         .Include("Employee.Employee_Country")
                         .FirstOrDefault(c => c.Id == companyID);

必须有更优雅的方式！这是冗长的，并且会生成可怕的 SQL

我在 VS 2010 中使用 EF4

Answer 1

使用extension methods。 将 NameOfContext 替换为您的对象上下文的名称。

public static class Extensions{
   public static IQueryable<Company> CompleteCompanies(this NameOfContext context){
         return context.Companies
             .Include("Employee.Employee_Car")
             .Include("Employee.Employee_Country") ;
     }

     public static Company CompanyById(this NameOfContext context, int companyID){
         return context.Companies
             .Include("Employee.Employee_Car")
             .Include("Employee.Employee_Country")
             .FirstOrDefault(c => c.Id == companyID) ;
      }

}

那么你的代码就变成了

     Company company = 
          context.CompleteCompanies().FirstOrDefault(c => c.Id == companyID);

     //or if you want even more
     Company company = 
          context.CompanyById(companyID);

Answer 2

EF 4.1 到 EF 6

有一个strongly typed .Include 允许通过将 Select 表达式提供到适当的深度来指定所需的急切加载深度：

using System.Data.Entity; // NB!

var company = context.Companies
                     .Include(co => co.Employees.Select(emp => emp.Employee_Car))
                     .Include(co => co.Employees.Select(emp => emp.Employee_Country))
                     .FirstOrDefault(co => co.companyID == companyID);

生成的 Sql 绝不是直观的，但似乎足够高效。我在GitHub here上放了一个小例子

EF 核心

EF Core 有一个新的扩展方法.ThenInclude()，虽然语法是slightly different：

var company = context.Companies
                     .Include(co => co.Employees)
                           .ThenInclude(emp => emp.Employee_Car)
                     .Include(co => co.Employees)
                           .ThenInclude(emp => emp.Employee_Country)

附上一些笔记

• 如上所述（Employees.Employee_Car 和 Employees.Employee_Country），如果您需要包含中间子集合的 2 个或更多子属性，you'll need to repeat.Include 为集合的每个子集合导航。
• As per the docs，我会在 .ThenInclude 中保留额外的“缩进”以保持您的理智。

Answer 3

您可能会在codeplex.com 找到这篇感兴趣的文章。

• Improving Entity Framework Query Performance Using Graph-Based Querying。

本文介绍了一种以声明性图形形状的形式表达跨多个表的查询的新方法。

此外，本文还对这种新方法与 EF 查询进行了全面的性能比较。该分析表明 GBQ 的性能很快优于 EF 查询。

Answer 4

How do you construct a LINQ to Entities query to load child objects directly, instead of calling a Reference property or Load()

没有其他方法 - 除了实现延迟加载。

或者手动加载....

myobj = context.MyObjects.First();
myobj.ChildA.Load();
myobj.ChildB.Load();
...

Answer 5

可能会帮助某人，每个级别有 4 个级别和 2 个孩子

Library.Include(a => a.Library.Select(b => b.Library.Select(c => c.Library)))
            .Include(d=>d.Book.)
            .Include(g => g.Library.Select(h=>g.Book))
            .Include(j => j.Library.Select(k => k.Library.Select(l=>l.Book)))

Answer 6

这样做：

namespace Application.Test
{
    using Utils.Extensions;
    public class Test
    {
        public DbSet<User> Users { get; set; }
        public DbSet<Room> Rooms { get; set; }
        public DbSet<Post> Posts { get; set; }
        public DbSet<Comment> Comments { get; set; }
        
        public void Foo()
        {
            DB.Users.Include(x => x.Posts, x => x.Rooms, x => x.Members);
            //OR
            DB.Users.Include(x => x.Posts, x => x.Rooms, x => x.Members)
                .ThenInclude(x => x.Posts, y => y.Owner, y => y.Comments);
        }
    }
}

这个扩展可能会有所帮助：

namespace Utils.Extensions
{
    using Microsoft.EntityFrameworkCore;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Linq.Expressions;
    public static partial class LinqExtension
    {
        public static IQueryable<TEntity> Include<TEntity>(
            this IQueryable<TEntity> sources,
            params Expression<Func<TEntity, object>>[] properties)
            where TEntity : class
        {
            System.Text.RegularExpressions.Regex regex = new(@"^\w+[.]");
            IQueryable<TEntity> _sources = sources;
            foreach (var property in properties)
                _sources = _sources.Include($"{regex.Replace(property.Body.ToString(), "")}");
            return _sources;
        }

        public static IQueryable<TEntity> ThenInclude<TEntity, TProperty>(
            this IQueryable<TEntity> sources,
            Expression<Func<TEntity, IEnumerable<TProperty>>> predicate,
            params Expression<Func<TProperty, object>>[] properties)
            where TEntity : class
        {
            System.Text.RegularExpressions.Regex regex = new(@"^\w+[.]");
            IQueryable<TEntity> _sources = sources;
            foreach (var property in properties)
                _sources = _sources.Include($"{regex.Replace(predicate.Body.ToString(), "")}.{regex.Replace(property.Body.ToString(), "")}");
            return _sources;
        }
    }
}