Question

我目前无法找到从SortedList获取IOrderedEnumerable的方法。

我有一个复杂的类型，我们只是称它为“A＆＃39;就目前而言，它可以被分解为类型A＆＃39;的可枚举类型。我目前正在递归分解函数中创建一个SortedList，其中键function onClick10f1(e: MouseEvent) { addChild(dropBall1) removeChild(bigBall1) dropBall1.x = 356.10; dropBall1.y = 28; var bigBDrop1: Tween = new Tween(dropBall1, "y", Regular.easeIn, 28, 156, 1, true); removeChild(dropBall1);与片段分解的顺序相关：

int

但是，我不想将SortedList暴露给消费者，因为与分解顺序相关的密钥值对消费者没什么意义（特别是作为private static SortedList<int, A> RecursivelyBuildMySortedList(A myValue) { if (myValue == StopCondition()) { return new SortedList<int, A> { { 1, myValue } }; } var left = RecursivelyBuildMySortedList(myValue.Left); var right = RecursivelyBuildMySortedList(myValue.Right).Select(entry => new KeyValuePair<int, A>(entry.Key + left.Count, entry.Value)).ToList(); right.ForEach(pair => left.Add(pair.Key, pair.Value)); return left; }）。消费者唯一需要关心的是这些碎片的最终排序是什么，以便每件都能以正确的顺序进行处理。我更愿意向消费者公开IOrderedEnumerable。我认为这将是一个相当简单的任务，因为SortedList在许多方面与OrderedEnumerable非常相似，但我还没有找到一个好的转换：

int

有没有人有一种方法可以从SortedList中提取IOrderedEnumerable以供消费？作为旁注，我意识到：

public static IOrderedEnumerable<A> Decompose(A myValue)
{
    SortedList<int, A> mySortedList = RecursivelyBuildMySortedList(myValue);

    // Can't find a way to preserve the order of the objects during 'OrderBy'
    // mySortedList.Select(keyValuePair => keyValuePair.Value).OrderBy(obj => obj.index);

    // The select statement would not match the return type that promises IOrderedEnumerable
    // mySortedList.OrderBy(keyValuePair => keyValuePair.Key).Select(keyValuePair => keyValuePair.Value);

}

会返回一个IEnumerable，它会保留顺序＆＃39;但是由于处理枚举的顺序有多重要，我宁愿返回类型足够描述以表达订购基础集合（以使API更具可读性）。

Answer 1

您需要使用SortedList的值值：

  private IOrderedEnumerable<string> GetResults() {
     SortedList<int, string> list = new SortedList<int, string>();
     list.Add(40, "Mehrzad");
     list.Add(20, "Chehraz");
     return list.Values.OrderBy(key => 0);         
  }

然后使用：

 IOrderedEnumerable<string> enumerable = GetResults();
 foreach (var item in enumerable) {
     System.Diagnostics.Debug.WriteLine(item);
 }

它起作用，因为OrderBy（key =＆gt; 0）以原始顺序返回值，这些值按SortedList排序。

或者您可以实现IOrderedEnumerable（我的旧答案）：

class OrderedEnumerableWithoutKey<TKey, TValue> : IOrderedEnumerable<TValue> {
     private IOrderedEnumerable<KeyValuePair<TKey, TValue>> inner;
     public OrderedEnumerableWithoutKey(IOrderedEnumerable<KeyValuePair<TKey, TValue>> inner) {
        this.inner = inner;
     }
     public IOrderedEnumerable<TValue> CreateOrderedEnumerable<TKey1>(Func<TValue, TKey1> keySelector, IComparer<TKey1> comparer, bool descending) {
        throw new NotImplementedException();
     }
     public IEnumerator<TValue> GetEnumerator() {
        return new Enumerator(inner.GetEnumerator());
     }
     IEnumerator IEnumerable.GetEnumerator() {
        return new Enumerator(inner.GetEnumerator());
     }
     class Enumerator : IEnumerator<TValue> {
        private IEnumerator<KeyValuePair<TKey, TValue>> inner;
        public Enumerator(IEnumerator<KeyValuePair<TKey, TValue>> inner) {
           this.inner = inner;
        }
        public TValue Current {
           get {
              return inner.Current.Value;
           }
        }
        object IEnumerator.Current {
           get {
              return inner.Current.Value;
           }
        }
        public void Dispose() {
           this.inner.Dispose();
        }
        public bool MoveNext() {
           return this.inner.MoveNext();
        }
        public void Reset() {
           this.inner.Reset();
        }
     }
  }

然后以这种方式使用它：

private IOrderedEnumerable<string> GetResults() {
     SortedList<int, string> list = new SortedList<int, string>();
     list.Add(20, "Mehrzad");
     list.Add(10, "Chehraz");
     return new OrderedEnumerableWithoutKey<int, string>(list.OrderBy(item => item.Key));    }
..
..
// Consumer part:
IOrderedEnumerable<string> enumerable = GetResults();
foreach (var item in enumerable) {
      System.Diagnostics.Debug.WriteLine(item);
}
// Outputs:
// Cherhaz
// Mehrzad

Answer 2

没有IOrderedEnumerable的公开实施可用。你必须自己动手。

在Enumerable.OrderBy和Enumerable.OrderByDescending的帮助下，这很简单。使用尽可能少的代码，请参阅下面的实现。

public class SortedListOrderedEnumerable<TKey, TValue> : IOrderedEnumerable<TValue>
{
    private readonly SortedList<TKey, TValue> innerList;
    public SortedListOrderedEnumerable(SortedList<TKey, TValue> innerList)
    {
        this.innerList = innerList;
    }

    public IOrderedEnumerable<TValue> CreateOrderedEnumerable<TKey1>(Func<TValue, TKey1> keySelector, IComparer<TKey1> comparer, bool @descending)
    {
        return @descending 
            ? innerList.Values.OrderByDescending(keySelector, comparer) 
            : innerList.Values.OrderBy(keySelector, comparer);
    }

    public IEnumerator<TValue> GetEnumerator()
    {
        return innerList.Values.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public static class Ext
{
    public static IOrderedEnumerable<TValue> AsOrderedEnumerable<TKey, TValue>(
        this SortedList<TKey, TValue> list)
    {
        return new SortedListOrderedEnumerable<TKey, TValue>(list);
    } 
}

然后将其用作

SortedList<int, string> list = new SortedList<int, string>();
...
var ordered = list.AsOrderedEnumerable()
    .ThenBy(...)
    .ThenByDescending(...);

现在你的Decompose方法将变为

public static IOrderedEnumerable<A> Decompose(A myValue)
{
    SortedList<int, A> mySortedList = RecursivelyBuildMySortedList(myValue);        
    return mySortedList.AsOrderedEnumerable();
}

修改：更新了我的初始答案以返回IOrderedEnumerable<TValue>，原始答案为IOrderedEnumerable<KeyValuePair<TKey,TValue>>

Answer 3

您可能不希望使用IOrderedEnumerable。

IOrderedEnumerable仅适用于ThenBy(...)之类的内容，您可以在运行时动态指定排序顺序（实际上，只需构建比较器）。

另一方面，

SortedList具有恒定的排序顺序和比较器 - 它的排序不能改变。

我建议坚持IEnumerable，除非你有充分的理由说明你还没有说明。请记住，接口不是用来记录类型的（即通过说“这是有序的”）。他们在那里公开功能。

将SortedList转换为IOrderedEnumerable

3 个答案: