Resolving TPH Inheritance and Migration Issues in Entity Framework Core with Multi-Project Architecture

Question

Resolving TPH Inheritance and Migration Issues in Entity Framework Core with Multi-Project Architecture

Laurent Guigon 311

Hello,

I’m working on a multi-project architecture with models and data access layers in separate .csproj files (These are Classes Libraries.) Using EF Core 8 and TPH inheritance, I encounter the following error when running Add-Migration in VS2022:

Unable to create a 'DbContext' of type 'ContentDbContext'. The exception 'The collection navigation 'Paragraphs' cannot be added to the entity type 'Summary' because its CLR type 'ICollection<SummaryParagraph>' does not implement 'IEnumerable<ParagraphBase>'. Collection navigations must implement IEnumerable<> of the related entity.'

This seems related to my TPH configuration. Below is an outline of the code setup.

Relevant Code

Model Interfaces

public interface IParagraph
{
 string Content { get; set; }
} 
public interface IHasParagraphs<T> where T : IParagraph
{
 ICollection<T> Paragraphs { get; set; }
}

Abstract Base Class

public abstract class ParagraphBase : TopicStructureBase, IOrderable, IParagraph
{
    public enum ParagraphParentType { ParagraphBlock, Summary }
    public ParagraphParentType? ParentType { get; set; }
    public int DisplayOrder { get; set; }
    public string Content { get; set; } = string.Empty;
}

Derived Classes

public class SummaryParagraph : ParagraphBase
{
    public Guid SummaryId { get; set; }
    public virtual Summary Summary { get; set; } = new();
}

public class ContentParagraph : ParagraphBase
{
    public Guid ParagraphBlockId { get; set; }
    public virtual ParagraphBlock Block { get; set; } = new();
}

Aggregates

public class Summary : IdentifiableEntityBase, IHasParagraphs<SummaryParagraph>
{
    public virtual ICollection<SummaryParagraph> Paragraphs { get; set; } = new HashSet<SummaryParagraph>();
}

public class ParagraphBlock : TopicElementBase, IHasParagraphs<ContentParagraph>
{
    public virtual ICollection<ContentParagraph> Paragraphs { get; set; } = new HashSet<ContentParagraph>();
}

Entity Configuration

public void Configure(EntityTypeBuilder<ParagraphBase> builder)
{
    builder.HasDiscriminator(p => p.ParentType)
           .HasValue<ContentParagraph>(ParagraphParentType.ParagraphBlock)
           .HasValue<SummaryParagraph>(ParagraphParentType.Summary);

    builder.HasOne<Summary>()
           .WithMany(s => s.Paragraphs)
           .HasForeignKey(sp => ((SummaryParagraph)sp).SummaryId);

    builder.HasOne<ParagraphBlock>()
           .WithMany(pb => pb.Paragraphs)
           .HasForeignKey(cp => ((ContentParagraph)cp).ParagraphBlockId);
}

What I’ve Tried

Moving foreign key properties (SummaryId, ParagraphBlockId) and navigation properties into the base class. This resolves the error but breaks specialization, as it forces all derived classes to share these properties.
Simplifying the configuration by defining relationships directly in OnModelCreating. This avoids IEntityTypeConfiguration<T> but does not address the root issue.
Searching online and using tools like ChatGPT, but without finding a definitive answer.

What I Need Help With

Foreign Key Properties: Must SummaryId and ParagraphBlockId be in the base class for TPH to work? If so, why does EF Core require this?
Compatibility Issues: Are there changes in EF Core 9 that could affect this configuration?
Alternative Approaches: Is there a way to resolve this issue while maintaining proper separation of concerns?

Anonymous

2024-12-09T09:56:32.95+00:00

Hi,@Laurent Guigon. Welcome to Microsoft Q&A.

I'm investigating and it will take some time. Please wait and I will get back to you as soon as I find something.

2 answers

Your answer

Anonymous

2024-12-09T09:56:32.95+00:00

Hi,@Laurent Guigon. Welcome to Microsoft Q&A.

I'm investigating and it will take some time. Please wait and I will get back to you as soon as I find something.

Answer 1

Anonymous

Hi, @Laurent Guigon.

Foreign key properties

Foreign key properties (such as SummaryId and ParagraphBlockId) do not necessarily need to be in the base class. The official documentation on TPH does not clearly state the requirements for foreign keys.

Compatibility issues

No compatibility issues with EF Core 9 have been found so far. EF Core 9 does have major adjustments to TPH, but it affects Azure Cosmos DB. After testing the rollback version, the problem still occurs.

Alternative methods:

No better alternative methods have been found without modifying the table structure.

Currently available directions to try:

Do not use TPH, directly set the EntityConfig of ContentParagraph and SummaryParagraph, and the properties of the subclass inheriting the parent class will still be generated in the database. However, due to the relationship between foreign keys, you will get an error when executing dotnet ef database update, so you still need to adjust the design of foreign keys.
Re-adjust the table structure. If the table itself needs to implement a one-to-many relationship, consider using an attribute to save the associated Id.

If the answer is the right solution, please click "Accept Answer" and kindly upvote it. If you have extra questions about this answer, please click "Comment".

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Laurent Guigon 311

Hi,
May be I should Provide the original error message

Unable to create a 'DbContext' of type 'ContentDbContext'. The exception 'The collection navigation 'Paragraphs' cannot be added to the entity type 'Summary' because its CLR type 'ICollection<SummaryParagraph>' does not implement 'IEnumerable<ParagraphBase>'. Collection navigations must implement IEnumerable<> of the related entity.' was thrown while attempting to create an instance. For the different patterns supported at design time

I give you an old version of my code. TPH was ok with this one.

Relevant CodeModel Interfaces

public interface IParent
{
    Guid ParentId { get; set; }
}
public interface IAlineasContainer<T> where T : IAlinea
{
    ICollection<T> Alineas { get; set; }
}
public interface IAlinea
{
    string Content { get; set; }
    Guid? ReplacedById { get; set; }
    Guid? ReplacesId { get; set; }
}

Abstract Base Class

public abstract class AlineaBase : TopicBase, IUtoYearDisplay, IOrderedDisplay, IAlinea
{
    public enum AlineaParentType
    {
        Paragraph,
        Summary
    }
    public string Content { get; set; }
    public Guid? ReplacedById { get; set; }
    public virtual AlineaBase? ReplacedBy { get; set; }
    public Guid? ReplacesId { get; set; }
    public virtual AlineaBase? Replaces { get; set; }
    public int? DisplayEndYearUto { get; set; }
    public int? DisplayStartYearUto { get; set; }
    public int DisplayOrder { get; set; }
    public AlineaParentType ParentType { get; set; }
    public virtual object Parent { get; set; }
}

Derived Classes

public class ParagraphAlinea : AlineaBase
{
    public Guid ParagraphId { get; set; }
    public virtual Paragraph Parent { get; set; }
}
public class SummaryAlinea : AlineaBase
{
    public Guid SummaryId { get; set; }
    public virtual Summary Parent { get; set; }
}

Aggregates

public class Paragraph : IllustratedTopicSubdivisionBase, IAlineasContainer<ParagraphAlinea>, IDraftable
{
    public bool IsDraft { get; set; } = true;
    public virtual Article Parent { get; set; }
    public virtual ICollection<ParagraphAlinea> Alineas { get; set; }
}
public class Summary : IdentifierModelBase, IAlineasContainer<SummaryAlinea>, IParent, IDraftable, IIllustratable
{
    public Guid ParentId { get; set; }
    public bool IsDraft { get; set; } = true;
    public virtual Topic Parent { get; set; }
    public virtual ICollection<SummaryAlinea> Alineas { get; set; }
    public Guid? IllustrationAssociationId { get; set; }
    public virtual IllustrationAssociation? Illustration { get; set; }
}

Entity Configuration

private void ConfigureEntities(ModelBuilder modelBuilder)
{
    //Other code
    ConfigureAlineaTablePerHierarchy(modelBuilder);
    ConfigureZeroOrOneToManyRelationships(modelBuilder);
    ConfigureOneToOneRelationships(modelBuilder);
}
private void ConfigureAlineaTablePerHierarchy(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<AlineaBase>()
        .HasDiscriminator(x => x.ParentType)
        .HasValue<SummaryAlinea>(AlineaParentType.Summary)
        .HasValue<ParagraphAlinea>(AlineaParentType.Paragraph);
    modelBuilder.Entity<SummaryAlinea>()
        .Property(sa => sa.SummaryId)
        .HasColumnName("SummaryId");
    modelBuilder.Entity<ParagraphAlinea>()
        .Property(pa => pa.ParagraphId)
        .HasColumnName("ParagraphId");
}
private void ConfigureZeroOrOneToManyRelationships(ModelBuilder modelBuilder)
{
    // other code 
    ConfigureZeroOrOneToMany<Summary, SummaryAlinea>(modelBuilder, a => a.Parent, s => s.Alineas, a => a.SummaryId);
    ConfigureZeroOrOneToMany<Paragraph, ParagraphAlinea>(modelBuilder, a => a.Parent, p => p.Alineas, a => a.ParagraphId);
    void ConfigureZeroOrOneToMany<TParent, TChild>(ModelBuilder modelBuilder, Expression<Func<TChild, TParent>> parentProperty, Expression<Func<TParent, IEnumerable<TChild>>> childrenProperty, Expression<Func<TChild, object>> foreignKeyProperty, DeleteBehavior deleteBehavior = DeleteBehavior.Restrict)
        where TParent : class
        where TChild : class
    {
        modelBuilder.Entity<TChild>()
            .HasOne(parentProperty)
            .WithMany(childrenProperty)
            .HasForeignKey(foreignKeyProperty)
            .OnDelete(deleteBehavior);
    }
}

The entity names were changed, yet this iteration remained operational.

The IEntityTypeConfiguration<T> was not utilized in this version. Previously, the code resided within a Blazor.WebApp project, whereas now it is situated in a Class Library.

Anonymous

Hi, @Laurent Guigon.

You could try the following solution. Instead of configuring it in EntityConfig, configure it in your DbContext

For testing, I added some primary keys to some tables and deleted some interfaces.

    public abstract class ParagraphBase :  IParagraph
    {
        public enum ParagraphParentType { ParagraphBlock, Summary }
        public ParagraphParentType? ParentType { get; set; }

        [Key]
        public int DisplayOrder { get; set; }
        public string Content { get; set; } = string.Empty;
    }

    public class ParagraphBlock : IHasParagraphs<ContentParagraph>
    {
        [Key]
        public Guid ParentId { get; set; }
        public virtual ICollection<ContentParagraph> Paragraphs { get; set; } = new HashSet<ContentParagraph>();
    }

    public class Summary : IHasParagraphs<SummaryParagraph>
    {
        [Key]
        public Guid ParentId { get; set; }
        public virtual ICollection<SummaryParagraph> Paragraphs { get; set; } = new HashSet<SummaryParagraph>();
    }

Configuring in your DbContext

private void ConfigureAlineaTablePerHierarchy(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<ParagraphBase>()
        .HasDiscriminator(x => x.ParentType)
        .HasValue<SummaryParagraph>(ParagraphBase.ParagraphParentType.Summary)
        .HasValue<ContentParagraph>(ParagraphBase.ParagraphParentType.ParagraphBlock);
}
private void ConfigureZeroOrOneToManyRelationships(ModelBuilder modelBuilder)
{
    ConfigureZeroOrOneToMany<Summary, SummaryParagraph>(modelBuilder, a => a.Summary, s => s.Paragraphs, a => a.SummaryId);
    ConfigureZeroOrOneToMany<ParagraphBlock, ContentParagraph>(modelBuilder, a => a.Block, p => p.Paragraphs, a => a.ParagraphBlockId);

    void ConfigureZeroOrOneToMany<TParent, TChild>(ModelBuilder modelBuilder, Expression<Func<TChild, TParent>> parentProperty, Expression<Func<TParent, IEnumerable<TChild>>> childrenProperty, Expression<Func<TChild, object>> foreignKeyProperty, DeleteBehavior deleteBehavior = DeleteBehavior.Restrict)
        where TParent : class
        where TChild : class
    {
        modelBuilder.Entity<TChild>()
            .HasOne(parentProperty)
            .WithMany(childrenProperty)
            .HasForeignKey(foreignKeyProperty)
            .OnDelete(deleteBehavior);
    }
}

Answer 2

Laurent Guigon 311

This is what I Should code :

internal

Share via

Resolving TPH Inheritance and Migration Issues in Entity Framework Core with Multi-Project Architecture

2 answers

Your answer