Question

Sort()没有IList功能。 someoene可以帮我这个吗？我想对自己的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<T>委托，而不必写一个实现{{1}的类}}。我们可以使用扩展方法实现该目标，如果您对此感兴趣，请查看SortExtensions：

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

Answer 5

为解释为什么不使用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!!
    }
}

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<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的数组/列表排序算法不稳定。 要稳定排序，您将不得不使用：

        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

如何排序IList <class>？</class>

6 个答案: