EF Core 与级联删除的一对一可选关系 - 主体实体上的 FK

Question

I have two Entities and want to configure a 1:1 optional relationship that supports cascade one delete. One Episode can have one optional Release , but a Release can never exist without an Episode . So Episode should be the principal entity and Release the dependant entity, also whenever an Episode is deleted, the possible Release should also be deleted.

But since i have a lot of business logic that depends on whether the Episode has a Release and what the possible details are, i need the FK to be on Episode rather than on Release an do a lot of checks like someEpisode.ReleaseId.HasValue .

public class Episode
{
    public Guid Id { get; set; }
    // a lot of episode infos...

    public Release? Release { get; set; }
    public Guid? ReleaseId { get; set; }
}

public class Release
{
    public Guid Id { get; set; }
    // a lot of release infos
}

But using this entity definitions, i could not find a way to configure EF Core to meet my expectations stated above. Episode is always considered als dependant entity. As a workaround i currently delete the Release manually whenever an Episode has to be deleted.

Is it maybe impossible to place an FK on a principal entity, regardless of EF Core?

Thanks!

Answer 1

In 1:n associations it seems more intuitive to us that the independent entity, the parent, doesn't have a foreign key to its children. We immediately sense that one foreign key for many children can't be right. The children have a foreign key to the parent, obviously.

In 1:1 associations we somehow get lured into an object-oriented mindset more easily. It seems natural that if an independent (principal) entity owns a dependent entity, the former should "own" the foreign key. However, just as in 1:n, the dependent entity is the child and, hence, has a foreign key (see object–relational impedance mismatch ).

With this in mind, it's clear how the model and the mappings should be coded. For example (because there are options):

class Episode
{
    public Guid Id { get; set; }
    public Release? Release { get; set; }
}

class Release
{
    public Guid Id { get; set; }
    public Episode Episode { get; set; }
}

And the mapping:

modelBuilder.Entity<Release>()
    .HasOne(r => r.Episode)
    .WithOne(e => e.Release)
    .HasForeignKey<Release>();

The line HasForeignKey<Release>() turns Release into the dependent entity. By default, EF creates a shared primary key association in which Release 's primary key is also the foreign key:

CONSTRAINT [FK_Release_Episode_Id] FOREIGN KEY ([Id]) REFERENCES [Episode] 
    ([Id]) ON DELETE CASCADE

You can also have a separate foreign key:

modelBuilder.Entity<Release>()
    .HasOne(r => r.Episode)
    .WithOne(e => e.Release)
    .HasForeignKey<Release>("EpisodeID");

...which creates a Release.EpisodeID foreign key field in the database and a shadow property in the class model.

Another option is to create a foreign key relationship (reference and foreign key property in the class model):

class Release
{
    public Guid Id { get; set; }
    public Guid EpisodeId { get; set; }
    public Episode Episode { get; set; }
}

...which EF understands by convention, ie without explicit mapping, but could be mapped explicitly as:

modelBuilder.Entity<Release>()
    .HasOne(r => r.Episode)
    .WithOne(e => e.Release)
    .HasForeignKey<Release>(r => r.EpisodeId);

Finally, it's not necessary to have both reference properties in both classes. Either Episode.Release or Release.Episode can be omitted. In the latter case, mappings should have modelBuilder.Entity<Release>() as starting point.