One to zero-or-one with HasForeignKey

c# entity-framework fluent-entity-framework

Question

I have two models:

public class Person
{
    public virtual int Id { get; set; }
    public virtual Employee Employee { get; set; } // optional
}

public class Employee
{
    public virtual int Id { get; set; }
    public virtual int PersonId { get; set; }

    public virtual Person Person {get; set; } // required
}

public class EmployeeConfiguration : EntityTypeConfiguration<Employee>
{
    public EmployeeConfiguration()
    {
        Property(e=>e.PersonId) // I need this property mapped
            .HasColumnName("person_id")
            .HasColumnType("int");
    }
}

I want to map them using fluent mapping. Employee table has column 'person_id' which is non-nullable. I tried following:

HasRequired(e => e.Person)
    .WithOptional(p => p.Employee)
    .Map(m => m.MapKey("person_id"));

But it fails with:

System.Data.Entity.ModelConfiguration.ModelValidationException : One or more validation errors were detected during model generation:

person_id: Name: Each property name in a type must be unique. Property name 'person_id' is already defined.

I need PersonId property on its own, so what I basically want is:

HasRequired(e => e.Person)
    .WithOptional(p => p.Employee)
    .HasForeignKey(e => e.PersonId); // there is no such method

But there is no such method here as HasForeignKey

1
31
8/31/2015 2:31:04 PM

Accepted Answer

OK, I figured that out - you should use WithMany (yep, not obvious) in order to store foreign key in some property:

Property(e => e.PersonId).HasColumnName("person_id");
HasRequired(e => e.Person)
    .WithMany()
    .HasForeignKey(p => p.PersonId);

See One-to-One Foreign Key Associations article for details. BTW this will create employee foreign key column for person's table, but there is no other way to have navigation property and foreign key separately.


If you need foreign key read-only, you can change PersonId property to:

public int PersonId { get { return Person.Id; } }

And use your original mapping

HasRequired(e => e.Person)
    .WithOptional(p => p.Employee)
    .Map(m => m.MapKey("person_id"));
51
9/10/2013 1:59:56 PM

Popular Answer

There's actually a better way to do this:

HasKey(e => e.PersonId);

HasRequired(e => e.Person)
    .WithOptional(p => p.Employee);

Note that you no longer need the Employee.Id property with this approach, as it was superfluous in terms of a 1 to 0 or 1 relationship in the first place.



Related Questions





Related

Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow