C#：如何实现IOrderedEnumerable<T>

Question

我想为实践实现一些不同的算法，只是为了看看我到底有多糟糕，并变得更好:p

无论如何，我想我会尝试使用IEnumerable<T>和IOrderedEnumerable<T>以及其他.Net集合类型来兼容(以便以后可以更容易地使用我编写的内容)。

但是，除了使用IOrderedEnumerable<T>和ThenBy扩展方法之外，我找不到返回OrderBy实例的方法。所以我想我必须创建自己的类来实现这个接口。但是这个界面对我来说不太有意义。可能，但我不确定。

我创建了一个空类，添加了接口，然后让ReSharper为我添加空实现。看起来是这样的：

class MyOrderedEnumerable<T> : IOrderedEnumerable<T>
{
    /// <summary>
    /// Performs a subsequent ordering on the elements of an <see cref="T:System.Linq.IOrderedEnumerable`1"/> according to a key.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Linq.IOrderedEnumerable`1"/> whose elements are sorted according to a key.
    /// </returns>
    /// <param name="keySelector">The <see cref="T:System.Func`2"/> used to extract the key for each element.</param><param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare keys for placement in the returned sequence.</param><param name="descending">true to sort the elements in descending order; false to sort the elements in ascending order.</param><typeparam name="TKey">The type of the key produced by <paramref name="keySelector"/>.</typeparam><filterpriority>2</filterpriority>
    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
    /// </returns>
    /// <filterpriority>1</filterpriority>
    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
    /// </returns>
    /// <filterpriority>2</filterpriority>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

我不明白的是CreateOrderedEnumerable方法。它到底意味着什么？嗯，我想它当然会创建一个有序的可枚举的，但是如何？排序算法本身应该在那里吗？它会是什么样的呢？没有进入该方法的项的集合，那么它在哪里使集合被订购呢？你怎么用这门课？它是否意味着要实现，例如，需要对事物进行排序的东西中的私有助手类？

然后，与MyOrderedEnumerable<T> : IOrderedEnumerable<T>不同，您可能有一个QuickSorter<T> : IOrderedEnumerable<T>，它在构造函数中获取集合，并在调用CreateOrderedEnumerable方法时对其进行排序.但是，如果有人在调用该方法之前调用了GetEnumerator并开始枚举，那么会发生什么呢？

哈哈，这里刚刚发现我问过类似的问题。但这仅仅是如果有可能的话，返回一个。所以我想这个问题是对我得到的唯一答案的回答

Answer 1

我有一个你可以看的样本实现。它不是以任何方式被设计成高效的，但它应该会让你开始。

基本上，一个IOrderedEnumerable<T>只需要对它当前的顺序有一个概念，这样它就可以创建一个新的排序。假设您已经有了一个IComparer<T>，您可以通过这样的语句构建一个新的：

int Compare(T first, T second)
{
    if (baseComparer != null)
    {
        int baseResult = baseComparer.Compare(first, second);
        if (baseResult != 0)
        {
            return baseResult;
        }
    }
    TKey firstKey = keySelector(first);
    TKey secondKey = keySelector(second);

    return comparer.Compare(firstKey, secondKey);        
}

基本上，您创建了一个比较器链，从“最不重要的”到“最重要的”。您还需要在其中放置“下降”位，但这很简单:)

在上面链接的示例中，三个不同的方面在MiscUtil中已经存在的三个不同类中表示。

• ReverseComparer：逆转现有IComparer<T>的结果
• LinkedComparer：从两个中创建一个比较器，其中一个主和一个从
• ProjectionComparer：根据从原始项到键的投影创建一个比较器，委托另一个比较者来比较这些键。

比较器很适合像这样链接在一起。

Answer 2

您的类可能会有一些实现IEnumerable (例如List<T>)的内部存储变量。在这种情况下，这种方法的实现很简单：

private List<T> data = new List<T>();

public IOrderedEnumerable<CalculationResult> CreateOrderedEnumerable<TKey>(Func<CalculationResult, TKey> keySelector, IComparer<TKey> comparer, bool descending)
{
  return descending ? 
      data.OrderByDescending(keySelector, comparer) 
    : data.OrderBy(keySelector, comparer);
}