实体框架核心 .Include() 问题

Question

一直在玩 ef core 并且遇到了 include 语句的问题。对于这段代码，我得到了 2 家公司，这是我所期望的。

public IEnumerable<Company> GetAllCompanies(HsDbContext db)
{
    var c = db.Company;
    return c;
}

返回

[
    {
        "id":1,
        "companyName":"new",
        "admins":null,
        "employees":null,
        "courses":null
    },
    {
        "id":2,
        "companyName":"Test Company",
        "admins":null,
        "employees":null,
        "courses":null
    }
]

如您所见，有 2 家公司，所有相关属性均为空，因为我没有使用任何包含，这是我所期望的。现在，当我将方法更新为此：

public IEnumerable<Company> GetAllCompanies(HsDbContext db)
{
    var c = db.Company
        .Include(t => t.Employees)
        .Include(t => t.Admins)
        .ToList();

    return c;
}

这是它返回的内容：

[
    {
        "id":1,
        "companyName":"new",
        "admins":[
            {
                "id":2,
                "forename":"User",
                "surname":"1",
                "companyId":1
            }
        ]
    }
]

它只返回一家公司，并且只包括管理员。为什么不包括这两家公司及其员工？

public class Company
{
    public int Id { get; set; }
    public string CompanyName { get; set; }
    public List<Admin> Admins { get; set; }
    public List<Employee> Employees { get; set; }
    public List<Course> Courses { get; set; }

    public string GetFullName()
    {
        return CompanyName;
    }
}

public class Employee
{
    public int Id { get; set; }
    public string Forename { get; set; }
    public string Surname { get; set; }
    public int CompanyId { get; set; }
    [ForeignKey("CompanyId")]
    public Company company { get; set; }

    public ICollection<EmployeeCourse> Employeecourses { get; set; }
}

public class Admin
{
    public int Id { get; set; }
    public string Forename { get; set; }
    public string Surname { get; set; }
    public int CompanyId { get; set; }
    [ForeignKey("CompanyId")]
    public Company Company { get; set; }
}

Answer 1

我不确定您是否已经看到对此question 的公认答案，但问题在于 JSON 序列化程序如何处理循环引用。完整的详细信息和更多参考的链接可以在上面的链接中找到，我建议深入研究这些，但简而言之，将以下内容添加到 startup.cs 将配置序列化程序以忽略循环引用：

services.AddMvc()
    .AddJsonOptions(options => {
        options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
    });

Answer 2

EF Core 尚无法进行延迟加载。 Refer here.

您也可以使用预先加载。

阅读此article

下面是我创建的用于实现预加载的扩展方法。

扩展方法：

public static IQueryable<TEntity> IncludeMultiple<TEntity, TProperty>(
    this IQueryable<TEntity> source,
    List<Expression<Func<TEntity, TProperty>>> navigationPropertyPath) where TEntity : class
{
    foreach (var navExpression in navigationPropertyPath)
    {
        source= source.Include(navExpression);
    }
    return source.AsQueryable();
}

存储库调用：

public async Task<TEntity> FindOne(ISpecification<TEntity> spec)
{
    return await Task.Run(() => Context.Set<TEntity>().AsQueryable().IncludeMultiple(spec.IncludeExpression()).Where(spec.IsSatisfiedBy).FirstOrDefault());
}

用法：

List<object> nestedObjects = new List<object> {new Rules()};

ISpecification<Blog> blogSpec = new BlogSpec(blogId, nestedObjects); 

var challenge = await this._blogRepository.FindOne(blogSpec);

依赖关系：

public class BlogSpec : SpecificationBase<Blog>
{
    readonly int _blogId;
    private readonly List<object> _nestedObjects;

    public ChallengeSpec(int blogid, List<object> nestedObjects)
    {
        this._blogId = blogid;
        _nestedObjects = nestedObjects;
    }

    public override Expression<Func<Challenge, bool>> SpecExpression
    {
        get { return blogSpec => blogSpec.Id == this._blogId; }
    }

    public override List<Expression<Func<Blog, object>>> IncludeExpression()
    {
        List<Expression<Func<Blog, object>>> tobeIncluded = new List<Expression<Func<Blog, object>>>();
        if (_nestedObjects != null)
            foreach (var nestedObject in _nestedObjects)
            {
                if (nestedObject is Rules)
                {
                    Expression<Func<Blog, object>> expr = blog => blog.Rules;
                    tobeIncluded.Add(expr);
                }
                
            }

        return tobeIncluded;
    }
}

如果有帮助会很高兴。请注意，这不是生产就绪代码。

Answer 3

我测试你的代码，这个问题在我的测试中存在。在这篇帖子中LINK 建议使用数据投影。对于您的问题，如下所示是可行的。

[HttpGet]
public dynamic Get()
{
    var dbContext = new ApplicationContext();

    var result = dbContext.Companies
        .Select(e => new { e.CompanyName, e.Id, e.Employees, e.Admins })
        .ToList();

    return result;
}

Answer 4

确保您使用的是“Microsoft.EntityFrameworkCore”中的包含和“System.Data.Entity”中的Not

Answer 5

我知道这是一个老问题，但它在 google 中的结果最高，所以我把我找到的解决方案放在这里。对于 Core 3.1 Web 项目，有一个快速修复。 添加 nuget 包 Microsoft.EntityFrameworkCore.Proxies。 然后，您只需在配置服务时在选项生成器中指定。文档：https://docs.microsoft.com/en-us/ef/core/querying/related-data

public void ConfigureServices(IServiceCollection services) {    
    services.AddDbContextPool<YourDbContext>(options => {
        options.UseLazyLoadingProxies();
        options.UseSqlServer(this.Configuration.GetConnectionString("MyCon"));
    });
}

现在您的延迟加载应该可以像在以前的 EF 版本中那样工作了。 如果您不将它用于 Web 项目，则可以直接在 DbContext 本身的 OnConfiguringMethod 内部进行。

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
    optionsBuilder.UseLazyLoadingProxies();
}

我的 EF 内容保存在一个单独的类库中，因此我可以通过多个公司应用程序重复使用它。因此，在特定应用程序不需要时能够不延迟加载是很有用的。因此，出于重用能力的目的，我更喜欢传入构建选项。但两者都可以。