Zählen Sie die Elemente aus einem IEnumerable <T> ohne Iteration?

private IEnumerable<string> Tables
{
    get
    {
        yield return "Foo";
        yield return "Bar";
    }
}

Nehmen wir an, ich möchte diese iterieren und so etwas wie die Verarbeitung von #n von #m schreiben.

Gibt es eine Möglichkeit, den Wert von m herauszufinden, ohne vor meiner Hauptiteration zu iterieren?

Ich hoffe ich habe mich klar gemacht.

IEnumerableunterstützt dies nicht. Dies ist beabsichtigt. IEnumerableverwendet die verzögerte Auswertung, um die gewünschten Elemente abzurufen, bevor Sie sie benötigen.

Wenn Sie die Anzahl der Elemente wissen möchten, ohne sie zu durchlaufen ICollection<T>, haben Sie eine CountEigenschaft.

Die System.Linq.Enumerable.CountErweiterungsmethode on IEnumerable<T>hat die folgende Implementierung:

ICollection<T> c = source as ICollection<TSource>;
if (c != null)
    return c.Count;

int result = 0;
using (IEnumerator<T> enumerator = source.GetEnumerator())
{
    while (enumerator.MoveNext())
        result++;
}
return result;

Also versucht es zu werfen ICollection<T>, was eine CountEigenschaft hat, und verwendet diese, wenn möglich. Andernfalls iteriert es.

Daher ist es am besten, die Count()Erweiterungsmethode für Ihr IEnumerable<T>Objekt zu verwenden, da Sie auf diese Weise die bestmögliche Leistung erzielen.

Fügen Sie einfach einige zusätzliche Informationen hinzu:

Die Count()Erweiterung iteriert nicht immer. Betrachten Sie Linq to Sql, wo die Anzahl in die Datenbank geht. Anstatt jedoch alle Zeilen zurückzubringen, wird der Count()Befehl Sql ausgegeben und stattdessen das Ergebnis zurückgegeben.

Darüber hinaus ist der Compiler (oder die Laufzeit) so intelligent, dass er die Objektmethode Count()aufruft, falls vorhanden. Es ist also nicht so, wie andere Antwortende sagen, völlig ignorant zu sein und immer zu iterieren, um Elemente zu zählen.

In vielen Fällen, in denen der Programmierer nur if( enumerable.Count != 0 )mit der Any()Erweiterungsmethode prüft , if( enumerable.Any() ) ist dies bei der verzögerten Auswertung von linq weitaus effizienter, da er kurzschließen kann, sobald er feststellt, dass Elemente vorhanden sind. Es ist auch besser lesbar

Ein Freund von mir hat eine Reihe von Blog-Posts, die veranschaulichen, warum Sie dies nicht tun können. Er erstellt eine Funktion, die eine IEnumerable zurückgibt, wobei jede Iteration die nächste Primzahl bis zu zurückgibt ulong.MaxValueund das nächste Element erst berechnet wird, wenn Sie danach fragen. Schnelle Pop-Frage: Wie viele Artikel werden zurückgegeben?

Hier sind die Beiträge, aber sie sind ziemlich lang:

1. Beyond Loops (bietet eine anfängliche EnumerableUtility-Klasse, die in den anderen Posts verwendet wird)
2. Anwendungen von Iterate ( Erstimplementierung )
3. Verrückte Erweiterungsmethoden: ToLazyList (Leistungsoptimierungen)

IEnumerable kann nicht ohne Iteration zählen.

Unter "normalen" Umständen können Klassen, die IEnumerable oder IEnumerable <T> implementieren, wie z. B. List <T>, die Count-Methode implementieren, indem sie die List <T> .Count-Eigenschaft zurückgeben. Die Count-Methode ist jedoch keine Methode, die auf der IEnumerable <T> - oder IEnumerable-Schnittstelle definiert ist. (Der einzige, der tatsächlich ist, ist GetEnumerator.) Dies bedeutet, dass keine klassenspezifische Implementierung dafür bereitgestellt werden kann.

Count it ist vielmehr eine Erweiterungsmethode, die in der statischen Klasse Enumerable definiert ist. Dies bedeutet, dass es für jede Instanz einer von IEnumerable <T> abgeleiteten Klasse aufgerufen werden kann, unabhängig von der Implementierung dieser Klasse. Es bedeutet aber auch, dass es an einem einzigen Ort außerhalb einer dieser Klassen implementiert wird. Was natürlich bedeutet, dass es auf eine Weise implementiert werden muss, die völlig unabhängig von den Interna dieser Klasse ist. Die einzige Möglichkeit zum Zählen ist die Iteration.

Alternativ können Sie Folgendes tun:

Tables.ToList<string>().Count;

Nein, im Allgemeinen nicht. Ein Punkt bei der Verwendung von Aufzählungszeichen ist, dass die tatsächliche Menge von Objekten in der Aufzählung nicht bekannt ist (im Voraus oder überhaupt nicht).

Sie können System.Linq verwenden.

using System;
using System.Collections.Generic;
using System.Linq;

public class Test
{
    private IEnumerable<string> Tables
    {
        get {
             yield return "Foo";
             yield return "Bar";
         }
    }

    static void Main()
    {
        var x = new Test();
        Console.WriteLine(x.Tables.Count());
    }
}

Sie erhalten das Ergebnis '2'.

Wenn Sie über Ihre unmittelbare Frage hinausgehen (die gründlich verneint wurde), während Sie den Fortschritt während der Verarbeitung einer Aufzählung melden möchten, sollten Sie sich meinen Blog-Beitrag " Fortschritte bei Linq-Abfragen melden" ansehen .

Damit können Sie Folgendes tun:

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += (sender, e) =>
      {
          // pretend we have a collection of 
          // items to process
          var items = 1.To(1000);
          items
              .WithProgressReporting(progress => worker.ReportProgress(progress))
              .ForEach(item => Thread.Sleep(10)); // simulate some real work
      };

Ich habe diese Methode in einer Methode verwendet, um den übergebenen IEnumberableInhalt zu überprüfen

if( iEnum.Cast<Object>().Count() > 0) 
{

}

Innerhalb einer Methode wie dieser:

GetDataTable(IEnumberable iEnum)
{  
    if (iEnum != null && iEnum.Cast<Object>().Count() > 0) //--- proceed further

}

Dies hängt von der Version von .Net und der Implementierung Ihres IEnumerable-Objekts ab. Microsoft hat die IEnumerable.Count-Methode behoben, um nach der Implementierung zu suchen, und verwendet ICollection.Count oder ICollection <TSource> .Count. Weitere Informationen finden Sie hier https://connect.microsoft.com/VisualStudio/feedback/details/454130

Und unten ist die MSIL von Ildasm für System.Core, in der sich die System.Linq befindet.

.method public hidebysig static int32  Count<TSource>(class 

[mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource> source) cil managed
{
  .custom instance void System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
  // Code size       85 (0x55)
  .maxstack  2
  .locals init (class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource> V_0,
           class [mscorlib]System.Collections.ICollection V_1,
           int32 V_2,
           class [mscorlib]System.Collections.Generic.IEnumerator`1<!!TSource> V_3)
  IL_0000:  ldarg.0
  IL_0001:  brtrue.s   IL_000e
  IL_0003:  ldstr      "source"
  IL_0008:  call       class [mscorlib]System.Exception System.Linq.Error::ArgumentNull(string)
  IL_000d:  throw
  IL_000e:  ldarg.0
  IL_000f:  isinst     class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>
  IL_0014:  stloc.0
  IL_0015:  ldloc.0
  IL_0016:  brfalse.s  IL_001f
  IL_0018:  ldloc.0
  IL_0019:  callvirt   instance int32 class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>::get_Count()
  IL_001e:  ret
  IL_001f:  ldarg.0
  IL_0020:  isinst     [mscorlib]System.Collections.ICollection
  IL_0025:  stloc.1
  IL_0026:  ldloc.1
  IL_0027:  brfalse.s  IL_0030
  IL_0029:  ldloc.1
  IL_002a:  callvirt   instance int32 [mscorlib]System.Collections.ICollection::get_Count()
  IL_002f:  ret
  IL_0030:  ldc.i4.0
  IL_0031:  stloc.2
  IL_0032:  ldarg.0
  IL_0033:  callvirt   instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource>::GetEnumerator()
  IL_0038:  stloc.3
  .try
  {
    IL_0039:  br.s       IL_003f
    IL_003b:  ldloc.2
    IL_003c:  ldc.i4.1
    IL_003d:  add.ovf
    IL_003e:  stloc.2
    IL_003f:  ldloc.3
    IL_0040:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
    IL_0045:  brtrue.s   IL_003b
    IL_0047:  leave.s    IL_0053
  }  // end .try
  finally
  {
    IL_0049:  ldloc.3
    IL_004a:  brfalse.s  IL_0052
    IL_004c:  ldloc.3
    IL_004d:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_0052:  endfinally
  }  // end handler
  IL_0053:  ldloc.2
  IL_0054:  ret
} // end of method Enumerable::Count

Hier ist eine großartige Diskussion über die verzögerte Bewertung und die verzögerte Ausführung . Grundsätzlich müssen Sie die Liste materialisieren, um diesen Wert zu erhalten.

Das Ergebnis der Funktion IEnumerable.Count () ist möglicherweise falsch. Dies ist ein sehr einfach zu testendes Beispiel:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;

namespace Test
{
  class Program
  {
    static void Main(string[] args)
    {
      var test = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
      var result = test.Split(7);
      int cnt = 0;

      foreach (IEnumerable<int> chunk in result)
      {
        cnt = chunk.Count();
        Console.WriteLine(cnt);
      }
      cnt = result.Count();
      Console.WriteLine(cnt);
      Console.ReadLine();
    }
  }

  static class LinqExt
  {
    public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int chunkLength)
    {
      if (chunkLength <= 0)
        throw new ArgumentOutOfRangeException("chunkLength", "chunkLength must be greater than 0");

      IEnumerable<T> result = null;
      using (IEnumerator<T> enumerator = source.GetEnumerator())
      {
        while (enumerator.MoveNext())
        {
          result = GetChunk(enumerator, chunkLength);
          yield return result;
        }
      }
    }

    static IEnumerable<T> GetChunk<T>(IEnumerator<T> source, int chunkLength)
    {
      int x = chunkLength;
      do
        yield return source.Current;
      while (--x > 0 && source.MoveNext());
    }
  }
}

Das Ergebnis muss (7,7,3,3) sein, aber das tatsächliche Ergebnis ist (7,7,3,17).

Der beste Weg, den ich gefunden habe, ist zu zählen, indem ich ihn in eine Liste konvertiere.

IEnumerable<T> enumList = ReturnFromSomeFunction();

int count = new List<T>(enumList).Count;

Ich würde vorschlagen, ToList anzurufen. Ja, Sie führen die Aufzählung frühzeitig durch, haben jedoch weiterhin Zugriff auf Ihre Elementliste.

Möglicherweise wird nicht die beste Leistung erzielt, aber Sie können LINQ verwenden, um die Elemente in einer IEnumerable zu zählen:

public int GetEnumerableCount(IEnumerable Enumerable)
{
    return (from object Item in Enumerable
            select Item).Count();
}

Ich denke, der einfachste Weg, dies zu tun

Enumerable.Count<TSource>(IEnumerable<TSource> source)

Referenz: system.linq.enumerable

Ich benutze IEnum<string>.ToArray<string>().Lengthund es funktioniert gut.

Ich verwende solchen Code, wenn ich eine Liste von Zeichenfolgen habe:

((IList<string>)Table).Count