Linq bei Verwendung von GroupBy, Include funktioniert nicht

Question

include matchparticipants funktioniert nicht. Es sagt immer Null wenn ich debugge. Aber wenn ich die GroupBy in Kommentar setzen, funktioniert es gut. Ich benutze Entity Framework 4.3.1 mit Code zuerst.

Instanzen:

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

Wie kann ich die Arbeit einbeziehen zu machen?

Answer 1

Include fordert, dass sich die Form der Abfrage nicht ändert. Dies bedeutet, dass Ihre Abfrage IQueryable<Match> zurückgeben muss. GroupBy Operator wird wahrscheinlich als Formänderung betrachtet, da es IQueryable<IGrouping<TKey, TSource>> zurückgibt. Sobald sich die Form der Abfrage ändert, werden alle Include-Anweisungen weggelassen. Aus diesem Grund können Sie Include nicht mit Projektionen, benutzerdefinierten Joins und Gruppierungen verwenden.

Als Abhilfe können Sie ausführen können, in die Gruppierung Linq-to-Objekte:

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

In diesem speziellen Fall, wenn Ihr GroupBy die neueste Operator ist, funktioniert diese Abfrage gut ... Aber IMHO Antwort oben ist die schlechteste Antwort für Anfänger, weil es Ursachen wirklich schlecht optimierte Abfrage verursacht, wenn Ihre GroupBy nicht direkt danach ausgeführt wird, aber von einer anderen Anweisung gefolgt wird (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