eine IOrderedEnumerable Graf ohne es

Question

raubend Was ich tun möchte, kurze Version:

var source = new[]{2,4,6,1,9}.OrderBy(x=>x); 
int count = source.Count; // <-- get the number of elements without performing the sort 

---

Lange Version:

Um die Anzahl der Elemente in einem IEnumerable, es festzustellen, ist notwendig, um über alle Elemente zu iterieren. Dies könnte möglicherweise eine sehr teure Operation sein.

Wenn die IEnumerable kann ICollection gegossen werden, dann kann die Zählung schnell ohne Iteration bestimmt werden. Die LINQ Count() -Methode führt dies automatisch aus.

Die Funktion myEnumerable.OrderBy() eine IOrderedEnumerable zurückgibt. Ein IOrderedEnumerable kann natürlich nicht auf ICollection umgewandelt werden, so ruft Count() wird die ganze Sache verbrauchen.

Die Sortierung ändert jedoch nicht die Anzahl der Elemente, und ein IOrderedEnumerable muss einen Verweis auf seine Quelle behalten. Wenn also diese Quelle eine ICollection ist, sollte es möglich sein, die Zählung von IOrderedEnumerable zu ermitteln, ohne sie zu verbrauchen.

Mein Ziel ist es, eine Bibliotheksmethode zu haben, die eine IEnumerable mit n Elementen nimmt und dann zum Beispiel das Element an der Position n/2 abruft;

Ich möchte vermeiden, zweimal über die IEnumerable zweimal nur um seine Anzahl zu bekommen, aber ich möchte auch vermeiden, eine unnötige Kopie zu erstellen, wenn überhaupt möglich.

---

ist hier ein Skelett der Funktion I

public void DoSomething(IEnumerable<T> source) 
{ 
    int count; // What we do with the source depends on its length 

    if (source is ICollection) 
    { 
     count = source.Count(); // Great, we can use ICollection.Count 
    } 
    else if (source is IOrderedEnumerable) 
    { 
     // TODO: Find out whether this is based on an ICollection, 
     // TODO: then determine the count of that ICollection 
    } 
    else 
    { 
     // Iterating over the source may be expensive, 
     // to avoid iterating twice, make a copy of the source 
     source = source.ToList(); 
     count = source.Count(); 
    } 

    // do some stuff 

} 

Answer 1

Lassen Sie uns überlegen, was dieser Code tatsächlich aussieht:

var source = new[]{ 2, 4, 6, 1, 9 }.OrderBy(x => x); 
int count = source.Count(); 

Es gleiche wie

int count = Enumerable.Count(Enumerable.OrderBy(new[]{ 2, 4, 6, 1, 9 }, x => x)); 

Ergebnis Enumerable.OrderBy(new[]{ 2, 4, 6, 1, 9 }, x => x) in Count Erweiterung übergeben wird. Sie können nicht vermeiden, OrderBy Ausführung. Und so ist es ein Nicht-Streaming-Operator, der alle Quellen verbraucht, bevor er etwas zurückgibt, das an Count übergeben wird.

Die einzige Möglichkeit, die Iteration über die gesamte Sammlung zu vermeiden, ist die Vermeidung von OrderBy - Elemente vor dem Sortieren zählen.

---

UPDATE: Sie können auf jedem OrderedEnumerable diese Erweiterung Methode aufrufen - es Reflexion verwenden source Bereich OrderedEnumerable<T> zu erhalten, die Quellsequenz hält. Dann prüfen Sie, ob diese Sequenz Sammlung ist, und verwenden Sie Count ohne Ausführung Bestellung:

public static class Extensions 
{ 
    public static int Count<T>(this IOrderedEnumerable<T> ordered) 
    { 
     // you can check if ordered is of type OrderedEnumerable<T> 
     Type type = ordered.GetType(); 
     var flags = BindingFlags.NonPublic | BindingFlags.Instance; 
     var field = type.GetField("source", flags); 
     var source = field.GetValue(ordered); 
     if (source is ICollection<T>) 
      return ((ICollection<T>)source).Count; 

     return ordered.Count(); 
    } 
} 

Verbrauch:

var source = new[]{ 2, 4, 6, 1, 9 }.OrderBy(x => x); 
int count = source.Count(); 

Answer 2

Wenn Sie schauen, erstellen eine performante Lösung erstellen möchte ich die Schaffung Überlastungen betrachten würde, die entweder eine Sammlung oder ein IOrderedEnumerable nehmen usw. .. alles, was "ist" und "wie" Typchecking und Casting kann nicht gut für die Art von Dingen, die Sie erstellen.

Sie erfinden das Rad neu. linq's "Count()" Funktion macht so ziemlich wie Sie wollen.

Fügen Sie auch das Schlüsselwort this hinzu und machen Sie dies zu einer raffinierten Erweiterungsmethode, um sich selbst und andere mit dem Code zufrieden zu stellen.

DoSomething(this Collection source); 
DoSomething<T>(this List<T> source); 
DoSomething<T>(this IOrderedEnumerable<T> source); 

etc ...

Answer 3

Ein weiterer Ansatz ist es, eine Klasse zu implementieren, die IOrderedEnumerable<T> implementiert. Sie können dann Klassenelemente implementieren, die die üblichen Linq-Erweiterungsmethoden kurzschließen, und eine Zählmethode bereitstellen, die die ursprüngliche Enumeration berücksichtigt.

public class MyOrderedEnumerable<T> : IOrderedEnumerable<T> 
{ 
    private IEnumerable<T> Original; 
    private IOrderedEnumerable<T> Sorted; 

    public MyOrderedEnumerable(IEnumerable<T> orig) 
    { 
      Original = orig; 
      Sorted = null; 
    } 

    private void ApplyOrder<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending) 
    { 
      var before = Sorted != null ? Sorted : Original; 
      if (descending) 
        Sorted = before.OrderByDescending(keySelector, comparer); 
      else 
        Sorted = before.OrderBy(keySelector, comparer); 
    } 

    #region Interface Implementations 

    public IEnumerator<T> GetEnumerator() 
    { 
      return Sorted != null ? Sorted.GetEnumerator() : Original.GetEnumerator(); 
    } 

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

    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(
      Func<T, TKey> keySelector, 
      IComparer<TKey> comparer, 
      bool descending) 
    { 
      var newSorted = new MyOrderedEnumerable<T>(Original); 
      newSorted.ApplyOrder(keySelector, comparer, descending); 
      return newSorted; 
    } 

    #endregion Interface Implementations 


    //Ensure that OrderBy returns the right type. 
    //There are other variants of OrderBy extension methods you'll have to short-circuit 
    public MyOrderedEnumerable<T> OrderBy<TKey>(Func<T, TKey> keySelector) 
    { 
      Console.WriteLine("Ordering"); 
      var newSorted = new MyOrderedEnumerable<T>(Original); 
      newSorted.Sorted = (Sorted != null ? Sorted : Original).OrderBy(keySelector); 
      return newSorted; 
    } 

    public int Count() 
    { 
      Console.WriteLine("Fast counting.."); 
      var collection = Original as ICollection; 
      return collection == null ? Original.Count() : collection.Count; 
    } 

    public static void Test() 
    { 
      var nums = new MyOrderedEnumerable<int>(Enumerable.Range(0,10).ToList()); 
      var nums2 = nums.OrderBy(x => -x); 
      var z = nums.Count() + nums2.Count(); 
    } 
}