c# - 如何使用 Entity Framework 映射具有实体集合的派生类

Question

如何将狗和猫映射到一组玩具而不是老鼠，因为它们'不是宠物吗？

public abstract class Animal {
    public int Id { get; set; }
}

public class Cat : Animal {
    public virtual ICollection<Toy> Toys { get; set; }
}

public class Dog : Animal {
    public virtual ICollection<Toy> Toys { get; set; }
}

public class Rat : Animal {

}

public class Toy {
    public int Id { get; set; }

    public string Name { get; set; }

    public Animal Owner { get; set; }

    public int OwnerId { get; set; }
}

我尝试使用流畅的映射，执行以下操作:

public class CatEntityConfiguration : EntityConfiguration<Cat> {
    public CatEntityConfiguration() {
        HasMany(c => c.Toys).WithRequired(t => t.Owner);
    }
}

但是 Owner 必须是 Cat 类型，而不是 Animal，但是当然，Dog 想要Owner 类型为 Dog，而不是 Animal 或 Cat。我可以在 Toy 上创建一个 Dog 和 Cat 属性，但这看起来像是一种 hack，而不是解决方案。

Answer 1

Entity Framework 的问题在于它希望实体之间有一个非常紧密的关系，它确实如此。如果您说“玩具:您可以将任何动物作为所有者，但只有某些动物类型会将您作为 child ' 然后 Entity Framework 将其读取为“我不能允许 Toy 隐式引用 Animal，因为 Animal 不知道任何事情关于 Toy，而Toy实际上与Cat或Dog相关。 '

解决此问题的最简单方法是使用 Toys 创建 Pet 类，然后创建 Cat 和 Dog > 继承 Pet 类，其中 Rat 仍然是 Animal:

public abstract class Animal
{
    public int Id { get; set; }
}

public abstract class Pet : Animal
{
    public virtual ICollection<Toy> Toys { get; set; }
}

public class Cat : Pet
{
    public string Name { get; set; }
}

public class Dog : Pet
{
    public int CollarColor { get; set; }
}

public class Rat : Animal
{

}

public class Toy
{
    public int Id { get; set; }
    public Pet Owner { get; set; }
}

EF 然后将创建一个 Pets 表，其中包含一个 Discriminator 列以及两个对象的属性(Dog) > 和 Cat 不再是数据库实体):

CREATE TABLE [dbo].[Pets] (
    [Id]            INT            IDENTITY (1, 1) NOT NULL,
    [Discriminator] NVARCHAR (128) NOT NULL,
    [Name]          NVARCHAR (MAX) NULL,
    [CollarColor]   INT            NULL,
    CONSTRAINT [PK_dbo.Pets] PRIMARY KEY CLUSTERED ([Id] ASC)
);

CreateTable(
    "dbo.Pets",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            Discriminator = c.String(nullable: false, maxLength: 128),
            Name = c.String(),
            CollarColor = c.Int(),
        })
    .PrimaryKey(t => t.Id);

当我们添加名为 Frank 的 Cat 时，我们得到:

Id  Discriminator   Name    CollarColor
1   Cat             Frank   NULL

如果您不喜欢这种数据库结构，另一种选择是创建一个 PetAttributes 类，其中每个 Pet 都有一个，然后 Toys 是该类的一部分，每个玩具都由 PetAttribute 拥有，然后生活继续。唯一的问题是您的导航变成了 Cat.Attributes.Toys，但您可以构建一个 get-only 属性来解决这个问题。

要删除该 Discriminator 列，我们可以添加:

modelBuilder.Ignore<Pet>();

然后构建一个新的但仍然不是最佳的数据库结构:

CreateTable(
    "dbo.Toys",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            Cat_Id = c.Int(),
            Dog_Id = c.Int(),
        })
    .PrimaryKey(t => t.Id)
    .ForeignKey("dbo.Cats", t => t.Cat_Id)
    .ForeignKey("dbo.Dogs", t => t.Dog_Id)
    .Index(t => t.Cat_Id)
    .Index(t => t.Dog_Id);

因此，最后一个选项是使用 Toys 创建一个 PetAttributes 类:

public abstract class Pet : Animal
{
    public PetAttributes Attributes { get; set; }
}

public class PetAttributes
{
    [Key]
    public int OwnerId { get; set; }

    [ForeignKey(nameof(OwnerId))]
    public Pet Owner { get; set; }

    public virtual ICollection<Toy> Toys { get; set; }
}

public class Toy
{
    public int Id { get; set; }
    public PetAttributes Owner { get; set; }
}

我们重写OnModelCreating:

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

    modelBuilder.Ignore<Pet>();
    modelBuilder.Entity<Pet>().HasRequired(p => p.Attributes).WithRequiredDependent(a => a.Owner);
}

我们得到了一个新的表结构:

CreateTable(
    "dbo.Cats",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            Name = c.String(),
            Attributes_OwnerId = c.Int(),
        })
    .PrimaryKey(t => t.Id)
    .ForeignKey("dbo.PetAttributes", t => t.Attributes_OwnerId)
    .Index(t => t.Attributes_OwnerId);

CreateTable(
    "dbo.PetAttributes",
    c => new
        {
            OwnerId = c.Int(nullable: false, identity: true),
        })
    .PrimaryKey(t => t.OwnerId);

CreateTable(
    "dbo.Toys",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            Owner_OwnerId = c.Int(),
        })
    .PrimaryKey(t => t.Id)
    .ForeignKey("dbo.PetAttributes", t => t.Owner_OwnerId)
    .Index(t => t.Owner_OwnerId);

然后，我们可以将更多属性移至 Pet 或 PetAttributes 中，并为它们创建仅 get 的属性(如果它们位于 中) >宠物属性:

public abstract class Pet : Animal
{
    public string Name { get; set; }

    public PetAttributes Attributes { get; set; }

    public ICollection<Toy> Toys => Attributes.Toys;
}

CreateTable(
    "dbo.Cats",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            Name = c.String(),
            Attributes_OwnerId = c.Int(),
        })
    .PrimaryKey(t => t.Id)
    .ForeignKey("dbo.PetAttributes", t => t.Attributes_OwnerId)
    .Index(t => t.Attributes_OwnerId);

CreateTable(
    "dbo.Dogs",
    c => new
        {
            Id = c.Int(nullable: false, identity: true),
            CollarColor = c.Int(nullable: false),
            Name = c.String(),
            Attributes_OwnerId = c.Int(),
        })
    .PrimaryKey(t => t.Id)
    .ForeignKey("dbo.PetAttributes", t => t.Attributes_OwnerId)
    .Index(t => t.Attributes_OwnerId);

正如我们所见，EF 使得将一个实体映射为多个其他实体关系的多个部分变得困难，但并非不可能。这主要是由于类型限制:EF 还使得在关系中很难因类型错误而出错。