Il tipo 'Company.Model.User' e il tipo 'Company.Core.Model.User' hanno entrambi lo stesso nome semplice di 'Utente' e quindi non possono essere utilizzati nello stesso modello

Question

Ho una classe di entità di base MyCompany.Core.Model.User che deve essere utilizzato per le proprietà comuni di un User entità:

public class User 
{ 
    public string Username { get; set; } 
    public string Usercode { get; set; } 
} 

ho anche una classe corrispondenza base MyCompany.Core.Model.UserMap per impostare il codice primi mappature per la base User classe:

public class UserMap<TUser> : EntityMapBase<TUser> 
    where TUser : User 
{ 
    public UserMap() 
    { 
     // Primary Key 
     this.HasKey(t => t.Usercode); 

     // Table & Column Mappings 
     this.ToTable("Users"); 
     this.Property(t => t.Username).HasColumnName("Username"); 
     this.Property(t => t.Usercode).HasColumnName("UserCode"); 
    } 
} 

In un separato assembly ho una classe derivata MyCompany.Model.User che eredita dalla classe base User e si estende con alcune proprietà aggiuntive:

public class User : Core.User 
{ 
    public string Surname { get; set; } 
} 

Inoltre Ho una classe di mappatura derivata MyCompany.Model.UserMap per fornire la configurazione aggiuntiva per le proprietà aggiuntive:

public class UserMap : Core.UserMap<User> 
{ 
    public UserMap() 
    { 
     this.Property(t => t.Surname).HasColumnName("Surname"); 
    } 
} 

Tuttavia quando si aggiunge MyCompany.Model.User al contesto e si registra il MyCompany.Model.UserMap Viene visualizzato il seguente errore:

Il tipo "MyCompany.Model.User" e il tipo "MyCompany.Core.Model.User" hanno entrambi lo stesso nome semplice di "Utente" e quindi non possono essere utilizzati nello stesso modello. Tutti i tipi in un determinato modello devono avere nomi semplici univoci. Utilizzare 'NotMappedAttribute' o chiamare Ignore nel codice Prima API fluente per escludere esplicitamente una proprietà o un tipo dal modello.

Questo link indica che non è possibile avere lo stesso "nome semplice" nel modello due volte.

Perché la classe di base "nome semplice" viene registrata nel modello e esiste un modo per implementare questo tipo di ereditarietà di entità?

Sospetto che la soluzione semplice sarebbe quella di rinominare la classe derivata; tuttavia preferirei evitare questo perché potrebbero esserci molte derivazioni in più contesti.

Nota: L'uso Entity Framework 6.0.0-rc1 (prerelease)

Answer 1

Questa è una limitazione di EF che ho segnalato nel 2012 https://entityframework.codeplex.com/workitem/483 che non è ancora implementato in 6.0.2. EF utilizza un'architettura interna piatta e non riconosce gli spazi dei nomi. Potrebbe venire in EF7, ma non prima. Per ora l'unica soluzione è rinominare le due classi in nomi di classi univoche indipendentemente dallo spazio dei nomi in cui si trovano. IMHO, questa è una limitazione significativa all'interno di EF. Prendi in considerazione una classe di nome Category e quanti spazi dei nomi diversi potrebbero essere utilizzati all'interno di un dominio.

Answer 2

Prima leggi Table type mappings

Il modello di implementazione gerarchico opzioni devono essere comprese prima. Quindi guarda l'opzione IGNORE. Potrebbe essere necessario o meno a seconda dell'approccio scelto.
richiede ignora ???

modelBuilder.Ignore<BaseXYZ>() 

Ef sta attualmente cercando di includere la classe di base per supportare un tipo di cui che eredita da una classe non astratta.

Answer 3

Per mantenere lo stesso nome di classe, suggerisco di utilizzare interfacce diverse. Un'interfaccia per Core.Entity che definisce le proprietà comuni e un'altra interfaccia per le proprietà aggiuntive. Quindi, invece di usare una classe derivata, usi una classe che implementa le due interfacce.