Convert SortedList in IOrderedEnumerable

Question

Ich habe derzeit Probleme, einen Weg zu finden, eine IOrderedEnumerable von einer SortedList zu erhalten.

Ich habe einen komplexen Typ, wir werden es jetzt nur 'A' nennen, das kann in eine Aufzählung vom Typ 'A' zerlegt werden. Ich bin derzeit einen SortedList in einer rekursiven Zerlegung Funktion schaffen, in dem der Schlüssel, ein int, auf die auftragsbezogene wird das Stück in zerlegt wurde: Jedoch

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; 
} 

, ich will nicht den SortedList für die Verbraucher belichten da der Wert des Schlüssels, der sich auf die Zerlegungsreihenfolge bezieht, für Verbraucher wenig Bedeutung hat (insbesondere als int). Das einzige, worüber sich ein Verbraucher kümmern muss, ist die endgültige Bestellung der Stücke, so dass jedes Stück in der richtigen Reihenfolge verarbeitet werden kann. Ich würde es vorziehen, den Verbrauchern ein IteredEnumerable zugänglich zu machen. Ich dachte, das eine ziemlich einfache Aufgabe sein würde, da ein SortedList in vielerlei Hinsicht sehr ähnlich einen OrderedEnumerable ist, aber ich habe noch nicht eine gute Umwandlung finden kann:

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); 

} 

Hat jemand ein Verfahren zum Extrahieren ein IOrderedEnumerable von einer SortedList zum Verbrauch? Als Randbemerkung, ich bin mir dessen bewusst, dass:

return mySortedList.Select(keyValuePair => keyValuePair.Value); 

Würde ein IEnumerable zurückgeben, um ‚unter der Haube‘, aber wegen, wie wichtig die Reihenfolge, in der die zählbare ist verarbeitet bewahren würde, würde ich lieber Der Rückgabetyp muss beschreibend genug sein, um zu belegen, dass die zugrunde liegende Sammlung geordnet ist (um die API lesbarer zu machen).

Answer 1

Sie müssen die Werte propery der SortedList verwenden:

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);   
    } 

Und dann verwenden:

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

Es seit SortiertNach arbeitet (key => 0) gibt Werte in ihrer ursprünglichen Reihenfolge der sind nach SortedList sortiert.

Oder Sie können IOrderedEnumerable (Meine alte Antwort) implementieren:

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(); 
     } 
    } 
    } 

es dann in dieser Art und Weise verwenden:

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

Es gibt keine öffentliche Umsetzung IOrderedEnumerable zur Verfügung. Sie müssen selbst rollen.

Es ist ziemlich einfach mit Hilfe von Enumerable.OrderBy und Enumerable.OrderByDescending zu tun. Mit minimalem möglichen Code, sehen Sie die Implementierung unten.

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); 
    } 
} 

verwenden sie dann als

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

Jetzt ist Ihre Decompose Methode

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

bearbeiten werden wird: Aktualisiert meine erste Antwort IOrderedEnumerable<TValue>, in Original Antwort zurück, es war IOrderedEnumerable<KeyValuePair<TKey,TValue>>

Answer 3

Sie möchten wahrscheinlich nichtverwendendafür.

IOrderedEnumerable existiert nur für Dinge wie ThenBy(...), wo Sie dynamisch die Sortierreihenfolge zur Laufzeit angeben (wirklich, nur einen Vergleich zu bauen).

SortedList auf der anderen Seite hat eine konstante Sortierreihenfolge und Vergleich - seine Reihenfolge kann nicht ändern.

Ich schlage vor, IEnumerable beizubehalten, es sei denn, Sie haben einen guten Grund, den Sie noch nicht angegeben haben. Denken Sie daran, dass Schnittstellen nicht dazu da sind, einen Typ zu dokumentieren (d. H., Indem Sie sagen "das ist geordnet"). Sie sind da, um die Funktionalität aufzudecken.