实体框架1到0或1关系配置

Question

I have this class

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

and a child class

public class Child
{
  [Key]
  [ForeignKey]
  public int ParentId { get; set; }
  public string Name { get; set; }
  public virtual Parent Parent { get; set; }
}

The relation is such that a parent can have either 0 or 1 child. I've checked SO and found two solutions.

modelBuilder.Configurations.Add(new ParentChildMap());

// solution 1
class ParentChildMap : EntityTypeConfiguration<Child>
{
    public ParentChildMap()
    {
        HasRequired(t => t.Parent).
            WithRequiredDependent(t => t.Child);    
    }
}

// solution 2
class ParentChildMap : EntityTypeConfiguration<Child>
{
    public ParentChildMap()
    {
         HasOptional(c => c.Parent)
            .WithRequired(c => c.Child);
    }
}

And the thing is, they are both working ! But the problem is, I am not sure which one is correct. Which one is providing me the mapping that one parent can have only 0 or 1 child. And then, what is the other one saying?

Answer 1

Let add the related entities to the desired relationship along with their cardinality:

Parent 1 <--> 0..1 Child

You can read it this way:

(1) --> 0..1 Child means that each Parent can have 0 or 1 Child, or in other words, the Child property of the Parent entity is optional

(2) Parent 1 <-- means that each Child always have 1 Parent, or in other words, the Parent property of the Child entity is required .

The fluent configuration which corresponds to the above from Child side is:

HasRequired(c => c.Parent).WithOptional(p => p.Child);

or alternatively from Parent side:

HasOptional(p => p.Child).WithRequired(c => c.Parent);

These two are the correct ones and fully equivalent - you can use one or the another depending of whether you start the configuration from Child (as in your sample) or from Parent . To avoid discrepancies, never do both.

Why both your current solutions are incorrect?

Because:

(solution 1)

HasRequired(t => t.Parent).WithRequiredDependent(t => t.Child);

represents Parent 1 <--> 1 Child relationship (parent must have always 1 child).

(solution 2)

HasOptional(c => c.Parent).WithRequired(c => c.Child);

represents Parent 0..1 <--> 1 Child relationship (child can have 0 or 1 parent, parent must have always 1 child), ie the opposite of what you want.

Answer 2

And the thing is, they are both working! But the problem is, I am not sure which one is correct?

Yes! your both approach is incorrect (Credit goes to Ivan Stoev). Because:

Your solution 1 :

HasRequired(t => t.Parent).WithRequiredDependent(t => t.Child);

represents Parent 1 <--> 1 Child relationship (parent must have always 1 child).

Your solution 2:

HasOptional(c => c.Parent).WithRequired(c => c.Child);

represents Parent 0..1 <--> 1 Child relationship (child can have 0 or 1 parent, parent must have always 1 child), ie the opposite of what you want.

Your Fluent API should be as follows:

modelBuilder.Entity<Parent>()
                .HasOptional(p => p.Child) // Mark Child property optional in Parent entity
                .WithRequired(c => c.Parent); // mark Parent property as required in Child entity. Cannot save Child without Parent

Moreover you can also configure One-to-One or One-to-Zero relationship with Data Annotation as follows:

Child class should be as follows:

public class Child
{
  [Key,ForeignKey("Parent")]
  public int ParentId { get; set; }
  public string Name { get; set; }
  public virtual Parent Parent { get; set; }
}

Answer 3

you don't need to decorate ForeignKey attribute. if you want to have a 1 to 0 relation, a side of relation must be optional (ex: HasOptional), like the following code:

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

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



public class ParentMap : EntityTypeConfiguration<Parent>
{
    public ParentMap ()
    {
        HasOptional(t => t.Child).WithRequired(t => t.Parent);
    }
}

now when you add a new parent to the database does not need to add a child because it is optional but when you want to add a new child to the database the child Id must equal with parent Id .