如何对 IList进行排序？

Question

IList 没有 Sort() 函数。有人可以帮我解决这个问题吗？ 我想对我自己的 IList 进行排序。

假设这是我的 IList：

public class MyObject() 
{
 public int number { get; set; }
 public string marker { get; set; }
}

如何使用标记字符串对 myobj 进行排序？

public void SortObject()
{
 IList<MyObject> myobj = new List<MyObject>();
}

Answer 1

使用 OrderBy

示例

public class MyObject() 
{
    public int number { get; set; }
    public string marker { get; set; }
}

IList<MyObject> myobj = new List<MyObject>();
var orderedList = myobj.OrderBy(x => x.marker).ToList();

作为案例不敏感你应该使用 IComparer

public class CaseInsensitiveComparer : IComparer<string>
{
    public int Compare(string x, string y)
    {
        return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
    }
}

IList<MyObject> myobj = new List<MyObject>();
var orderedList = myobj.OrderBy(x => x.marker, new CaseInsensitiveComparer()).ToList();

Answer 2

我会反对使用 OrderBy 与列表，因为它是一个 LINQ 扩展方法，因此：

• 它将列表包装在一个可枚举中，然后枚举它并填充一个新的临时列表，然后对这个新列表进行排序。
• 它将排序列表包装在另一个可枚举中。
• 然后，当您调用 ToList() 时，它会对其进行迭代并用项目填充另一个新列表。

本质上：除了实际排序之外，它还创建并填充 2 个新列表和 2 个可枚举值。
相比之下，List.Sort() 就地排序并且不创建任何内容，因此效率更高。

我的建议是：

• 如果您知道基础类型，请使用 List.Sort() 或 Array.Sort(array)
• 如果您不知道基础类型，请复制将 List 保存到临时数组并使用 Array.Sort(array) 对其进行排序并返回。

Answer 3

var sorted = myObj.OrderBy(x => x.marker);

Answer 4

OrderBy 肯定可以完成工作，但我个人更喜欢 List.Sort 的语法，因为您可以为其提供一个 Comparison 委托必须编写一个实现 IComparer 的类。我们可以使用扩展方法来实现该目标，如果您对此感兴趣，请查看 SortExtensions：

http://blog.velir.com/index.php/2011/02/17/ilistt-sorting-a-better-way/

Answer 5

要了解为什么不使用 OrderBy 或类似的信息，请查看 Christophe 的回答。

这是进行快速排序的一种尝试：

public static void Sort<T>(this IList<T> ilist)
{
    switch(ilist)
    {
        case List<T> lst:
            lst.Sort();
            break;
        case Array arr:
            Array.Sort(arr);
            break;
        default:
            throw new NotImplementedException();
            // or add slow impl if you don't want this to fail!!
    }
}

Answer 6

要就地排序，您基本上会看到这两种方法：

        IList<T> list = .... // your ilist
        var sorted = list.ToArray();
        Array.Sort(sorted);

        for (int i = 0; i < list.Count; i++)
        {
            list[i] = sorted[i];
        }

第二种方法

        IList<T> list = .... // your ilist
        ArrayList.Adapter((IList)list).Sort();

可能看起来更简单但对于值类型集合来说不太好，因为它会导致装箱惩罚。此外，无法保证您的 IList 将实现 IList。在我看来，第一个更好。

---

您还可以使用第一种方法就地对 ICollection 进行排序，但由于 ICollection合约不保证订单（想想哈希结构）。无论如何，向您展示代码示例：

    ICollection<T> collection = .... // your icollection
    var sorted = collection.ToArray();
    Array.Sort(sorted);

    collection.Clear();
    foreach (var i in sorted)
    {
       collection.Add(i);
    }

---

关于排序稳定性的说明，.NET 的数组/列表排序算法不稳定。 对于稳定的排序，您必须使用：

        IList<T> list = .... // your ilist
        var sorted = list.OrderBy(i => i).ToArray();

        for (int i = 0; i < list.Count; i++)
        {
            list[i] = sorted[i];
        }

这不可能像不稳定的排序那么快。

---

最后，为了完整的答案，也许watbywbarif 采用的复合方法更好：

    public static void Sort<T>(this IList<T> list, IComparer<T> comparer, bool stable)
    {
        if (stable)
        {
            list.StableSort(comparer);
        }
        else
        {
            list.UnstableSort(comparer);
        }
    }

    static void StableSort<T>(this IList<T> list, IComparer<T> comparer)
    {
        list.OrderBy(x => x, comparer).CopyTo(list);
    }

    static void UnstableSort<T>(this IList<T> list, IComparer<T> comparer)
    {
        switch (list)
        {
            case List<T> l:
                l.Sort(comparer);
                break;

            case T[] a:
                Array.Sort(a, comparer);
                break;

            default:
                T[] sortable = list.ToArray();
                sortable.UnstableSort(comparer);
                sortable.CopyTo(list);
                break;
        }
    }

    static void CopyTo<T>(this IEnumerable<T> source, IList<T> target)
    {
        int i = 0;
        foreach (T item in source)
        {
            target[i++] = item;
        }
    }

这就是内置方法。为了更快地实施，您必须推出自己的，请参阅：https://stackoverflow.com/a/19167475