如何使用Linq和EntityFramework 6在数据库中继承具有继承关系的类和同一表？

Question

我有一个用c＃ ， asp.net-mvc-5和Entity-framework-6编写的项目，并且具有以下类：

public class Profession
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }  
    public string Description { get; set; }
}

public class Person
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }  
    public string Name { get; set; }
}

public class Individuals : Person
{
    public string CPF { get; set; }
    public int Profession_Id { get; set; }
    [ForeignKey("Profession_Id")]
    public Profession Profession { get; set; }
}

public class Corporate : Person
{
    public string CNPJ { get; set; }
}

我的DbContext类是：

public class Context : DbContext
{
    public Context() : base("AppConnectionString") { }

    public DbSet<Profession> Professions { get; set; }
    public DbSet<Person> People { get; set; }
    public DbSet<Individuals> Individuals { get; set; }
    public DbSet<Corporate> Corporations { get; set; }
}

在运行应用程序时，将使用以下结构生成数据库：
表People和列Id ， Name ， CNPJ ， CPF和Discriminator CNPJ 。 以及具有Id和Description列的表Professions 。

这是我的示例项目：

public class Program
{
    public static void Main(string[] args) {
        var context = new Context();
        GenerateDatabase(context);

        // display the data

        System.Console.ReadKey();
    }

    private static void GenerateDatabase(Context context) 
    {
        if (!context.Database.Exists()) 
        {
            context.Database.Create();

            var p1 = new Profession { Description = "Profission 1" };
            var p2 = new Profession { Description = "Profission 2" };
            context.Professions.Add(p1);
            context.Professions.Add(p2);

            context.SaveChanges();

            context.Individuals.Add(new Individuals { Name = "People 1", CPF = "CPF Teste 1", Profession_Id = p1.Id });
            context.Individuals.Add(new Individuals { Name = "People 2", CPF = "CPF Teste 2", Profession_Id = p2.Id });
            context.Corporations.Add(new Corporate { Name = "Person 1", CNPJ = "CNPJ Teste 1" });
            context.Corporations.Add(new Corporate { Name = "Person 2", CNPJ = "CNPJ Teste 2" });

            context.SaveChanges();
        }
    }
}

好吧，在Main方法中，我有以下代码片段来显示数据：

var items = context.People.OfType<Individuals>();
foreach (var item in items)
    System.Console.WriteLine(item.Id.ToString() + " | " + item.Name + " | " item.Profession.Description + " | " + item.GetType().Name);

var items2 = context.People.OfType<Corporation>();
foreach (var item in items2)
    System.Console.WriteLine(items2.Id.ToString() + " - " + items2.Name);

我需要连接才能对结果进行排序。
在此示例中，按类的Name属性排序的结果不正确。

+----+----------+--------------+--------------+
| ID | Name     | Profession   | Discriminator|
+----+----------+--------------+--------------+
|  1 | Person 1 | Profission 1 | Individuals  |
|  2 | Person 2 | Profission 1 | Individuals  |
|  3 | Person 1 |              | Corporate    |
|  4 | Person 2 |              | Corporate    |
+----+----------+--------------+--------------+

我需要收集两种类型的记录才能显示在查询页面中。 因此，正如被告知要做一个Union all一样，他也想尝试Concat 。

不久，我测试了以下内容：

var items = context.People.OfType<Individuals>().Include(x => x.Profession).Concat<Individuals>(
    context.People.OfType<Corporate>().Select(x => new Corporate
    {
        Id = x.Id,
        Name = x.Name,
        CNPJ = x.CNPJ
    }));

items = items.OrderBy(x => x.Name);

但这是错误的，无法编译！

如何使用Queryable完成此操作？

Answer 1

一级解决方案是将“ Individuals和“ Corporate回基类，如下所示：

var items = 
    context.Individuals.Select(x => (Person)x)
    .Concat(context.Corporations.Select(x => (Person)x))
    .OrderBy(x => x.Name);

这会给你的枚举Person的对象，这可能是任何一个子类： Individuals或Corporate 。 强制转换为通用基类可以解决兼容性问题，但是现在您只能使用基类上可用的那些属性。 如果您需要访问特定于一个或其他子类的属性（例如，对“ Individuals对象的Profession参考），则需要对每个项目进行类型检查，以弄清具体的类型。

简单显示：

foreach (var person in items)
{
    Console.WriteLine("{0,-6}{1,-12}{2}", person.Id, person.Name, person.GetType().Name);
}

使用上面的数据，应显示：

1     Person 1    Individuals
3     Person 1    Corporate
2     Person 2    Individuals
4     Person 2    Corporate

---

正如评论中所讨论的，将对象强制转换为Person类型是在原始查询中的Include()语句之前完成的，当Entity Frameworks找不到People类的Profession属性时，这会在运行时导致错误。

我看到了三种解决方法：

1. 让EF将其作为延迟加载进行处理。

2. 添加一个在转换之前将数据强制进入内存的操作

3. 使用其他类型的结果。

第一种选择是根本不在查询中包含Profession属性，而让Entity Frameworks为您完成工作。 这是用于快速n脏查询的惰性方法，您希望只返回少量记录。 每当您首次引用Individuals对象的Profession属性时，EF都会向数据库服务器查询。 对于大量的记录，这是一个坏主意。 如果您有1000条Individuals记录，则必须再运行1000条SQL查询。

第二个选项如下所示：

var items = 
    context.Individuals.Include("Profession").ToArray().Select(x => (Person)x)
    .Concat(context.Corporations.Select(x => (Person)x)
    .OrderBy(x => x.Name);

表达式中间的ToArray操作将告诉EF停止构建查询并继续获取数据，并返回Individuals[]数组。 不幸的是，这对于大型数据集而言效率很低。

最后的选择：

var items =
    context.Individuals.Select(x => new 
        { 
            Id = x.Id, 
            Name = x.Name, 
            Profession = x.Profession.Description, 
            Type = "Individual" 
        })
    .Concat(context.Corporations.Select(x => new 
        { 
            Id = x.Id, 
            Name = x.Name, 
            Profession = (string)null, 
            Type = "Corporation" 
        }))
    .OrderBy(x => x.Name).ThenBy(x => x.Id);

我使用了兼容的匿名类型-相同的字段名称和类型以相同的顺序-但您也可以使用特定的结果记录结构或类。 如果所有处理都在本地进行，则使用匿名类型；如果要在方法之外传递信息，则使用结果struct / class。

总的来说，我认为最后一个是3中最好的。使用中间类型来存储结果，比起类型转换，将数据强制进入内存等，您会得到更好的结果。获得更高效的查询，因为只有您在查询中请求的那些字段才会从服务器返回。 当您只想从具有很多列的表中获得两列时，该功能很好。 当您使用50列以上的表格设计时，会产生很大的不同。

顺便说一句，我最初打印person.GetType().Name想法person.GetType().Name 。 EF子类化了您的类，因此，您得到的类型（以及因此的名称）将是丑陋的混搭。 第三个选项通过显式设置值来解决此问题。