自定义容器类成员使用List<T>.Sort()和List<T>.OrderBy()的实用性比较

Question

自定义容器类成员使用List<T>.Sort()和List<T>.OrderBy()的实用性比较

9

我发现自己需要运行一些旧的3.5框架遗留代码，并发现有一些地方必须以同步方式更新一大堆列表和字典。我决定通过合并这些内容到新的自定义容器类的自定义类中，可以使这个过程更易于使用和理解。然而，在组织这些新容器类的内容时，我遇到了一些问题，需要根据特定的内部属性进行排序。例如，按一个类的ID号属性排序。

由于容器类主要基于通用List对象，我的第一反应是为内部类编写IComparable，并编写比较属性的CompareTo方法。这样，当我想调用排序时，只需调用items.Sort()。

然而，我考虑改为使用items = items.OrderBy(Func)。这样，如果我需要按任何其他属性排序，它就更加灵活。可读性也更好，因为用于排序的属性将与排序调用一起列在行内，而不必查找IComparable代码。结果，整个实现感觉更清洁。

我不喜欢过早或微观优化，但我喜欢一致性。我认为最好在适当的情况下坚持一种实现方式，并在必要时使用不同的实现方式。是否值得将我的代码转换为使用LINQ OrderBy而不是使用List.Sort？对于这些自定义容器，坚持使用IComparable实现是否更好？两种方法提供的任何重要机械优势应该权衡决策吗？或者它们的最终功能等同于程序员的偏好到了一个点？

- Grace Note

2个回答

4

正如Julien所说，Sort()可能会更快，但是由于你提到了OrderBy()更好的可读性和灵活性，你也可以通过Sort()方法实现这一点（至少如果你想要基于比较的属性进行排序）。

items = items.OrderBy(x => x.Name).ToList();
items.Sort((x,y) => x.Name.CompareTo(y.Name)); // If x.Name is never null
items.Sort((x,y) => String.Compare(x.Name, y.Name)); // null safe

- Jürgen Steinblock

总有一天，我会停止忘记额外的小事情，比如“我可以指定排序函数而不是依赖于IComparable”。这很棒，因为这使我能够避免将某些类指定为“可比较的”，当它们实际上并没有那种感觉，它们只需要在某些情况下进行排序。我已经将您的答案与Julien的数据结合起来，取得了成功。非常感谢！ - Grace Note

我更喜欢使用IComparer<T>而不是IComparable。这样你就可以传递不同的排序算法封装。 - Po-ta-toe

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Julien Lebosquain · Accepted Answer

重要的一点是，List<T>.Sort()在原地排序。如果您的列表暴露给外部代码，它将始终代表相同的对象。如果该列表由容器类外部的代码保留在字段中，则这很重要。如果您正在使用 OrderBy() 进行排序，则每次都会得到一个新的枚举，替换先前的 items。任何先前存储的列表都不会表示您的类的当前状态。

考虑性能，OrderBy 必须遍历整个列表以对项目进行排序。然后，您将调用 ToList() 从此枚举中创建新列表，第二次遍历该列表。另外，由于它是一个枚举，List 将使用加倍算法，直到每个元素都可以适合其中为止。对于大型列表，可能需要分配很多内存和进行内存复制。我预计性能比 List<T>.Sort() 要差得多。 编辑：小型基准测试：

internal class Program {

    private static List<int> CreateList(int size) {

        // use the same seed so that every list has the same elements
        Random random = new Random(589134554);

        List<int> list = new List<int>(size);
        for (int i = 0; i < size; ++i)
            list.Add(random.Next());
        return list;
    }

    private static void Benchmark(int size, bool output = true) {
        List<int> list1 = CreateList(size);
        List<int> list2 = CreateList(size);

        Stopwatch stopwatch = Stopwatch.StartNew();
        list1.Sort();
        stopwatch.Stop();
        double elapsedSort = stopwatch.Elapsed.TotalMilliseconds;
        if (output)
            Console.WriteLine("List({0}).Sort(): {1}ms (100%)", size, elapsedSort);

        stopwatch.Restart();
        list2.OrderBy(i => i).ToList();
        stopwatch.Stop();
        double elapsedOrderBy = stopwatch.Elapsed.TotalMilliseconds;
        if (output)
            Console.WriteLine("List({0}).OrderBy(): {1}ms ({2:.00%})", size, elapsedOrderBy, elapsedOrderBy / elapsedSort);

    }

    internal static void Main() {

        // ensure linq library is loaded and initialized
        Benchmark(1000, false);

        Benchmark(10);
        Benchmark(100);
        Benchmark(1000);
        Benchmark(10000);
        Benchmark(100000);
        Benchmark(1000000);

        Console.ReadKey();
    }
}

输出结果（按List.Sort规范化）：

List(10).Sort(): 0,0025ms (100%)
List(10).OrderBy(): 0,0157ms (628,00%)
List(100).Sort(): 0,0068ms (100%)
List(100).OrderBy(): 0,0294ms (432,35%)
List(1000).Sort(): 0,0758ms (100%)
List(1000).OrderBy(): 0,3107ms (409,89%)
List(10000).Sort(): 0,8969ms (100%)
List(10000).OrderBy(): 4,0751ms (454,35%)
List(100000).Sort(): 10,8541ms (100%)
List(100000).OrderBy(): 50,3497ms (463,88%)
List(1000000).Sort(): 124,1001ms (100%)
List(1000000).OrderBy(): 705,0707ms (568,15%)