C# Enumerable.SortBy-使用哪个排序函数？

有谁能告诉我Linq.Sort by中使用了哪种类型的排序技术（冒泡、插入、选择）

---

编辑：是否还有一个简单的was，可以将其spe到这个函数中并亲自查看源代码-我曾经能够用Java实现这一点，因为没有LINQ

可枚举的方法

但是，有一个
Enumerable.OrderBy
函数，它实例化了一个新的
OrderedEnumerable
，该函数使用
EnumerableSorter
类。下面是这些类的源代码。欢迎你随意称呼他们

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    protected EnumerableSorter()
    {
    }

    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right)
    {
        do
        {
            int index = left;
            int num2 = right;
            int num3 = map[index + ((num2 - index) >> 1)];
            do
            {
                while ((index < map.Length) && (this.CompareKeys(num3, map[index]) > 0))
                {
                    index++;
                }
                while ((num2 >= 0) && (this.CompareKeys(num3, map[num2]) < 0))
                {
                    num2--;
                }
                if (index > num2)
                {
                    break;
                }
                if (index < num2)
                {
                    int num4 = map[index];
                    map[index] = map[num2];
                    map[num2] = num4;
                }
                index++;
                num2--;
            }
            while (index <= num2);
            if ((num2 - left) <= (right - index))
            {
                if (left < num2)
                {
                    this.QuickSort(map, left, num2);
                }
                left = index;
            }
            else
            {
                if (index < right)
                {
                    this.QuickSort(map, index, right);
                }
                right = num2;
            }
        }
        while (left < right);
    }

    internal int[] Sort(TElement[] elements, int count)
    {
        this.ComputeKeys(elements, count);
        int[] map = new int[count];
        for (int i = 0; i < count; i++)
        {
            map[i] = i;
        }
        this.QuickSort(map, 0, count - 1);
        return map;
    }
}

internal class EnumerableSorter<TElement, TKey> : EnumerableSorter<TElement>
{
    // Fields
    internal IComparer<TKey> comparer;
    internal bool descending;
    internal TKey[] keys;
    internal Func<TElement, TKey> keySelector;
    internal EnumerableSorter<TElement> next;

    // Methods
    internal EnumerableSorter(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending, EnumerableSorter<TElement> next)
    {
        this.keySelector = keySelector;
        this.comparer = comparer;
        this.descending = descending;
        this.next = next;
    }

    internal override int CompareKeys(int index1, int index2)
    {
        int num = this.comparer.Compare(this.keys[index1], this.keys[index2]);
        if (num == 0)
        {
            if (this.next == null)
            {
                return (index1 - index2);
            }
            return this.next.CompareKeys(index1, index2);
        }
        if (!this.descending)
        {
            return num;
        }
        return -num;
    }

    internal override void ComputeKeys(TElement[] elements, int count)
    {
        this.keys = new TKey[count];
        for (int i = 0; i < count; i++)
        {
            this.keys[i] = this.keySelector(elements[i]);
        }
        if (this.next != null)
        {
            this.next.ComputeKeys(elements, count);
        }
    }
}

内部抽象类EnumerableSorter
{
//方法
受保护的EnumerableSorter（）
{
}
内部摘要int CompareKeys（int index1，int index2）；
内部抽象无效计算（TElement[]元素，整数计数）；
私有void快速排序（int[]映射，int左，int右）
{
做
{
int索引=左；
int num2=右；
int num3=map[指数+（（num2-指数）>>1）]；
做
{
而（（索引0））
{
索引++；
}
while（（num2>=0）和&（this.CompareKeys（num3，map[num2]）<0））
{
num2--；
}
如果（索引>num2）
{
打破
}
如果（指数而（index没有LINQ
可枚举的方法

但是，有一个
Enumerable.OrderBy
函数，它实例化了一个新的
OrderedEnumerable
，该函数使用
EnumerableSorter
类。下面是这些类的源代码。欢迎您随意调用它们

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    protected EnumerableSorter()
    {
    }

    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right)
    {
        do
        {
            int index = left;
            int num2 = right;
            int num3 = map[index + ((num2 - index) >> 1)];
            do
            {
                while ((index < map.Length) && (this.CompareKeys(num3, map[index]) > 0))
                {
                    index++;
                }
                while ((num2 >= 0) && (this.CompareKeys(num3, map[num2]) < 0))
                {
                    num2--;
                }
                if (index > num2)
                {
                    break;
                }
                if (index < num2)
                {
                    int num4 = map[index];
                    map[index] = map[num2];
                    map[num2] = num4;
                }
                index++;
                num2--;
            }
            while (index <= num2);
            if ((num2 - left) <= (right - index))
            {
                if (left < num2)
                {
                    this.QuickSort(map, left, num2);
                }
                left = index;
            }
            else
            {
                if (index < right)
                {
                    this.QuickSort(map, index, right);
                }
                right = num2;
            }
        }
        while (left < right);
    }

    internal int[] Sort(TElement[] elements, int count)
    {
        this.ComputeKeys(elements, count);
        int[] map = new int[count];
        for (int i = 0; i < count; i++)
        {
            map[i] = i;
        }
        this.QuickSort(map, 0, count - 1);
        return map;
    }
}

internal class EnumerableSorter<TElement, TKey> : EnumerableSorter<TElement>
{
    // Fields
    internal IComparer<TKey> comparer;
    internal bool descending;
    internal TKey[] keys;
    internal Func<TElement, TKey> keySelector;
    internal EnumerableSorter<TElement> next;

    // Methods
    internal EnumerableSorter(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending, EnumerableSorter<TElement> next)
    {
        this.keySelector = keySelector;
        this.comparer = comparer;
        this.descending = descending;
        this.next = next;
    }

    internal override int CompareKeys(int index1, int index2)
    {
        int num = this.comparer.Compare(this.keys[index1], this.keys[index2]);
        if (num == 0)
        {
            if (this.next == null)
            {
                return (index1 - index2);
            }
            return this.next.CompareKeys(index1, index2);
        }
        if (!this.descending)
        {
            return num;
        }
        return -num;
    }

    internal override void ComputeKeys(TElement[] elements, int count)
    {
        this.keys = new TKey[count];
        for (int i = 0; i < count; i++)
        {
            this.keys[i] = this.keySelector(elements[i]);
        }
        if (this.next != null)
        {
            this.next.ComputeKeys(elements, count);
        }
    }
}

内部抽象类EnumerableSorter
{
//方法
受保护的EnumerableSorter（）
{
}
内部摘要int CompareKeys（int index1，int index2）；
内部抽象无效计算（TElement[]元素，整数计数）；
私有void快速排序（int[]映射，int左，int右）
{
做
{
int索引=左；
int num2=右；
int num3=map[指数+（（num2-指数）>>1）]；
做
{
而（（索引0））
{
索引++；
}
while（（num2>=0）和&（this.CompareKeys（num3，map[num2]）<0））
{
num2--；
}
如果（索引>num2）
{
打破
}
如果（指数而（index在reflector中查找后，
OrderBy
LINQ操作符使用快速排序

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    protected EnumerableSorter();
    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right);
    internal int[] Sort(TElement[] elements, int count);
}

内部抽象类EnumerableSorter
{
//方法
[TargetedPatchingOptOut（“性能对于跨NGen映像边界内联这种类型的方法至关重要”）]
受保护的EnumerableSorter（）；
内部摘要int CompareKeys（int index1，int index2）；
内部抽象无效计算（TElement[]元素，整数计数）；
私有void快速排序（int[]映射，int左，int右）；
内部int[]排序（TElement[]元素，int计数）；
}

方法名
QuickSort
使其非常明显，并且算法确认了这一点

要检查部件，请使用以下工具（通常使用的名称是reflector，但是，它在下一个版本中将不再免费，所有免费版本都包含基于时间的禁用开关，最后一个免费版本将在2011年3月的某个时间禁用）.
在reflector中查找后，
OrderBy
LINQ操作符使用快速排序

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    protected EnumerableSorter();
    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right);
    internal int[] Sort(TElement[] elements, int count);
}

内部抽象类EnumerableSorter
{
//方法
[TargetedPatchingOptOut（“性能对于跨NGen映像边界内联这种类型的方法至关重要”）]
受保护的EnumerableSorter（）；
内部摘要int CompareKeys（int index1，int index2）；
内部抽象无效计算（TElement[]元素，整数计数）；
私有void快速排序（int[]映射，int左，int右）；
内部int[]排序（TElement[]元素，int计数）；
}

方法名
QuickSort
使其非常明显，并且算法确认了这一点

要检查组件，请使用以下工具（通常使用的名称是reflector，但是，它在下一个版本中将不再免费，并且所有免费版本都包含基于时间的禁用开关，最后一个免费版本将在2011年3月某个时间禁用）。
仅用于状态的文档

此方法执行稳定排序；即，如果两个元素的键相等，则保留元素的顺序

这意味着不同版本的.NET Framework的实现可能有所不同，但假设它是O（n log n）

编辑

需要注意的是，的文档中明确提到了快速排序的使用（并注意到它是不稳定的）。
仅用于状态的文档

此方法执行稳定排序；即，如果两个元素的键相等，则保留元素的顺序

这意味着不同版本的.NET Framework的实现可能有所不同，但假设它是O（n log n）

编辑

需要注意的是，e