Entity Framework 6 DBContext con solo un sottoinsieme di tutte le tabelle

Question

Abbiamo un enorme database con 770 tabelle e vogliamo fare un test delle prestazioni con EF 6.1x.

Vogliamo interrogare solo 5 di quelle 770 tabelle. È possibile creare un DBContext "leggero" con solo 5-6 entità/DBSet invece di utilizzare l'intero contesto 770-tabelle?

Quando si utilizza il contesto completo, una query semplice con 4 join richiede 45 secondi. Sono 44 secondi troppo lunghi. Utilizziamo il codice prima (reverse engineering).

Il problema: Quando creiamo una versione come "luce" del contesto completo (vale a dire 5 tavoli solo), EF si lamenta che tutti gli altri soggetti che sono in qualche modo legati a questi 5 tabelle hanno chiavi mancanti. Mappiamo solo le chiavi, le proprietà, le relazioni per quei 5 tavoli, ma non il resto.

Poiché la query scritta in LINQ richiede solo 5 tabelle, EF deve semplicemente ignorare le altre tabelle 765, ma non lo farà. Perché no? LazyLoading = true/false non sembra avere alcuna influenza su questo.

Nota: Ovviamente si potrebbe creare una vista nel DB che esegue ciò che facciamo in codice con una query LINQ. La domanda è che si può fare con un DbContext "leggero" come sopra.

C'è la versione "light" del contesto:

public class ItemLookupContext : DbContext 
{ 
    static ItemLookupContext() 
    { 
     Database.SetInitializer<ItemLookupContext>(null); 
    } 

    public ItemLookupContext() 
     : base("Name=ItemLookupContext") 
    { 
     //Configuration.LazyLoadingEnabled = true; 
    } 

    public DbSet<Identity> Identities { get; set; } 
    public DbSet<Item> Items { get; set; } 
    public DbSet<Price> Prices { get; set; } 
    public DbSet<Department> Departments { get; set; } 
    public DbSet<Brand> Brands { get; set; } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     modelBuilder.Configurations.Add(new IdentityMap()); 
     modelBuilder.Configurations.Add(new ItemMap()); 
     modelBuilder.Configurations.Add(new PriceMap()); 
     modelBuilder.Configurations.Add(new DepartmentMap()); 
     modelBuilder.Configurations.Add(new BrandMap()); 

     //ignore certain entitities to speed up loading? 
     //does not work 
     modelBuilder.Ignore<...>(); 
     modelBuilder.Ignore<...>(); 
     modelBuilder.Ignore<...>(); 
     modelBuilder.Ignore<...>(); 
     modelBuilder.Ignore<...>(); 
    } 
} 

Answer 1

ciò che si cerca di qualcosa come "Contesto limitata", che è uno dei modelli DDD

Quindi, è possibile controllare questo articolo di Julie Lerman, Shrink EF Models with DDD Bounded Contexts

Answer 2

Quando si ha una relazione molti-a-uno rapporto tra classe A e la classe B:

public class A 
{ 
    public B b {get; set;} 
} 
public class B 
{ 
    public ICollection<A> As {get; set;} 
} 

e definire in seguito DbContext , EF automaticamente include DbSet<B> a DbContext:

public class MyContext : DbContext 
{ 
    ... 
    public DbSet<A> As { get; set; } 
} 

Quindi, se si desidera che la vostra luce DbContext non include i relativi DbSet s, è sufficiente utilizzare Ignore metodo:

public class MyContext : DbContext 
{ 
    ... 
    public DbSet<A> As { get; set; } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     modelBuilder.Ignore<B>(); 
    } 
} 

Answer 3

Sembra si è utilizzato uno strumento come Entity Framework Power Tools per generare l'entità classi e mappature. Questo avrebbe generato una classe per ogni tabella nel database, un contesto enorme, mappature per tutte queste classi e tutte le possibili associazioni. Questo è troppo.

Prima rimuovere tutte le classi e i mapping non necessari. Quindi rimuovi tutte le associazioni alle classi rimosse nelle poche classi che hai lasciato, non i campi di chiavi esterne primitive. Rimuovi anche tutti i DbSet dal contesto tranne i pochi che ti servono.

Questo modello di classe snellito sarà di per sé coerente. Non avrà associazioni a tutte le entità nel database, ma sarà possibile filtrare per valori di chiavi estranee che si riferiscono a entità esterne al contesto.

Se il codice è stato generato/creato in qualsiasi altro modo, questo è ancora il punto cruciale: utilizzare solo le proprietà di navigazione per altre classi nel modello di classe.Per altri riferimenti utilizzare le proprietà delle chiavi esterne primitive.

Answer 4

semplicemente creare il DbContext per le tabelle. Per evitare che Entity Framework si lamenti delle tabelle non mappate, è necessario disattivare l'inizializzazione del db nell'applicazione. Mettete questo nella vostra global.asax/Startup.cs

Database.SetInitializer<YourDbContext>(null); 

Racconta EF per fermare confrontando la struttura attuale DB contro il tuo DbContext. Significa anche che se qualcuno cambia le tue tabelle mappate EF, non hai alcuna possibilità di ricevere una notifica al riguardo.