c# - 如何对 IList 进行排序?

Question

没有Sort()功能IList。有人可以帮我吗？我想对自己的 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绝对可以完成工作，但我个人更喜欢 of 的语法，List.Sort因为您可以为它提供一个Comparison<T>委托，而不必编写一个实现IComparer<T>. 我们可以使用扩展方法来实现该目标，如果您对此感兴趣，请查看 SortExtensions：

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

Answer 5

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

        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<T>将实施IList。第一个是更好的IMO。

---

您也可以使用第一种方法对ICollection<T>就地排序，但是否应该公开这样的功能是有问题的，因为ICollection<T>合约不保证顺序（想想哈希结构）。无论如何向您展示代码示例：

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

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

---

关于排序稳定性的说明，.NET 的 Array/List 排序算法是不稳定的。对于稳定的排序，您将不得不使用：

        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

Answer 6

为了解释为什么不使用 OrderBy 或类似的检查Christophe's answer。

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

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!!
    }
}