Sortier-Array basierend auf der Eigenschaft des Objekts im inneren Array

Question

Ich habe ein Array von Accounts, die von unserer API zurückgegeben werden und die folgende Datenstruktur haben.

Accounts[] accounts = [ 
    { 
     AccountNumber: 0000000001, 
     PrimaryPerson: Virginia, 
     PrimaryPersonNumber: 0001, 
     PersonRoleCode: "OWN", 
     PersonRoleDescription: "Owner", 
     RoleOrder: 1 
     PersonRoles: [ 
         { 
          AccountRoleCode: "CO", 
          AccountRoleDescription: "Co-Owner", 
          PersonName: "David", 
          PersonNumber: 0002, 
          RoleOrder: 2 
         }, 
         { 
          AccountRoleCode: "POA", 
          AccountRoleDescription: "Power of Attorney", 
          PersonName: "Clark", 
          PersonNumber: 0003, 
          RoleOrder: 6 
         } 
        ] 
    }, 
    { 
     AccountNumber: 0000000002, 
     PrimaryPerson: Clark, 
     PrimaryPersonNumber: 0003, 
     PersonRoleCode: "OWN", 
     PersonRoleDescription: "Owner", 
     RoleOrder: 1 
     PersonRoles: [ 
         { 
          AccountRoleCode: "CO", 
          AccountRoleDescription: "Co-Owner", 
          PersonName: "Virginia", 
          PersonNumber: 0001, 
          RoleOrder: 2 
         }, 
         { 
          AccountRoleCode: "POA", 
          AccountRoleDescription: "Power of Attorney", 
          PersonName: "David", 
          PersonNumber: 0002, 
          RoleOrder: 6 
         } 
        ] 
    }, 
    { 
     AccountNumber: 0000000003, 
     PrimaryPerson: David, 
     PrimaryPersonNumber: 0002, 
     PersonRoleCode: "OWN", 
     PersonRoleDescription: "Owner", 
     RoleOrder: 1 
     PersonRoles: [ 
         { 
          AccountRoleCode: "CO", 
          AccountRoleDescription: "Co-Owner", 
          PersonName: "Clark", 
          PersonNumber: 0003, 
          RoleOrder: 2 
         }, 
         { 
          AccountRoleCode: "CO", 
          AccountRoleDescription: "Co-Owner", 
          PersonName: "Virginia", 
          PersonNumber: 0001, 
          RoleOrder: 2 
         }, 
         { 
          AccountRoleCode: "POA", 
          AccountRoleDescription: "Power of Attorney", 
          PersonName: "Virginia", 
          PersonNumber: 0001, 
          RoleOrder: 6 
         } 
        ] 
    } 
]; 

Ich brauche dieses Accounts Objekt auf den RoleOrder für das Accounts Objekt zu sortieren selbst und die RoleOrder für das PersonRole Objekt in jedem PersonRoles[] Index.

Ich habe versucht, es mit LINQ zu tun, aber ich bin mir nicht sicher, warum es nicht richtig funktioniert.

Hier ist, was ich versuchte und was ich erwartet hatte.

IEnumberable<Account> sortedAccounts = accounts 
    .OrderBy(acct => acct.PersonRoles 
    .Where(role => role.PersNbr == 0001) 
    .Select(x => x.RoleOrder)).ToList(); 

I erwartet, dass es die Haupt accounts[] vom PersonRoles[] zu bestellen, wo die PersNbr den gegebenen PersNbr gleich (0001) und sortiert auf den RoleOrder.

Also im Grunde möchte ich die accounts[] basierend auf der RoleOrder für eine bestimmte Person nur sortieren.

So auf Virginia basierte Sortierung in Accounts[] accounts = [0000000001, 0000000003, 0000000002]

führt auf David Gestützte Sortierung in Accounts[] accounts = [0000000003, 0000000001, 0000000002]

führen wird, was ich für LINQ haben nichts zu tun ist (Reihenfolge gleich bleibt), das mich denken Ich mache die Abfrage in der richtigen Reihenfolge.

Wie schreibe ich eine LINQ-Abfrage, oder muss ich sie in verschiedene Abfragen aufteilen?

Answer 1

Ich bin gebeten worden, eine vollständige Antwort zu geben, hier gehen wir:

Zuerst möchte ich Ihre Aufmerksamkeit auf eine „Design-Loch“ zeichnen, die Sie haben: was ist, wenn Sie nicht passiert diese "Person" überhaupt? Für diesen Fall habe ich mir erlaubt, anzunehmen, dass all diese Ergebnisse am Ende gezeigt werden. Das Problem: Die Komplexität des Problems kommt von Ihnen, müssen Sie zwei verschiedene Sortierung durchführen: während der Array [] -Array Sortierung und auch innerhalb des PersonRoles-Array innerhalb jedes Kontos, während beide Sortierungen die gleiche Logik hat .

Unter der Annahme, dass Ihr Objekt wandelbar ist, Ich empfehle die nächste Lösung:

IEnumerable<Account> sortedAccounts = accounts 
      .Select(x => { 
       x.PersonRoles = x 
       .PersonRoles 
       .OrderBy(acct => { 
        if (acct.PersonNumber != 001) 
         return 999; 
        return acct.RoleOrder; 
       }).ToArray(); 
       return x; 
      }) 
      .OrderBy(acct => {     
       var relevantRoles = acct.PersonRoles 
        .Where(role => role.PersonNumber == 0001) 
        .Select(x => x.RoleOrder); 
       if (relevantRoles.Any() == false) 
        return 999; 
       return relevantRoles.Max(); 
       } 
      ).ToList(); 

Erklärung: Wir von der „select“ Anweisung zu starten, in dem neu ordnen wir die innere Struktur der PersonRoles Arrays innerhalb jeder Konto, auf diese Weise deutlicher ist und wird dazu beitragen, die Konten ein wenig einfacher

Später Bestellung ausführen, bestellen wir die Konten Array nach der gleichen Logik

Beachten sie, dass istead der " Wenn Sie 999 "-Anweisungen zurückgeben, können Sie eine andere Logik schreiben, die Fälle behandelt, in denen sich keine relevanten Benutzer im Array" PersonRoles "befinden.

Answer 2

Siehe: Sort a list and all its nested objects using Linq

Sie es in einer Erklärung tun. Innerhalb jedes LINQ müssen Sie neue Objekte mithilfe von Informationen aus der äußeren Anweisung erstellen.

class Account 
{ 
    public int AccountNumber { get; set; } 
    public Role[] Roles { get; set; } 
} 

class Role 
{ 
    public string State { get; set; } 
    public int RoleOrder { get; set; } 
} 

Account[] accounts = new Account[3]; 
     accounts[0] = new Account { AccountNumber = 1, Roles = new 
Role[2] { new Role { State = "AK", RoleOrder = 2 }, new Role { State = 
"CO", RoleOrder = 1 } } }; 
     accounts[1] = new Account { AccountNumber = 3, Roles = new 
Role[2] { new Role { State = "NY", RoleOrder = 66 }, new Role { State = 
"FL", RoleOrder = 5 } } }; 
     accounts[2] = new Account { AccountNumber = 2, Roles = new 
Role[2] { new Role { State = "CA", RoleOrder = 9 }, new Role { State = 
"AZ", RoleOrder = 8 } } }; 

IEnumerable<Account> info = accounts 
    .Select(x => new Account { 
     AccountNumber = x.AccountNumber 
     , Roles = x.Roles.OrderBy(y => y.RoleOrder).ToArray() 
    } 
    ).Where(x => x.AccountNumber == 2);