come ordinare una collezione in base al tipo di LINQ

Question

Ho una collezione come questa,

Class Base{} 
Class A : Base {} 
Class B : Base {} 

List<Base> collection = new List<Base>(); 
collection.Add(new A()); 
collection.Add(new B()); 
collection.Add(new A()); 
collection.Add(new A()); 
collection.Add(new B()); 

Ora voglio ordinare la raccolta in base al tipo (A/B). Come posso farlo? Mi aiuti per favore.

Answer 1

È possibile utilizzare il tipo informazioni in sé:

collection.Sort((a,b) => 
    { 
     bool aType = a.GetType() == typeof(A); 
     bool bType = b.GetType() == typeof(A); 
     return aType.CompareTo(bType); 
    }); 

Questo funzionerà per i due tipi specificati, ma non si ridimensiona oltre. Ti consente di specificare l'ordine in modo esplicito (es .: se vuoi elementi "B" prima di "A", puoi farlo funzionare usando questa tecnica).

Se è necessario supportare molti tipi, e l'ordinamento non ha bisogno di essere specificato in anticipo, si potrebbe fare qualcosa di simile:

collection.Sort((a,b) => a.GetType().FullName.CompareTo(b.GetType().FullName)); 

Ciò gestire qualsiasi numero di tipi (vale a dire: un C e anche un sottotipo D), e ordinali con il loro nome completo.

Answer 2

EDIT: Credo che questo sia ciò che si vuole:

Se non ti dispiace di smistamento 'fuori luogo' e riassegnazione della lista, questo dovrebbe funzionare:

collection = collection.GroupBy(item => item.GetType()) 
         .SelectMany(g => g) 
         .ToList(); 

o a seconda della esigenze, qualcosa come:

collection = collection.OrderBy(item => item.GetType().FullName) 
         .ToList(); 

se deve essere sul posto, quindi scrivendo un operatore di confronto personalizzato e list.Sort è probabilmente la scelta migliore.

---

Per raggruppare gli elementi per tipo, è possibile utilizzare GroupBy:

var groupedItems = collection.GroupBy(item => item.GetType()); 

Questo utilizza esecuzione differita.

In alternativa, è possibile inserire i 'gruppi' in un data-struttura come questa:

var itemsByTypeLookUp = collection.ToLookup(item => item.GetType()); 

foreach(A a in itemsByTypeLookUp[typeof(A)]) 
{ 
    ... 
} 

Se sei solo alla ricerca di un certo tipo:

var itemsOfTypeA = collection.OfType<A>(); 

Answer 3

Does

collection.Where(entry => entry is A).Concat(collection.Where(entry => entry is B)) 

fare quello che ti serve?

Answer 4

Questo sta per ordinare quindi A sarà il primo e B il secondo.

var xx = list.OrderBy(x => x.GetType() == typeof(B)).ToList(); 

Questo seguente progetto di console conferma:

class Program 
{ 
    public class X { } 
    public class A : X { } 
    public class B : X { } 
    static void Main() 
    { 
     List<X> list = new List<X>(); 
     list.Add(new B()); 
     list.Add(new A()); 
     list.Add(new B()); 
     list.Add(new A()); 
     list.Add(new A()); 

     // A.GetType() == typeof(B) will be "0" making the type A go first 
     // B.GetType() == typeof(B) will be "1" making the type B go last 
     var xx = list.OrderBy(x => x.GetType() == typeof(B)).ToList(); 

     Console.ReadLine(); 
    } 
} 

In questo caso io parto dal presupposto hai solo A e B. Se hai più tipi dovresti creare un comparatore per restituire un valore per ogni tipo.Si potrebbe anche avere una proprietà sulla classe base che imposterà l'ordine degli elementi, quindi si potrebbe ordinare l'elenco con questa proprietà.

Answer 5

private static int OrderOnType(Base item) 
{ 
    if(item is A) 
    return 0; 
    if(item is B) 
    return 1; 
    return 2; 
} 

Poi prendere la vostra scelta da:

collection.OrderBy(OrderOnType) 

o

collection.Sort((x, y) => OrderOnType(x).CompareTo(OrderOnType(y))); 

A seconda se si desidera che sul posto di smistamento o meno. Puoi inserire OrderOnType nel lambda se lo desideri, ma mi sembra più leggibile e preferisco mantenere lambdas quando aggiungono piuttosto che ridurre la leggibilità.

Answer 6

collection.OrderBy(i => i.GetType() == typeof(A) ? 0 : 1); 

vi darà una sequenza con tutte le A s poi tutto il B s

Answer 7

Qualcosa come questo funziona per me.

collection.OrderBy(p => p.GetType().Equals(typeof(B))).ThenBy(p => p.GetType().Equals(typeof(A))).ToList(); 

Il mio codice:

class Employer; 
class Doctor : Employer 
class Administrator : Employer 
class Nurse : Employer 
List<Employer> collection = new List<Employer>(); 
collection.Add(new Doctor()); 
collection.Add(new Administrator()); 
collection.Add(new Doctor()); 
collection.Add(new Nurse()); 
collection.Add(new Administrator()); 
collection = collection.OrderBy(p => p.GetType().Equals(typeof(Nurse))).ThenBy(p => p.GetType().Equals(typeof(Doctor))).ThenBy(p => p.GetType().Equals(typeof(Administrator))).ToList();