HasKey() throws confusing exception about redefining key if no inheritance was intended

[divega]

Work item is to add info about how you an get into this case.

---

From #3727 (comment) by @miroslavsiska: the following throws

InvalidOperationException: The derived type 'CashDesk.Models.AllergenQuantityMaterial' cannot have keys other than those declared on the root type.

Note that this is still a negative scenario, e.g. there cannot be a navigation property of the base type if the base type does not define the key. But the exception isn't very helpful if the type wasn't intended as an entity type in the first place.

Repro code:

public class AllergenQuantity
{              
    public Guid UnitId { get; set; }
    public virtual Unit Unit { get; set; }         

    [Display(Name = "Množství obsahu")]
    public decimal Quantity { get; set; }
}


 public class Unit 
{
    public Unit()
    {
        this.Id = Guid.NewGuid();
    }
    public virtual ICollection<AllergenQuantity> AllergenQuantity { get; set; }

    [Key]
    public Guid Id { get; set; }     

    [Display(Name = "Jednotka")]
    public string Name { get; set; }

    [Display(Name = "Typ Jednotky")]
    public string UnitType { get; set; }

    [Display(Name = "Použité v kulturách")]
    public string Cultures { get; set; }
}


  public class TenantDbContext : IdentityDbContext<TenantUser, TenantRole, Guid>
{
    private string _connectionString { get; set; }

    public TenantDbContext(DbContextOptions<TenantDbContext> options) : base(options) 
    {
        this._connectionString = "CON STRING";
    }

    public TenantDbContext()       
    {
    }   
    public TenantDbContext(string ConnectionString)
    {
        this._connectionString = ConnectionString;
    }
    public static TenantDbContext Create(string ConnectionString)
    {
        return new TenantDbContext(ConnectionString);
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    { 
        optionsBuilder.UseSqlServer(_connectionString);  
    }

    //  BASE
    public DbSet<Unit> Unit { get; set; }

    //  Stock
    public DbSet<Allergen> Allergen { get; set; }  
    public DbSet<AllergenQuantityMaterial> AllergenQuantityMaterial { get; set; }        
        //Inherited from AllergenQuantity
    public DbSet<Material> Material { get; set; }

    protected override void OnModelCreating(ModelBuilder builder)
    {      
        base.OnModelCreating(builder);

        // Throws
        builder.Entity<AllergenQuantityMaterial>().HasKey(l => new { l.MaterialId, l.AllergenId });  
    }
}

[divega]

@smitpatel feel free to start looking at this. Although it isn't triaged @ajcvickers @AndriySvyryd @rowanmiller and I already discussed it.

[miroslavsiska]

@divega Please check your E-mail - I sended you complete solution with this bug...

[maumar]

I think this is applicable to this discussion, I have a model with two types:

public abstract class Person 
{ 
public int Id {get; set; }
}

and

public class Donor : Person
{
}

in OnModelCreating I have the following snippet:

            modelBuilder.Entity<Person>().HasKey(p => p.PersonId);
            modelBuilder.Entity<Donor>().HasKey(d => d.PersonId);

this throws the following exception:

Unhandled Exception: System.InvalidOperationException: The derived type 'Donor' cannot have keys other than those declared on the root type 'Person'.

This is confusing to me, because both entities have the same key.

[mii9000]

@maumar What was your solution to this?
@rowanmiller Why is it required for the Id property to be on the root type?
I am making my entity classes by inheriting from domain model classes which are just POCOs without annotations or db related properties. How am I suppose to make this scenario work?

[AndriySvyryd]

@ibrahim-islam The key must be defined on the base type because EF allows assigning derived entities to navigations configured with the base entity type.
If you don't need to track the base entity type you can just ignore it in 'OnModelCreating'