c# - Include() ThenInclude() 在 Table Per Hierarchy 策略中抛出 "Sequence contains more than one matching element"异常

Question

我正在使用 Entity Framework 7 和代码优先，我有一个涉及 3 个级别的父子关系的模型:

• Corporations 有公司
• Companies 属于 corporation 并且有 factory
• 工厂 属于公司

由于这 3 个实体有很多共同点，它们都继承自一个抽象的 BaseOrganization 实体。

当我尝试列出所有工厂，包括它们的母公司，然后包括它们的母公司时，我有以下两种不同的情况:

• 不包含 BaseOrganization 到上下文中，代码优先创建三个表(对应于Table-Per-Concrete -类型或 TPC 模式)。 Include() 和 ThenInclude() 工作正常，我可以按预期列出工厂和遍历关系。
• 将 BaseOrganization 包含到上下文中，code-first 创建带有鉴别器字段的一个表(对应于表-按层次结构或 TPH 模式)。 Include() 和 ThenInclude() 抛出一个 Sequence contains more than one matching element 异常。

此问题(没有继承和抽象基类模式)已在 EF7 Github 存储库中得到解决，并已被清除(参见 https://github.com/aspnet/EntityFramework/issues/1460)。

所以我目前不知道我的方法是否有问题，或者这是否明显是 EF7 RC1 的问题？请注意，我真的更喜欢保留继承，以便我的 SQL 模型更具可读性。

下面是完整的复制代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using Microsoft.Data.Entity;

    namespace MultiLevelTest
    {
        // All places share name and Id
        public abstract class BaseOrganization
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }

        // a corporation (eg : Airbus Group)
        public class Corporation : BaseOrganization
        {
            public virtual ICollection<Company> Companies { get; set; } = new List<Company>();
        }

        // a company (eg : Airbus, Airbus Helicopters, Arianespace)
        public class Company : BaseOrganization
        {
            public virtual Corporation Corporation { get; set; }
            public virtual ICollection<Factory> Factories { get; set; } = new List<Factory>();
        }

        // a factory of a company (Airbus Toulouse, Airbus US...)
        public class Factory : BaseOrganization
        {
            public virtual Company Company { get; set; }
        }

        // setup DbContext
        public class MyContext : DbContext
        {
            // if this line is commented, then code first creates 3 tables instead of one, and everything works fine.
            public DbSet<BaseOrganization> BaseOrganizationCollection { get; set; }
            public DbSet<Corporation> Corporations { get; set; }
            public DbSet<Company> Companies { get; set; }
            public DbSet<Factory> Factories { get; set; }

            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlServer(
                    @"Server=(localdb)\mssqllocaldb;Database=MultiLevelTest;Trusted_Connection=True;MultipleActiveResultSets=true");
            }

            protected override void OnModelCreating(ModelBuilder modelBuilder)
            {
                base.OnModelCreating(modelBuilder);

                modelBuilder.Entity<Corporation>().HasMany(c => c.Companies).WithOne(c => c.Corporation);
                modelBuilder.Entity<Company>().HasMany(c => c.Factories).WithOne(c => c.Company);
                modelBuilder.Entity<Factory>().HasOne(f => f.Company);
            }
        }

        public class Program
        {
            public static void Main(string[] args)
            {
                using (var ctx = new MyContext())
                {
                    ctx.Database.EnsureDeleted();
                    ctx.Database.EnsureCreated();

                    // Add a corporation with companies then factories (this works fine)
                    if (!ctx.Corporations.Any()) CreateOrganizationGraph(ctx);

                    // Get all the factories without including anything (this is still working fine)
                    var simpleFactories = ctx.Factories.ToList();
                    foreach(var f in simpleFactories) Console.WriteLine(f.Name);

                    // Get all the factories including their mother company, then their mother corporation
                    var fullFactories = ctx.Factories
                        .Include(f => f.Company)
                        .ThenInclude(c => c.Corporation)
                        .ToList();
                    foreach (var f in fullFactories) Console.WriteLine($"{f.Company.Corporation.Name} > {f.Company.Name} > {f.Name}");
                }
            }

            public static void CreateOrganizationGraph(MyContext ctx)
            {
                var airbusCorp = new Corporation()
                {
                    Name = "Airbus Group",
                    Companies = new List<Company>()
                            {
                                new Company
                                {
                                    Name = "Airbus",
                                    Factories = new List<Factory>()
                                    {
                                        new Factory {Name = "Airbus Toulouse (FR)"},
                                        new Factory {Name = "Airbus Hambourg (DE)"}
                                    }
                                },
                                new Company
                                {
                                    Name = "Airbus Helicopters",
                                    Factories = new List<Factory>()
                                    {
                                        new Factory {Name = "Eurocopter Marignane (FR)"},
                                        new Factory {Name = "Eurocopter Deutschland (DE)"}
                                    }
                                }
                            }
                };

                ctx.Corporations.Add(airbusCorp);
                ctx.SaveChanges();

            }
        }
    }

您需要包含以下 NuGet 包:

"EntityFramework.Commands": "7.0.0-rc1-final",
"EntityFramework.Core": "7.0.0-rc1-final",
"EntityFramework.MicrosoftSqlServer": "7.0.0-rc1-final"

更新

如我自己的评论所述，我的第一个解决方法是避免在 DbContext 中包含基本类型，以便代码优先生成具有 TPC 模式的模式(错误仅在 TPH 策略中抛出)。

问题是上面的示例比我的实际实现更简单，它涉及在基类型级别定义的多对多关系。

由于 EF7(还？)不支持多对多关系，我们必须定义一个链接实体，它自己映射两个一对多关系。

在基类型级别定义和使用的映射实体，代码优先仍然选择 TPH 策略，然后错误仍然抛出。

换句话说，我被卡住了，或者我将不得不重复一些逻辑三次，这几乎就像故意打断自己的腿一样!

Answer 1

我认为您不应该尝试在您的案例中使用基类。

组织、公司、工厂代表不同的对象，从我在这里看到的情况来看，您正在尝试重构代码而不是抽象对象:

如果您创建一个存储作者和书籍的数据库，那么作者和书籍都会有一个名称和一个 ID，但是有一个基类有意义吗？

你肯定会节省几行代码，但它会降低你的代码可读性。

我认为当有真正的继承时你应该使用基类:

例如，您可以有一个基类 Person 和一个 Manager 和 Employee 类继承自 Person 类，因为员工和经理是人。

对我来说，你只需要删除你的基类，它就会按预期工作:

public class Corporation
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Company> Companies { get; set; } = new List<Company>();
}

public class Company
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Corporation Corporation { get; set; }
    public List<Factory> Factories { get; set; } = new List<Factory>();
}

public class Factory
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Company Company { get; set; }
}

public class MyContext : DbContext
{
    public DbSet<Corporation> Corporations { get; set; }
    public DbSet<Company> Companies { get; set; }
    public DbSet<Factory> Factories { get; set; }

    ...

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Corporation>().HasMany(c => c.Companies).WithOne(c => c.Corporation);
        modelBuilder.Entity<Company>().HasMany(c => c.Factories).WithOne(c => c.Company);
        modelBuilder.Entity<Factory>().HasOne(f => f.Company);
    }
}