如何表示同一类型的父属性和多个子属性之间的关系？

Question

考虑以下两个实体^*：

public class Parent
{
    public int Id { get; set; }
    public string Name { get; set; }

    public virtual Child PrimaryChild { get; set; }
    public virtual Child SecondaryChild { get; set; }
}

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }

    // Foreign keys to be added here or
    // in the other class (that's what I'm trying to figure out)
}

如代码所示，父母需要有一个主要孩子和一个次要孩子；并且（最好）当父级被删除时，两个子级也应该被删除。

甚至可以用EF表示这种关系吗？

如果父母只有一个孩子，我可以通过将Child 的主键转换为 PK 和 FK 来轻松使用一对一关系 (1 to 0..1)。显然，这不适用于当前的情况，因为一个主键不能有多个值。

感觉这是一种足够普遍的情况，它应该有一个众所周知的解决方案。但是，查了无数个帖子，还是没有找到。我能找到的最接近的东西是this answer，但它不起作用，因为：

1. 它创建* to 0..1 关系。

2. 当我忽略这个事实并尝试执行以下代码时：

   var c1 = new Child { Name = "C1" };
   var c2 = new Child { Name = "C2" };
   context.Parents.Add(new Parent { Name = "P1", PrimaryChild = c1, SecondaryChild = c2 });
   

   ...它抛出了一个带有消息的 DbUpdateException：

   无法确定相关操作的有效顺序。由于外键约束、模型要求或存储生成的值，可能存在依赖关系。

如何解决这个问题？

---

^*_{这是一个简化的例子。在现实生活场景中，父实体和其他子实体之间存在关系，每个子实体有两个或多个引用。}

Answer 1

此代码已在 Visual Studio 中测试并正常运行

var c1 = new Child { Name = "C1" };
var c2 = new Child { Name = "C2" };
_context.Parents.Add(new Parent { Name = "P1", PrimaryChild = c1, SecondaryChild = c2 });

var parents = _context.Parents
               .Include(i => i.PrimaryChild)
               .Include(i => i.SecondaryChild)
               .ToList();

要尝试它，你必须向你的类添加关系

public class Parent
{
    [Key]
    public int Id { get; set; }
    public string Name { get; set; }

    public int? PrimaryChildId { get; set; }
    public int? SecondaryChildId { get; set; }

    [ForeignKey(nameof(PrimaryChildId))]
    [InverseProperty("PrimaryChildParents")]
    public virtual Child PrimaryChild { get; set; }

    [ForeignKey(nameof(SecondaryChildId))]
    [InverseProperty("SecondaryChildParents")]
    public virtual Child SecondaryChild { get; set; }
}

public class Child
{
    [Key]
    public int Id { get; set; }
    public string Name { get; set; }

    [InverseProperty(nameof(Parent.PrimaryChild))]
    public virtual ICollection<Parent> PrimaryChildParents { get; set; }

    [InverseProperty(nameof(Parent.SecondaryChild))]
    public virtual ICollection<Parent> SecondaryChildParents { get; set; }
}

如果您想进行一对一，并且因为您使用的是 EF6 您可以为外键添加一些约束

[Index("IX_Parents_PrimaryChildId", 1, IsUnique = true)]
public int? PrimaryChildId { get; set; }
      
[Index("IX_Parents_SecondaryChildId", 2, IsUnique = true)]
public int? SecondaryChildId { get; set; }

Answer 2

我想出了一个老套的解决方案，但我仍然希望有一个更好的解决方案。

我创建了一个很好的旧的一对多关系，而不是一对一关系（Parent 有很多 Child），并在 Child 类中使用一个属性来存储类型（primary/ secondary)，并在Parent 类中创建了未映射的属性来替换原来的导航属性。

问题示例的代码如下所示：

Child类：

public enum ChildType { Primary, Secondary }

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }

    public ChildType ChildType { get; set; }

    [ForeignKey("Parent")]
    public int ParentId { get; set; }
    public virtual Parent Parent { get; set; }
}

Parent类：

public class Parent
{
    public Parent()
    {
        Children = new HashSet<Child>();
    }
    public int Id { get; set; }
    public string Name { get; set; }

    public virtual ICollection<Child> Children { get; set; }

    [NotMapped]
    public Child PrimaryChild
    {
        get
        {
          return Children.SingleOrDefault(c => c.ChildType == ChildType.Primary);
        }
        set
        {
         var existingChild = 
                Children.SingleOrDefault(c => c.ChildType == ChildType.Primary);
            if (existingChild != null) Children.Remove(existingChild);

            Children.Add(value);
        }
    }

    [NotMapped]
    public Child SecondaryChild
    {
        get
        {
            return Children.SingleOrDefault(c => c.ChildType == ChildType.Secondary);
        }
        set
        {
            var existingChild = 
                Children.SingleOrDefault(c => c.ChildType == ChildType.Secondary);
            if (existingChild != null) Children.Remove(existingChild);

            Children.Add(value);
        }
    }
}

用法：

var c1 = new Child { Name = "C1", ChildType = ChildType.Primary };
var c2 = new Child { Name = "C2", ChildType = ChildType.Secondary };
context.Parents.Add(new Parent { Name = "P1", PrimaryChild = c1, SecondaryChild = c2 });

显然，这并不强制规定父母可以拥有的孩子的最小或最大数量或 ChildType 他们必须是什么。这是我能想到的最好的了。

Answer 3

有两种方法可以创建这种关系：

1. Parent 对各自的孩子有两个外键，与您所做的接近。
2. 子项对父项具有外键，这将是一个简单的一对多。

第一个选项很容易将父母限制为两个孩子，并且很容易区分主要和次要孩子。

第二个选项，如果您需要区分主要和次要对象，则需要为子对象添加一个类型。使用父母的 Id 和类型作为唯一索引将允许您将孩子限制为每个父母一个主要和一个次要孩子。

现在就删除父级而言，如果您对关系进行级联删除，它将自动发生。我知道在第二个选项中，简单的一对多，级联删除将按预期工作。第一个选项，基本上是两个一对一的关系，您可以设置级联删除，但我怀疑您需要确保它是单向级联。例如如果父项被删除，则子项也会被删除，但如果子项被删除，则父项应该保留。

我会倾向于拥有外键和类型的孩子。所以沿着这些思路：

public class Parent
{
    public int Id { get; set; }
    public string Name { get; set; }

    public virtual ICollection<Child> Children { get; set; }
}

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }

    [Index("IX_Child_Parent_Type", 1, IsUnique = true)]
    public int ParentId { get; set; }
    public virtual Parent Parent { get; set; }
    
    [Index("IX_Child_Parent_Type", 2, IsUnique = true)]
    public int ChildTypeId { get; set; }
    public virtual ChildType Type { get; set; }
}

public class ChildType
{
    public int Id { get; set; }
    public string Name { get; set; }
}

另一个选项如下所示：

public class Parent
{
    public int Id { get; set; }
    public string Name { get; set; }

    public virtual Child PrimaryChild { get; set; }
    public virtual Child SecondaryChild { get; set; }
}

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Answer 4

对实体进行一些小修改，并使用 fluent api 指定一对多关系

public class Parent
{
    public int Id { get; set; }
    public string Name { get; set; }

    public virtual IEnumerable<Child> Children { get; set; }
}

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsPrimary {get; set;}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
       modelBuilder.Entity<Parent>()
            .HasKey(p => p.Id)
            .WithMany(p => p.Child)
            .HasForeignKey(s => s.ParentId);
    }
    
    public DbSet<Child> Children{ get; set; }

Answer 5

试试这个方法，

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
  // this class will represent a person, a parent or a child since they have the same attributes
  class Person
  {
    protected int _id;
    protected string _name; 
    public int Id { get => _id; }
    public string Name { get => _name; }
    // Any object wether it's a parent or a child must be instantiated with those properties
    public Person(int id, string name)
    {
      this._id = id;
      this._name = name;
    }
  }

  // this represents a parent which is a persone but have two persons reprenseting it's children. the children can't be instanciated alone.
  class Parent : Person
  {
    private Person _primaryChild;
    private Person _secondaryChild;
    public Person PrimaryChild { get => _primaryChild; }
    public Person SecondaryChild { get => _secondaryChild; }

    // this creates the parent with it's children. one the parent dispose its children will be deleted.
    public Parent(Person parent, Person primaryChild, Person secondaryChild) : base( parent.Id,  parent.Name)
    {
      // this primaryChild enforce that a parent must have two different children to represents a primary and a secondry child.
      if(primaryChild.Id != secondaryChild.Id)
      {
        this._id = parent.Id;
        this._name = parent.Name;
        this._primaryChild = primaryChild;
        this._secondaryChild = secondaryChild;
      }
      else
      {
        throw new Exception("Children must not be tweens.");
      }
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      // instanciating a person does'nt represent an actor in the process. A parent must be instianciated.
      try
      {
        // creating a new parent with its related children
        var parent = new Parent(new Person(1, "Parent"), new Person(1, "ChildOne"), new Person(2, "ChildTwo"));
        // diplaying children names
        Console.WriteLine($"Primary Child is {parent.PrimaryChild.Name}. Secondary Child is {parent.SecondaryChild.Name}.");
      }
      catch (Exception e)
      {

        Console.WriteLine(e.Message);
      }
       
    }
  }
}

Answer 6

子类应该包含父类的外键，在本例中，我使用复合键来表示一对一关系。

public class Child
{
    [Key]
    [Column(Order = 1)]
    public int Id { get; set; }
    public string Name { get; set; }

    [Key, ForeignKey("Parent")]
    [Column(Order = 2)]
    public int ParentId { get; set; }
}

然后在您的上下文的 OnModelCreating 中，您需要设置约束。

protected override void OnModelCreating(DbModelBuilder modelBuilder) {

        modelBuilder.Entity<Parent>()
                .HasRequired(e => e.PrimaryChild)
                .WithRequiredPrincipal(e => e.Parent);

        modelBuilder.Entity<Parent>()
                .HasRequired(e => e.SecondaryChild)
                .WithRequiredPrincipal(e => e.Parent);

         modelBuilder.Entity<Child>()
            .HasKey(e => e.ParentId);
}

您可以根据需要扩展它。