Gruppe mit anonymen Typ in Linq

Question

Lassen Sie mich sagen, ich habe eine Mitarbeiterklasse, und GetAllEmployees() gibt eine Liste der Mitarbeiterinstanz zurück. Ich möchte Mitarbeiter nach Abteilung und Geschlecht, so die Antwort, die ich habe, ist

var employeeGroup = Employee.GetAllEmployees() 
          .GroupBy(x => new { x.Department, x.Gender }) // I don't understand this anonymous type 
          .OrderBy(g => g.Key.Department) 
          .ThenBy(g => g.Key.Gender) 
          .Select(g => new { //I can understand this anonymous type 
           Dept = g.Key.Department, 
           Gender = g.Key.Gender, 
           Employees = g.OrderBy(x => x.Name) 
          }); 

Ich habe zwei Fragen:

1. Warum ein anonymer Typ durch eine mehr Schlüssel Gruppe erlaubt?

2. ich den ersten anonymen Typ nicht verstehen, weil aus meinem Verständnis eines Formats über den anonymen Typ

   neue {field1 = x.Department, field2 = x.Gender}

so sein sollte

Wie kann der erste anonyme Typ ohne Felder haben? Ich meine, es ist die korrekte Syntax, so etwas zu schreiben:

var anonymous = new {field1 = 1,field2 =2} 

Aber es wird Fehler kompilieren, wenn ich es so schreiben:

var anonymous = new {1, 2} //compile error !!! 

Answer 1

Anonyme Typen können mehrere Felder hier Gruppe verwendet werden , weil GroupBy den standardmäßigen Gleichheitsvergleich verwendet.
Der standardmäßige Gleichheitsvergleich für anonyme Typen verwendet den standardmäßigen Gleichheitsvergleich für jede Eigenschaft des anonymen Typs.

So sind für den ersten anonymen Typ zwei Instanzen gleich, wenn sowohl Department s als auch beide Gender s gleich sind (entsprechend ihren Standardgleichheitsvergleichern).

Sie können den anonymen Typen vorstellen, so etwas zu sein:

public class AnonymousType1 
{ 
    public int Department { get; set; } // I don't know your department type 
    public int Gender { get; set; } // neither your gender type 

    public int GetHashCode() { return Department.GetHashCode()^Gender.GetHashCode(); } 
    public bool Equals(AnonymousType1 other) 
    { 
     if (ReferenceEquals(other, null)) return false; 
     return Department == other.Department && Gender == other.Gender; 
    } 
} 

---

Die zweite Frage ist einfach, auch: Der Compiler verwendet die Eigenschaftsnamen (Department von x.Department und Gender von x.Gender) als Name für die Eigenschaften des anonymen Typs.

So

var anon = new { employee.Department, employee.Gender } 

schafft eine Art mit einer Eigenschaft namens Department und eine Eigenschaft namens Gender.
Natürlich kann dies nur mit vorhandenen Eigenschaften/Namen arbeiten, nicht mit konstanten Werten wie

var anon = new {1,2}; // fails to compile, no names provided.