Linq al usar GroupBy, Include no funciona

Question

include matchparticipants no funciona. Siempre dice nulo cuando depuro. Pero cuando pongo el GroupBy en comentario, funciona bien. Estoy utilizando Entity framework 4.3.1 con código primero.

Entidades:

public class Match 
    { 
     [ScaffoldColumn(false)] 
     public int MatchId { get; set; } 

     [Required(ErrorMessage = "Matchtype is a required field")] 
     public int Scheme { get; set; } 

     [Required] 
     [DefaultValue(false)] 
     public bool Finished { get; set; } 

     public int Round { get; set; } 


     // Relations 
     [Required] 
     public Category Category { get; set; } 

     public Official Official { get; set; } 

     public Slot Slot { get; set; } 

     public ICollection<MatchParticipant> MatchParticipants { get; set; } 
    } 

public class MatchParticipant 
    { 
     [ScaffoldColumn(false)] 
     public int MatchParticipantId { get; set; } 

     public int Points { get; set; } 

     public int Goals { get; set; } 

     [Required] 
     public Match Match { get; set; } 

     [Required] 
     public Team Team { get; set; } 
    } 

public class Team 
    { 
     [ScaffoldColumn(false)] 
     public int TeamId { get; set; } 

     [Required(ErrorMessage="Name is a required field")] 
     public string Name { get; set; } 

     [Required(ErrorMessage="Number of players is a required field")] 
     public int NumberOfPlayers { get; set; } 

     [Required(ErrorMessage="Coach is a required field")] 
     public string Coach { get; set; } 

     [Required(ErrorMessage="Phone is a required field")] 
     public string Phone { get; set; } 

     public string CellPhone { get; set; } 

     public string Fax { get; set; } 

     [Required(ErrorMessage="Email is a required field")] 
     public string Email { get; set; } 

     [Required(ErrorMessage="Address is a required field")] 
     public Address Address { get; set; } 

     public Pool Pool { get; set; } 

     [Required(ErrorMessage = "Category is a required field")] 
     public Category Category { get; set; } 

     public ICollection<MatchParticipant> matchParticipants { get; set; } 
    } 

     var matches = 
     context.matches 
     .Include("Official") 
     .Include("Slot") 
     .Include("MatchParticipants.Team") 
     .Include("Category.Tournament") 
     .Where(m => m.Category.Tournament.TournamentId == tournamentId) 
     .GroupBy(m => m.Category); 

¿Cómo puedo hacer el trabajo Incluir?

Answer 1

Include exige que la forma de la consulta no cambie. Significa que su consulta debe devolver IQueryable<Match>. El operador GroupBy probablemente se considera que cambia de forma porque devuelve IQueryable<IGrouping<TKey, TSource>>. Una vez que la forma de la consulta cambia, todas las sentencias Include se omiten. Por eso no puede usar Include con proyecciones, uniones personalizadas y agrupaciones.

Como solución puede ejecutar agrupación en LINQ-a-objetos:

var matches = context.matches 
        .Include("Official") 
        .Include("Slot") 
        .Include("MatchParticipants.Team") 
        .Include("Category.Tournament") 
        .Where(m => m.Category.Tournament.TournamentId == tournamentId) 
        .ToList() 
        .GroupBy(m => m.Category); 

Answer 2

En este caso especial, cuando su GroupBy es el último operador, esta consulta funciona bien ... Pero en mi humilde opinión respuesta anterior es la peor respuesta para el principiante, porque causa una consulta muy mal optimizada cuando su GroupBy no se ejecuta inmediatamente después, pero es seguido por otra instrucción (Where, Select ...).

var ctx = new MyDataContext(); // Please use "using" 
var result = ctx.SomeTable 
       //.Include(ah => ah.IncludedTable) // DO NOT PUT IT HERE 
       .Where(t => t.IsWhateverTrue) 
       .GroupBy(t => t.MyGroupingKey) 
       .Select(gt => 
        gt.OrderByDescending(d => d.SomeProperty) 
         .FirstOrDefault(ah => ah.SomeAnotherFilter)) 
       .Include(ah => ah.IncludedTable) // YES, PUT IT HERE 
       .ToList(); // Execute query here