如何排序基于类型的LINQ

Question

我有这样一个集合的集合，

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

现在我要进行排序基于类型（A/B）的集合。我如何做到这一点？请帮帮我。

Answer 1

您可以使用类型信息本身：

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

这会为你指定的两种类型的工作，但没有规模超越他们。它确实允许你明确地指定顺序（即：如果你想在“A”之前使用“B”元素，你可以使用这种技术使其工作）。

如果你需要支持多种类型，并且排序并不需要提前指定的，你可以这样做：

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

这将处理任何数量的类型（即：一个C和一个D子类型），并按全名命名。

Answer 2

编辑：我想这是你想要的东西：

如果你不介意整理“出位”，并重新分配名单，这应该工作：

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

或根据您的需求是这样的：

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

如果一定要就地，然后写一个自定义比较和list.Sort可能是最好的选择。

---

要按类型分组的项目，你可以使用GroupBy：

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

它使用延迟执行。

或者，你可以把“群体”到数据结构是这样的：

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

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

如果你只是在寻找某一类型：

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

Answer 3

是否

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

你需要什么？

Answer 4

这是要命令所以A将是第一个和B第二个。

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

这以下控制台项目确认：

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

在这种情况下，我假设你只有A和B。如果你有更多的类型，你将不得不创建一个比较器来为每种类型返回一个值。你也可以在基类上设置一个属性来设置元素的顺序，然后你可以用这个属性对列表进行排序。

Answer 5

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

然后从你挑：

collection.OrderBy(OrderOnType) 

或

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

根据您是否想就地分拣与否。如果你真的想要的话，你可以把OrderOnType放入lambda表达式中，但这对我来说似乎更易读，而且我更喜欢在添加lambda时保留lambda表达式，而不是减少可读性。

Answer 6

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

会给你一个序列的所有A当时的所有B小号

Answer 7

像这样的事情对我的作品。

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

我的代码：

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