C# 如何按类型排列列表？

假设您有一个名为

list

的列表

Foo

是一个抽象类，因此可以是

FooA

、

FooB

、

FooC

或

FooD

。我想为

List

提供一个扩展，您可以按类型顺序排列这些元素

例如，如果我有9个元素

FooA, FooA, FooB, FooD, FooC, FooC, FooA, FooB, FooA

按类型顺序排列的订单将被删除

FooA, FooB, FooC, FooD, FooA, FooB, FooC, FooA, FooA

我试图按照您指定的顺序对函数进行排序，在这种情况下，即：

new[] { typeof(FooA), typeof(FooB), typeof(FooC), typeof(FooD) }

---

我试图创建这个扩展，但什么也没有得到。你能帮点忙吗？我猜我可以用LINQ完成这项工作。

您可以按类型对项目进行分组，按类型对组进行排序，并交叉分组：

var groups = items.GroupBy(x => x.GetType())
                  .OrderBy(g => orderedTypes.IndexOf(g.Key))
                  .ToList();

var result = groups.First().Interleave(groups.Skip(1).ToArray());

使用

输出：

---

在类型上分组，然后循环遍历项目，每次添加一组。比如：

var groups =
  collection.GroupBy(x => x.GetType())
  .ToDictionary(g => g.Key, g => g.ToList());

List<Foo> result = new List<Foo>();
int max = groups.Values.Max(n => n.Count);
for (int i = 0; i < max; i++) {
  foreach (Type  t in sortArray) {
    if (groups[t].Count > i) {
      result.Add(groups[t][i]);
    }
  }
}

var组=
collection.GroupBy（x=>x.GetType（））
.ToDictionary（g=>g.Key，g=>g.ToList（））；
列表结果=新列表（）；
int max=groups.Values.max（n=>n.Count）；
对于（int i=0；ii）{
结果：添加（组[t][i]）；
}
}
}

列表

是要排序的元素集合。

模式

是按特定顺序排列的元素集合。

result

是来自

列表

的元素集合，按照

模式

排序

var list = new List<Foo> { new FooA(), new FooB(), new FooC(), new FooA(), new FooC(), new FooA(), new FooD() };
var pattern = new Foo[] { new FooB(), new FooC(), new FooD(), new FooA() };

var result = list.OrderBy(p => p, new MyFooComparer(pattern));

致电后：

        foreach (var foo in result)
        {
            Console.WriteLine(foo.GetType().Name);
        }

根据

模式

，您将获得：

FooB
FooC
FooC
FooD
FooA
FooA
FooA

编辑：

列表的扩展名

：

静态类MyExtension
{
公共静态IEnumerable OrderByFoo（此列表，IEnumerable paten）
{
return list.OrderBy（p=>p，新的MyFooComparer（patern））；
}
}

如果列表中没有FooC，或者有FooA、FooB、FooC、FooC、FooC、FooC、FooD，会发生什么情况，您如何排序？我建议您根据需要调整选择排序。@L.B:指定排序顺序的

Type

对象数组。

public class MyFooComparer : IComparer<Foo>
{
    private readonly Dictionary<Type, int> _pattern;
    public MyFooComparer(IEnumerable<Foo> pattern)
    {
        _pattern = new Dictionary<Type, int>();
        int i = 0;
        foreach (var foo in pattern)
        {
            _pattern.Add(foo.GetType(), i);
            i++;
        }
    }

    public int Compare(Foo x, Foo y)
    {
        var xVal = _pattern[x.GetType()];
        var yVal = _pattern[y.GetType()];
        return xVal.CompareTo(yVal);
    }
}

        foreach (var foo in result)
        {
            Console.WriteLine(foo.GetType().Name);
        }

FooB
FooC
FooC
FooD
FooA
FooA
FooA

static class MyExtension
{
    public static IEnumerable<Foo> OrderByFoo<T>(this List<Foo> list, IEnumerable<Foo> patern)
    {
        return list.OrderBy(p => p, new MyFooComparer(patern));
    }
}