linq to entities - Linq al usar GroupBy, Include no funciona

linq-to-entities ef-code-first

Question

incluir matchparticipants no está funcionando. Siempre dice nulo cuando depuro. Pero cuando pongo el GroupBy en comentario funciona bien. Estoy usando Entity framework 4.3.1 con el 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 que el Include funcione?

Answer 1

En este caso especial, cuando su GroupBy es el último operador, esta consulta funciona bien ... Pero IMHO, la respuesta anterior es la peor para el principiante , ya que causa una consulta muy mal optimizada cuando su GroupBy no se ejecuta justo después, pero es seguido de alguna otra declaració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

Answer 2

Include demandas de que la forma de la consulta no cambie. Significa que su consulta debe devolver IQueryable<Match> . GroupBy operador GroupBy probablemente se considera un cambio de forma porque devuelve IQueryable<IGrouping<TKey, TSource>> . Una vez que la forma de la consulta cambia, se omiten todas las declaraciones de inclusión. Por este motivo, no puede utilizar Include con proyecciones, uniones personalizadas y agrupaciones.

Como solución alternativa, puede ejecutar la agrupación en objetos Linq:

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);

Edición: Como se mencionó en los comentarios y en otras respuestas, esta es una solución muy peligrosa que puede llevar a problemas de rendimiento. Extrae todos los registros de la base de datos a la aplicación y realiza la agregación en la aplicación. Puede funcionar en los mismos casos, pero definitivamente no es aplicable como solución genérica.