在 C# 中对 IList 进行排序

Question

所以今天我遇到了一个有趣的问题。 我们有一个返回 IList 的 WCF Web 服务。 没什么大不了的，直到我想对它进行排序。

原来 IList 接口没有内置排序方法。

我最终使用 ArrayList.Adapter(list).Sort(new MyComparer()) 方法来解决问题，但它似乎对我来说有点“贫民窟”。

我尝试编写一个扩展方法，还尝试继承 IList 并实现我自己的 Sort() 方法以及转换为 List，但这些似乎都不太优雅。

所以我的问题是，是否有人有一个优雅的解决方案来对 IList 进行排序

Answer 1

将您的 IList 转换为 List 或其他一些通用集合，然后您可以使用 System.Linq 命名空间（它将提供一堆扩展方法）

Answer 2

如果你问我的话，这看起来要简单得多。 这对我来说非常有效。

您可以使用 Cast() 将其更改为 IList，然后使用 OrderBy()：

    var ordered = theIList.Cast<T>().OrderBy(e => e);

其中 T 是类型，例如。 Model.Employee 或 Plugin.ContactService.Shared.Contact

然后您可以使用 for 循环及其 DONE。

  ObservableCollection<Plugin.ContactService.Shared.Contact> ContactItems= new ObservableCollection<Contact>();

    foreach (var item in ordered)
    {
       ContactItems.Add(item);
    }

Answer 3

这是一个有效的解决方案吗？

        IList<string> ilist = new List<string>();
        ilist.Add("B");
        ilist.Add("A");
        ilist.Add("C");

        Console.WriteLine("IList");
        foreach (string val in ilist)
            Console.WriteLine(val);
        Console.WriteLine();

        List<string> list = (List<string>)ilist;
        list.Sort();
        Console.WriteLine("List");
        foreach (string val in list)
            Console.WriteLine(val);
        Console.WriteLine();

        list = null;

        Console.WriteLine("IList again");
        foreach (string val in ilist)
            Console.WriteLine(val);
        Console.WriteLine();

结果是：
列表
乙
A
C

列表
A
乙
C I

再次列出
A
乙
C

Answer 4

在VS2008中，当我单击服务引用并选择“配置服务引用”时，有一个选项可以选择客户端如何反序列化从服务返回的列表。

值得注意的是，我可以在 System.Array、System.Collections.ArrayList 和 System.Collections.Generic.List 之间进行选择

Answer 5

这是使用更强类型的示例。 但不确定这是否一定是最好的方法。

static void Main(string[] args)
{
    IList list = new List<int>() { 1, 3, 2, 5, 4, 6, 9, 8, 7 };
    List<int> stronglyTypedList = new List<int>(Cast<int>(list));
    stronglyTypedList.Sort();
}

private static IEnumerable<T> Cast<T>(IEnumerable list)
{
    foreach (T item in list)
    {
        yield return item;
    }
}

Cast函数只是3.5自带的扩展方法的重新实现，写成普通的静态方法。 不幸的是，它非常丑陋且冗长。

Answer 6

using System.Linq;

var yourList = SomeDAO.GetRandomThings();
yourList.ToList().Sort( (thing, randomThing) => thing.CompareThisProperty.CompareTo( randomThing.CompareThisProperty ) );

太漂亮了！贫民窟。

Answer 7

发现了一篇关于此的好帖子，我想分享一下。 在这里查看

基本上。

您可以创建以下类和 IComparer 类

public class Widget {
    public string Name = string.Empty;
    public int Size = 0;

    public Widget(string name, int size) {
    this.Name = name;
    this.Size = size;
}
}

public class WidgetNameSorter : IComparer<Widget> {
    public int Compare(Widget x, Widget y) {
        return x.Name.CompareTo(y.Name);
}
}

public class WidgetSizeSorter : IComparer<Widget> {
    public int Compare(Widget x, Widget y) {
    return x.Size.CompareTo(y.Size);
}
}

然后如果您有一个 IList，您可以像这样对它进行排序。

List<Widget> widgets = new List<Widget>();
widgets.Add(new Widget("Zeta", 6));
widgets.Add(new Widget("Beta", 3));
widgets.Add(new Widget("Alpha", 9));

widgets.Sort(new WidgetNameSorter());
widgets.Sort(new WidgetSizeSorter());

但请查看此网站以获取更多信息...在这里查看

Answer 8

您可以使用 LINQ：

using System.Linq;

IList<Foo> list = new List<Foo>();
IEnumerable<Foo> sortedEnum = list.OrderBy(f=>f.Bar);
IList<Foo> sortedList = sortedEnum.ToList();

Answer 9

这个问题启发我写了一篇博客文章： http://blog.velir.com/index.php/2011/02/17/ilistt-sorting-a-better-way/

我认为，理想情况下，.NET Framework 将包含一个静态接受 IList的排序方法，但下一个最好的事情是创建您自己的扩展方法。 创建几个允许您对 IList进行排序的方法并不太难。 就像 List一样。 作为奖励，您可以使用相同的技术重载 LINQ OrderBy 扩展方法，这样无论您使用的是 List.Sort、IList.Sort 还是 IEnumerable.OrderBy，都可以使用完全相同的语法。

public static class SortExtensions
{
    //  Sorts an IList<T> in place.
    public static void Sort<T>(this IList<T> list, Comparison<T> comparison)
    {
        ArrayList.Adapter((IList)list).Sort(new ComparisonComparer<T>(comparison));
    }

    // Sorts in IList<T> in place, when T is IComparable<T>
    public static void Sort<T>(this IList<T> list) where T: IComparable<T>
    {
        Comparison<T> comparison = (l, r) => l.CompareTo(r);
        Sort(list, comparison);

    }

    // Convenience method on IEnumerable<T> to allow passing of a
    // Comparison<T> delegate to the OrderBy method.
    public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> list, Comparison<T> comparison)
    {
        return list.OrderBy(t => t, new ComparisonComparer<T>(comparison));
    }
}

// Wraps a generic Comparison<T> delegate in an IComparer to make it easy
// to use a lambda expression for methods that take an IComparer or IComparer<T>
public class ComparisonComparer<T> : IComparer<T>, IComparer
{
    private readonly Comparison<T> _comparison;

    public ComparisonComparer(Comparison<T> comparison)
    {
        _comparison = comparison;
    }

    public int Compare(T x, T y)
    {
        return _comparison(x, y);
    }

    public int Compare(object o1, object o2)
    {
        return _comparison((T)o1, (T)o2);
    }
}

使用这些扩展，可以像列表一样对 IList 进行排序：

IList<string> iList = new []
{
    "Carlton", "Alison", "Bob", "Eric", "David"
};

// Use the custom extensions:

// Sort in-place, by string length
iList.Sort((s1, s2) => s1.Length.CompareTo(s2.Length));

// Or use OrderBy()
IEnumerable<string> ordered = iList.OrderBy((s1, s2) => s1.Length.CompareTo(s2.Length));

帖子中有更多信息： http://blog.velir.com/index.php/2011/02/17/ilistt-sorting-a-better-way/

Answer 10

@DavidMills 接受的答案非常好，但我认为它可以改进。 其一，当框架已包含静态方法 Comparer.Create(Comparison) 时，无需定义 ComparisonComparer 类。 此方法可用于动态创建 IComparison。

此外，它将 IList 转换为 IList，这可能是危险的。 在我见过的大多数情况下，实现 IList 的 List 在幕后用于实现 IList，但是这个无法保证，并且可能导致代码脆弱。

最后，重载的 List.Sort() 方法有 4 个签名，但仅实现了其中 2 个。

1. List.Sort()
2. List.Sort(Comparison)
3. List.Sort(IComparer)< /code>
4. List.Sort(Int32, Int32, IComparer)

下面的类实现了所有 4 个 List.Sort() 签名IList 接口：

using System;
using System.Collections.Generic;

public static class IListExtensions
{
    public static void Sort<T>(this IList<T> list)
    {
        if (list is List<T> listImpl)
        {
            listImpl.Sort();
        }
        else
        {
            var copy = new List<T>(list);
            copy.Sort();
            Copy(copy, 0, list, 0, list.Count);
        }
    }

    public static void Sort<T>(this IList<T> list, Comparison<T> comparison)
    {
        if (list is List<T> listImpl)
        {
            listImpl.Sort(comparison);
        }
        else
        {
            var copy = new List<T>(list);
            copy.Sort(comparison);
            Copy(copy, 0, list, 0, list.Count);
        }
    }

    public static void Sort<T>(this IList<T> list, IComparer<T> comparer)
    {
        if (list is List<T> listImpl)
        {
            listImpl.Sort(comparer);
        }
        else
        {
            var copy = new List<T>(list);
            copy.Sort(comparer);
            Copy(copy, 0, list, 0, list.Count);
        }
    }

    public static void Sort<T>(this IList<T> list, int index, int count,
        IComparer<T> comparer)
    {
        if (list is List<T> listImpl)
        {
            listImpl.Sort(index, count, comparer);
        }
        else
        {
            var range = new List<T>(count);
            for (int i = 0; i < count; i++)
            {
                range.Add(list[index + i]);
            }
            range.Sort(comparer);
            Copy(range, 0, list, index, count);
        }
    }

    private static void Copy<T>(IList<T> sourceList, int sourceIndex,
        IList<T> destinationList, int destinationIndex, int count)
    {
        for (int i = 0; i < count; i++)
        {
            destinationList[destinationIndex + i] = sourceList[sourceIndex + i];
        }
    }
}

用法：

class Foo
{
    public int Bar;

    public Foo(int bar) { this.Bar = bar; }
}

void TestSort()
{
    IList<int> ints = new List<int>() { 1, 4, 5, 3, 2 };
    IList<Foo> foos = new List<Foo>()
    {
        new Foo(1),
        new Foo(4),
        new Foo(5),
        new Foo(3),
        new Foo(2),
    };

    ints.Sort();
    foos.Sort((x, y) => Comparer<int>.Default.Compare(x.Bar, y.Bar));
}

这里的想法是利用底层 List 的功能来尽可能处理排序。 同样，我见过的大多数 IList 实现都使用它。 如果底层集合是不同类型，则回退到使用输入列表中的元素创建 List 的新实例，使用它进行排序，然后将结果复制回输入列表。 即使输入列表没有实现 IList 接口，这也将起作用。

Answer 11

你将不得不做类似我认为的事情（将其转换为更具体的类型）。

也许将其放入 T 的列表而不是 ArrayList 中，以便获得类型安全性以及如何实现比较器的更多选项。

Answer 12

使用 LINQ To Objects 为您排序怎么样？

假设您有一个 IList，并且汽车有一个 Engine 属性，我相信您可以按如下方式排序：

from c in list
orderby c.Engine
select c;

编辑：您确实需要快速在这里得到答案。 由于我提出的语法与其他答案略有不同，因此我将留下我的答案 - 但是，提出的其他答案同样有效。

Answer 13

对于网格排序很有用，此方法根据属性名称对列表进行排序。 如下示例所示。

    List<MeuTeste> temp = new List<MeuTeste>();

    temp.Add(new MeuTeste(2, "ramster", DateTime.Now));
    temp.Add(new MeuTeste(1, "ball", DateTime.Now));
    temp.Add(new MeuTeste(8, "gimm", DateTime.Now));
    temp.Add(new MeuTeste(3, "dies", DateTime.Now));
    temp.Add(new MeuTeste(9, "random", DateTime.Now));
    temp.Add(new MeuTeste(5, "call", DateTime.Now));
    temp.Add(new MeuTeste(6, "simple", DateTime.Now));
    temp.Add(new MeuTeste(7, "silver", DateTime.Now));
    temp.Add(new MeuTeste(4, "inn", DateTime.Now));

    SortList(ref temp, SortDirection.Ascending, "MyProperty");

    private void SortList<T>(
    ref List<T> lista
    , SortDirection sort
    , string propertyToOrder)
    {
        if (!string.IsNullOrEmpty(propertyToOrder)
        && lista != null
        && lista.Count > 0)
        {
            Type t = lista[0].GetType();

            if (sort == SortDirection.Ascending)
            {
                lista = lista.OrderBy(
                    a => t.InvokeMember(
                        propertyToOrder
                        , System.Reflection.BindingFlags.GetProperty
                        , null
                        , a
                        , null
                    )
                ).ToList();
            }
            else
            {
                lista = lista.OrderByDescending(
                    a => t.InvokeMember(
                        propertyToOrder
                        , System.Reflection.BindingFlags.GetProperty
                        , null
                        , a
                        , null
                    )
                ).ToList();
            }
        }
    }

Answer 14

try this  **USE ORDER BY** :

   public class Employee
    {
        public string Id { get; set; }
        public string Name { get; set; }
    }

 private static IList<Employee> GetItems()
        {
            List<Employee> lst = new List<Employee>();

            lst.Add(new Employee { Id = "1", Name = "Emp1" });
            lst.Add(new Employee { Id = "2", Name = "Emp2" });
            lst.Add(new Employee { Id = "7", Name = "Emp7" });
            lst.Add(new Employee { Id = "4", Name = "Emp4" });
            lst.Add(new Employee { Id = "5", Name = "Emp5" });
            lst.Add(new Employee { Id = "6", Name = "Emp6" });
            lst.Add(new Employee { Id = "3", Name = "Emp3" });

            return lst;
        }

**var lst = GetItems().AsEnumerable();

            var orderedLst = lst.OrderBy(t => t.Id).ToList();

            orderedLst.ForEach(emp => Console.WriteLine("Id - {0} Name -{1}", emp.Id, emp.Name));**

Answer 15

当我正在寻找原始帖子中描述的确切问题的解决方案时发现了这个线程。 然而，没有一个答案完全符合我的情况。 布罗迪的回答非常接近。 这是我的情况和我找到的解决方案。

我有两个由 NHibernate 返回的相同类型的 IList，并将这两个 IList 合并为一个，因此需要排序。

就像 Brody 所说，我在对象（ReportFormat）上实现了 ICompare，它是我的 IList 的类型：

 public class FormatCcdeSorter:IComparer<ReportFormat>
    {
       public int Compare(ReportFormat x, ReportFormat y)
        {
           return x.FormatCode.CompareTo(y.FormatCode);
        }
    }

然后将合并的 IList 转换为相同类型的数组：

ReportFormat[] myReports = new ReportFormat[reports.Count]; //reports is the merged IList

然后对数组进行排序：

Array.Sort(myReports, new FormatCodeSorter());//sorting using custom comparer

因为一维数组实现了接口 System.Collections.Generic.IList，该数组可以像原始IList一样使用。