Entity Framework 6.1.3: Projection - charge directement les enfants des enfants

Question

Mon objectif est de faire un seul voyage dans la base de données et d'obtenir des commandes avec une collection enfant filtrée.

Pour ce faire, je l'ai utilisé une projection:

using (var db = new context()) 
      { 
       var query = from o in db.Orders 
          select 
           new 
           { 
            Order = o, 
            Events = o.Events.Where(
             e => e.SomeBool 
             && e.SomeBool2 
            ), 

            EventsGroups = o.Events.Where(
             e => e.SomeBool 
             && e.SomeBool2 
            ).Select(e => e.Groups), 

           }; 
      } 

Le problème ici est que la collection des enfants, « Groupes » sur les événements, n'est pas chargé. Pour résoudre cela, je l'ai chargé comme une autre propriété "EventsGroups" dans la requête, que je peux ensuite mettre en place avec les événements après.

Ma question: Existe-t-il un moyen de charger l'enfant, "Groupes" sur "l'événement" directement, donc je n'ai pas besoin de les obtenir comme une autre propriété?

Le long des lignes de

Events = o.Events.Where(
e => e.SomeBool 
&& e.SomeBool2 
).Include(e => e.Groups), //this cannot be done this way 

---

Pourquoi suis-je en utilisant une projection et non le chargement impatient:

https://msdn.microsoft.com/en-us/magazine/hh205756.aspx

Filtering include items in LINQ and Entity Framework

Les classes sous-jacentes:

public class Order 
{ 
    public Order() 
    { 
     Events = new HashSet<Event>(); 
    } 

    public int Id { get; set; } 

    public virtual ICollection<Event> Events { get; set; } 
} 

public class Event 
{ 
    public Event() 
    { 
     Groups = new HashSet<Group>(); 
    } 

    public int Id { get; set; } 

    public bool SomeBool { get; set; } 

    public bool SomeBool2 { get; set; } 

    public virtual ICollection<Group> Groups { get; set; } 
} 

public class Group 
{ 
    public Group() 
    { 
     Events = new HashSet<Event>(); 
    } 

    public int Id { get; set; } 

    public string Name { get; set; } 

    public virtual ICollection<Event> Events { get; set; } 
} 

Answer 1

Depuis Include ne peut pas être combiné avec une projection anonyme, vous devez projeter Event.Groups de la même façon que vous projetez Order.Events, par exemple en utilisant une autre projection de type anonyme:

var query = from o in db.Orders 
      select new 
      { 
       Order = o, 
       Events = (from e in o.Events 
          where e.SomeBool && e.SomeBool2 
          select new 
          { 
           Event = e, 
           Groups = e.Groups, 
          }), 
      }; 

Answer 2

vous pouvez charger tout en mettant Configuration.LazyLoadingEnabled = true;, sans avoir besoin de tout comprendre, bien sûr ... perfoamnce doit mettre à l'esprit .. dépend ..

public MyDatabaseContext(string databaseName) 
     : base(databaseName) 
    { 
     Configuration.LazyLoadingEnabled = true; 
    } 

Answer 3

Je crois que cela devrait fonctionner pour vous:

using (var db = new context()) 
{ 
    var query = db.Orders 
    .Include(o=>o.Events) 
    .Include(o=>o.Events.Select(e=>e.Groups)) 
    .Select(o=>new 
    { 
     Order = o, 
     Events = o.Events.Where(e => e.SomeBool && e.SomeBool2) 
    }); 
} 

sinon, cela:

using (var db = new context()) 
{ 
    var query = db.Orders 
    .Include(o=>o.Events) 
    .Include(o=>o.Events.Select(e=>e.Groups)) 
    .Select(o=>new Order 
    { 
     Id=o.Id, 
     Events = o.Events.Where(e => e.SomeBool && e.SomeBool2).ToList() 
    }); 
}