EF won't update tables based on my model

Question

At first I created a Person model which only contained the basic properties:

[Table("SGDB_Persons")]
public class Person {
    public int Id { get; set; }

    [Required]
    public string Firstname { get; set; }

    [Required]
    public string Lastname { get; set; }

    [Required]
    public Department Department { get; set; }

    [Required]
    public SourceType SourceType { get; set; }

After I noticed I'm missing something I've added a new PersonData Property:

[Required]
    public PersonData PersonData { get; set; }

Unfortunately EF won't update the Database at all - PersonData which at first contained an object of type Person got updated so there is no Person property anymore. On the other hand, EF does not create a new Column for PersonData_Id.

Additionally the ID column is not auto-incrementing (all other table's Id Column do). What's confusing me is the following Constraing which gets created inside my Person table:

CONSTRAINT [FK_dbo.SGDB_Persons_dbo.SGDB_PersonData_Id] FOREIGN KEY ([Id]) REFERENCES [dbo].[SGDB_PersonData] ([Id])

I tried everything (at least I think so). I dropped all tables / the whole database manually, reinstalled EF, executed manual migrations but nothing seems to work.

I think it's this problem which causes me to not be able to seed my database with the following code:

protected override void Seed(PersonContext context) {
        base.Seed(context);
        var dep = new DepartmentContext().Departments.First();

        var status = new Status("Test");
        var persondata = new PersonData(status);
        context.Status.Add(status);
        context.PersonData.Add(persondata);
        for (int i = 0; i < 10; i++) {
            var person = new Person {
                Firstname = $"TestPersonFirstname{i}",
                Lastname = $"TestPersonLastname{i}",
                SourceType = COM.SourceType.Manual,
                Department = dep,
                PersonData = persondata
            };
            context.Persons.Add(person);
        }
        context.SaveChanges();
    }

Everytime this code get's executed I'm getting an Exception:

The member with identity 'SGDB.DAL.Contexts.Person_Department' does not exist in the metadata collection. Parameter name: identity.

I don't know if both problems are related to the same problem but both need to be resolved :)

Thanks in advance!

Update 1

My Solution is divided into a few different Projects:

BLL, DAL, COM, UI

DataContexts are located inside the DAL project, Models inside the COM project.

Department Model:

[Table("SGDB_Departments")]
public class Department {
    public int Id { get; set; }

    [Required]
    public string Costcenter { get; set; }

    [Required]
    public string Abbreviation { get; set; }

    public string Description { get; set; }

    public string FullDepartmentName {
        get {
            return $@"{Division.Abbreviation}\{Abbreviation}";
        }
    }
    [Required]
    public virtual Division Division { get; set; }
}

PersonData Model:

[Table("SGDB_PersonData")]
public class PersonData {
    public PersonData(Status status) {
        Status = status;
    }

    public int Id { get; set; }
    public DateTime Limit { get; set; }
    public Person Responsible { get; set; }
    [Required]
    public Status Status { get; set; }
}

The Person table (as you can see) has got a Department_Id column (EF inserted automatically).

Clarification

A Person object contains a PersonData object as additional Information for this Person. A Person may / may not has a Responsible Person (so PersonData.Responsible is not a Navigation Property to the Parent Person). Additionaly if possible I don't want to have a foreign Key inside the PersonData table.

As I figured out I'd have to modify

modelBuilder.Entity<Person>()
       .HasRequired(e => e.PersonData)
       .WithRequiredPrincipal(e => e.Responsible)
       .WillCascadeOnDelete(true);

to

modelBuilder.Entity<Person>()
       .HasRequired(e => e.PersonData)
       .WithMany()
       .WillCascadeOnDelete(true);

I'll try this and report in if it solved my problem.

Update 2

The member with identity 'SGDB.DAL.Contexts.Person_Department' does not exist in the metadata collection.

Answer 1

Your model defines one-to-one relationship between Person and PersonData with later being required and the former - optional. EF always uses the required side of the one-to-one relationship as principal and optional part as dependent. Hence it thinks PersonaData is the principal and Person - dependent and reflects that in database table design.

You need the opposite and also both sides being required. When both sides are required or optional, EF cannot automatically derive the principal/dependent side and there is no way to specify that via data annotations (attributes), so you need a fluent API setup.

Override your DbContext OnModelCreating and add something like this:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Person>()               
        .HasRequired(e => e.PersonData)
        .WithRequiredPrincipal(e => e.Responsible)
        .WillCascadeOnDelete(true);

    base.OnModelCreating(modelBuilder);
}

What it does is to tell EF that both sides of the Person->PersonData relationship are required and Person is the principal. This should make again your Person.Id column auto-increment and should resolve the person-data part of the problem.

The other thing I've noticed is this line:

var dep = new DepartmentContext().Departments.First();

while all other parts of the same procedure are using a variable called context. This might/might not be a problem, just check it out.

UPDATE: From the clarification in the updated question it turns out you have two relationships between Person and PersonData, so you need separate configuration for each of them like this:

modelBuilder.Entity<Person>()
    .HasRequired(e => e.PersonData)
    .WithRequiredPrincipal()
    .WillCascadeOnDelete(true);

modelBuilder.Entity<PersonData>()
    .HasOptional(e => e.Responsible)
    .WithOptionalDependent() // or WithMany()
    .WillCascadeOnDelete(false);

Please note that there is no way to not introduce additional FK column in the PersonData table. It's needed to represent the Responsible relation, so you'll end up with a table column called Responsible_Id.