EF condizionale Calcola per tipo di entità

Question

prega, supponiamo che l'architettura:

public class Mammal 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

public class Dog : Mammal 
{ 
    public int TailId { get; set; } 
    public Tail Tail { get; set; } 
} 

public class Bat : Mammal 
{ 
    public int WingId { get; set; } 
    public Wing Wing { get; set; } 
} 

public class Buffalo : Mammal 
{ 
    public virtual ICollection<Horn> Horns { get; set; } 
} 

public class Tail 
{ 
    public int Id { get; set; } 
    ... 
} 

public class Wing 
{ 
    public int Id { get; set; } 
    ... 
} 

public class Horn 
{ 
    public int Id { get; set; } 
    ... 
} 

Ora, mio ​​contesto:

public class MyContext : DbContext 
{ 
    public DbSet<Mammal> Mammals { get; set; } 
} 

Quindi, voglio fare solo una query SQL, e comprendono (e il carico) tutte le entità nidificate, qualcosa di simile:

var query = myContext.Mammals 
    .IncludeIfTypeIs<Dog>(d => d.Tail) 
    .IncludeIfTypeIs<Bat>(b => b.Wing) 
    .IncludeIfTypeIs<Buffalo>(b => b.Horns) 
    ... 
    ... 
; 

so che posso farlo separatamente, ma non voglio perché ho molte entità, e ho bisogno di minimizzare le richieste del database.

Non voglio utilizzare il caricamento lazy perché questo farà anche molte richieste di database.

Come raggiungerlo?

Answer 1

Puoi provare qualcosa di simile:

public static class Extensions 
{ 
    public static IQueryable<Mammal> IncludeExtraEntities<Mammal,T>(this IQueryable<Mammal> query, T derivedType) where T :Mammal 
    { 
     if (derivedType is Dog) 
      return query.Include("Tail"); 
     if (derivedType is Bat) 
      return query.Include("Wing"); 
     return query; 
    } 
} 

Poi nella chiamata db:

var query = myContext.Mammals.IncludeExtraEntities(typeof(Dog)); 

Forse questo funzionerà.

Answer 2

È possibile creare un metodo per includere un elenco di espressioni. (o forse un metodo di estensione).

public static IQueryable<Mammal> GetMammals(params Expression<Func<T, Object>>[] includeExps) 
{ 
    var query = context.Mammals.AsQueryable(); 
    if (includeExps != null) 
     query = includeExps.Aggregate(query, (current, exp) => current.Include(exp)); 

    return query; 

} 

E poi, nel codice:

//Bat and Dog will be included here 
var mammals = GetMammals(i => i.Bat, i => i.Dog); 

Speranza che aiuta!

Answer 3

La domanda è, come si caricheranno le proprietà dei tipi derivati, utilizzando solo un DbSet della classe base e senza un caricamento lazy? Temo che questo non sia possibile.

È possibile comunque fare questo:

public class MyContext : DbContext 
{ 
    public DbSet<Mammal> Mammals { get; set; } 
    public DbSet<Dog> Dogs { get; set; } 
    public DbSet<Bat> Bats { get; set; } 
} 

si potrebbe anche semplicemente implementare un metodo, specifici per tipo per ciascuno dei vostri tipi

public static class Extensions 
{ 
    public static IQueryable<Dog> IncludeExtraEntities<Dog>(this IQueryable<Dog> query) where Dog : Mammal 
    { 
      return query.Include("Tail"); 
    } 

    public static IQueryable<Bat> IncludeExtraEntities<Bat>(this IQueryable<Bat> query) where Bat: Mammal 
    { 
      return query.Include("Wing"); 
    } 
} 

Quindi, è possibile chiamare semplicemente:

myContext.Dogs.IncludeExtraEntities(); 

E verrà chiamato il metodo a seconda del tipo.

Answer 4

Ti stai aspettando troppo da Include. L'espressione lambda inserita in Include è semplicemente un fornitore di stringhe che sembra troppo intelligente. Sotto il cofano la sua espressione membro viene sezionata per ottenere il nome della proprietà, questo è tutto. Il nome viene inserito nel metodo Include che accetta un parametro stringa. Quel metodo fa il vero lavoro.

L'espressione lambda deve puntare a una proprietà di navigazione del tipo nello IQueryable. Non si può fare ...

myContext.Mammals.Include(d => d.Tail) 

... perché Tail non è una proprietà del tipo di base.Si può solo fare ...

myContext.Mammals.OfType<Dog>().Include(d => d.Tail) 

Il meglio che si può ottenere è qualcosa di simile a

from m in context.Mammals 
let tail = (m as Dog).Tail 
let wing = (m as Bat).Wing 
let horns= (m as Buffalo).Horns 
select new { Mammal = m, tail, wing, horns } 

Dal momento che tutto si traduce in SQL non dovete preoccuparvi di eccezioni riferimento null.

Answer 5

ho dovuto affrontare problemi del genere e qui come ho risolto:

public IEnumerable<OrderLine> GetAllOrderLinesData() 
    { 
     var _StockOrderLines = appContext.OrderLines.OfType<StockOrderLine>() 
      .Include(p => p.Order).Include(p => p.Product); 

     var _AnnualOrderLines = appContext.OrderLines.OfType<AnnualOrderLine>() 
      .Include(p => p.Order).Include(p => p.Customer); 

     return _StockOrderLines.ToList<OrderLine>().Union<OrderLine>(_AnnualOrderLines.ToList<OrderLine>()); 
    } 

è possibile modificare le classi come la tua :)