IOrderedEnumerable<T> 与 SortedSet<T>：哪个序列化更快？

进行测量以找出哪个集合创建和迭代更快IOrderedEnumerable<T>或SortedSet<T>

internal class User
{
    public string Surname { get; set; }
    public string Name { get; set; }
    public int DocumNumber { get; set; }
}

internal class UserDto : IComparable<UserDto>
{
    public string FullName { get; set; }
    public int DocumNumber { get; set; }
    public int CompareTo(UserDto other)
    {
        return string.Compare(this.FullName, other.FullName, StringComparison.Ordinal);
    }
}
class Program
{
    static void Main(string[] args)
    {
        const int count = 1000000;
        var users = new List<User>();
        for (var i = 0; i < count; i++)
        {
            users.Add(new User
            {
                Name = "Name",
                Surname = "Surname",
                DocumNumber = i
            });
        }

        // IOrderedEnumerable<T>
        var watch = Stopwatch.StartNew();
        var userDtoList = new List<UserDto>();
        foreach (var user in users)
        {
            userDtoList.Add(new UserDto
            {
                FullName = $"{user.Surname} {user.Name}",
                DocumNumber = user.DocumNumber
            });
        }
        var orderedEnumerableUserDto = userDtoList.OrderBy(u => u.FullName);
        foreach (var userDto in orderedEnumerableUserDto)
        {
            // просто делаем некую работу
        }
        watch.Stop();
        Console.WriteLine("IOrderedEnumerable<T>: {0}ms", watch.ElapsedMilliseconds);

        // SortedSet<T>                                                                 
        watch.Restart();
        var sortedSetUserDto = new SortedSet<UserDto>();
        foreach (var user in users)
        {
            sortedSetUserDto.Add(new UserDto
            {
                FullName = $"{user.Surname} {user.Name}",
                DocumNumber = user.DocumNumber
            });
        }
        foreach (var userDto in sortedSetUserDto)
        {
            // просто делаем некую работу
        }
        watch.Stop();
        Console.WriteLine("SortedSet<T>: {0}ms", watch.ElapsedMilliseconds);

        System.Console.ReadKey();
    }
}

根据三个测量的结果，平均值如下：

IOrderedEnumerable<T>: 4661 ms 
SortedSet<T>:          611 ms

快了近 8 倍SortedSet<T>。

一点关于 IOrderedEnumerable

在帖子的开头，我称它为IOrderedEnumerable<T>集合。我知道我错了，对不起，我只是不知道在比较集合和界面时如何正确操作。

我不明白这个接口是如何工作的，它返回什么样的枚举器。因为如果我们从两个测量中删除块

foreach (var userDto in orderedEnumerableUserDto)
{
    // просто делаем некую работу
}

我们将看到测量显示相同的结果。我确定表达式

var orderedEnumerableUserDto = userDtoList.OrderBy(u => u.FullName);

不会在内存中进行任何排序，否则会花费很多时间。在那里，很可能只发生了对象的标记——枚举器接口将调用哪个队列中的谁IOrderedEnumerable，例如

问题

我提出了我的想法IOrderedEnumerable<T>，因为我想说如果我从内部理解它是如何工作的，那么也许这个问题就不会出现。好吧，问题是：这两个选项中的哪一个更好地返回给控制器，这将在 JSON 中序列化所有这些优点，这会更快地发生吗？

我不够聪明，无法测量这两个对象的序列化速度，如果将这样的测量显示为答案，我将不胜感激。