Extracción de selección de N + 1 sin .include

Question

Considere estos entidad artificial objetos:

public class Consumer 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public bool NeedsProcessed { get; set; } 
    public virtual IList<Purchase> Purchases { get; set; } //virtual so EF can lazy-load 
} 

public class Purchase 
{ 
    public int Id { get; set; } 
    public decimal TotalCost { get; set; } 
    public int ConsumerId { get; set; } 
} 

Ahora vamos a decir que desea ejecutar este código:

var consumers = Consumers.Where(consumer => consumer.NeedsProcessed); 

//assume that ProcessConsumers accesses the Consumer.Purchases property 
SomeExternalServiceICannotModify.ProcessConsumers(consumers); 

Por defecto, este sufrirá de Selección N + 1 dentro del método ProcessConsumers. Que dará lugar a una consulta cuando enumera los consumidores, entonces va a agarrar cada colección compras 1 por 1. La solución estándar para este problema sería añadir un include:

var consumers = Consumers.Include("Purchases").Where(consumer => consumer.NeedsProcessed); 

//assume that ProcessConsumers accesses the Consumer.Purchases property 
SomeExternalServiceICannotModify.ProcessConsumers(consumers); 

Eso funciona bien en muchos casos, pero en algunos casos complejos, una inclusión puede destruir por completo el rendimiento en órdenes de magnitud. ¿Es posible hacer algo como esto:.

1. agarrar mis consumidores, consumidores var = _entityContext.Consumers.Where (...) ToList()
2. agarrar mis compras, compras var = _entityContext.Purchases. Dónde (...). ToList()
3. Hidrata al consumidor. Compra colecciones manualmente de las compras que ya cargué en la memoria. Luego, cuando lo paso a ProcessConsumers, no generará más consultas de db.

No sé cómo hacer # 3. Si intenta acceder a cualquier consumidor. Compra una colección que activará la carga diferida (y, por lo tanto, la Select N + 1). Tal vez deba enviar los consumidores al tipo correcto (en lugar del tipo de proxy EF) y luego cargar la colección? Algo como esto:

foreach (var consumer in Consumers) 
{ 
    //since the EF proxy overrides the Purchases property, this doesn't really work, I'm trying to figure out what would 
    ((Consumer)consumer).Purchases = purchases.Where(x => x.ConsumerId = consumer.ConsumerId).ToList(); 
} 

EDIT: he vuelto a escribir un poco el ejemplo de esperar para revelar el problema con mayor claridad.

Answer 1

EF rellenará los consumer.Purchases colecciones para usted, si se utiliza el mismo contexto para obtener ambas colecciones:

List<Consumer> consumers = null; 
using (var ctx = new XXXEntities()) 
{ 
    consumers = ctx.Consumers.Where(...).ToList(); 

    // EF will populate consumers.Purchases when it loads these objects 
    ctx.Purchases.Where(...).ToList(); 
} 

// the Purchase objects are now in the consumer.Purchases collections 
var sum = consumers.Sum(c => c.Purchases.Sum(p => p.TotalCost)); 

EDIT:

Esto se traduce en sólo 2 llamadas DB: 1 para obtener la colección de Consumers y 1 para obtener la colección de Purchases.

EF observará cada registro Purchase devuelto y buscará el registro correspondiente Consumer de Purchase.ConsumerId. A continuación, agregará el objeto Purchase a la colección Consumer.Purchases.

---

Opción 2:

Si hay alguna razón que se desea obtener dos listas de diferentes contextos y luego vincularlos, me gustaría añadir otra propiedad a la clase Consumer:

partial class Consumer 
{ 
    public List<Purchase> UI_Purchases { get; set; } 
} 

A continuación, puede configurar esta propiedad desde la colección Purchases y utilizarla en su UI.

Answer 2

Coge mis consumidores

var consumers = _entityContext.Consumers 
           .Where(consumer => consumer.Id > 1000) 
           .ToList(); 

Coge mis compras

var purchases = consumers.Select(x => new { 
             Id = x.Id, 
             IList<Purchases> Purchases = x.Purchases   
             }) 
         .ToList() 
         .GroupBy(x => x.Id) 
         .Select(x => x.Aggregate((merged, next) => merged.Merge(next))) 
         .ToList(); 

Hidratar al consumidor.Compra colecciones manualmente de las compras que ya he cargado en la memoria.

for(int i = 0; i < costumers.Lenght; i++) 
    costumers[i].Purchases = purchases[i]; 

Answer 3

¿No sería posible para que pueda trabajar alrededor de los muchos-ida y vuelta-o-ineficiente-consulta generación problema haciendo el trabajo en la base de datos - esencialmente mediante la devolución de una proyección en lugar de un particular, entidad, como se demuestra a continuación:

var query = from c in db.Consumers 
      where c.Id > 1000 
      select new { Consumer = c, Total = c.Purchases.Sum(p => p.TotalCost) }; 
var total = query.Sum(cp => cp.Total); 

no soy un experto EF por cualquier medio, así que perdónenme si esta técnica no es adecuada.

Answer 4

Si entiendo correctamente, le gustaría cargar un subconjunto filtrado de consumidores cada uno con un subconjunto filtrado de sus compras en 1 consulta. Si eso no es correcto, perdone mi comprensión de su intención. Si eso es correcto, usted podría hacer algo como:

var consumersAndPurchases = db.Consumers.Where(...) 
    .Select(c => new { 
     Consumer = c, 
     RelevantPurchases = c.Purchases.Where(...) 
    }) 
    .AsNoTracking() 
    .ToList(); // loads in 1 query 

// this should be OK because we did AsNoTracking() 
consumersAndPurchases.ForEach(t => t.Consumer.Purchases = t.RelevantPurchases); 

CannotModify.Process(consumersAndPurchases.Select(t => t.Consumer)); 

Tenga en cuenta que esto no funcionará si la función de proceso está esperando para modificar el objeto de consumo y luego confirmar esos cambios de nuevo a la base de datos.