Policzyć elementy z IEnumerable <T> bez iteracji?

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

Powiedzmy, że chcę je powtórzyć i napisz coś takiego jak przetwarzanie #n z #m.

Czy istnieje sposób, aby dowiedzieć się o wartości m bez iteracji przed moją główną iteracją?

Mam nadzieję, że wyraziłem się jasno.

IEnumerablenie obsługuje tego. To jest z założenia. IEnumerableużywa leniwej oceny, aby uzyskać elementy, o które prosisz tuż przed ich użyciem.

Jeśli chcesz poznać liczbę elementów bez iteracji nad nimi, możesz użyć ICollection<T>tej Countwłaściwości.

Metoda System.Linq.Enumerable.Countrozszerzenia IEnumerable<T>ma następującą implementację:

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;

Próbuje więc przesyłać do ICollection<T>, który ma Countwłaściwość, i używa go, jeśli to możliwe. W przeciwnym razie iteruje.

Więc najlepszym rozwiązaniem jest użycie Count()metody rozszerzenia na IEnumerable<T>obiekcie, ponieważ uzyskasz w ten sposób najlepszą możliwą wydajność.

Dodając dodatkowe informacje:

Count()Rozbudowa nie zawsze iteracji. Rozważ Linq do Sql, gdzie liczba trafia do bazy danych, ale zamiast przywracać wszystkie wiersze, wydaje Count()polecenie Sql i zwraca ten wynik.

Ponadto kompilator (lub środowisko wykonawcze) jest na tyle inteligentny, że wywoła Count()metodę object , jeśli ją posiada. Więc nie jest tak, jak mówią inni respondenci, będąc całkowicie ignorantem i zawsze iterując, aby policzyć elementy.

W wielu przypadkach, gdy programista sprawdza po prostu if( enumerable.Count != 0 )za pomocą Any()metody rozszerzenia, ponieważ if( enumerable.Any() ) jest to o wiele bardziej wydajne z leniwą oceną linq, ponieważ może zwierać, gdy może stwierdzić, że są jakieś elementy. Jest także bardziej czytelny

Mój przyjaciel ma serię postów na blogu, które ilustrują, dlaczego nie możesz tego zrobić. Tworzy funkcję, która zwraca IEnumerable, gdzie każda iteracja zwraca następną liczbę pierwszą, aż do ulong.MaxValue, a następny element nie jest obliczany, dopóki go nie poprosisz. Szybkie, popowe pytanie: ile przedmiotów jest zwracanych?

Oto posty, ale są one dość długie:

1. Beyond Loops (zapewnia początkową klasę EnumerableUtility używaną w innych postach)
2. Zastosowania Iterate (wstępne wdrożenie)
3. Szalone metody rozszerzenia: ToLazyList (optymalizacje wydajności)

IEnumerable nie może się liczyć bez iteracji.

W „normalnych” okolicznościach klasy implementujące IEnumerable lub IEnumerable <T>, takie jak List <T>, mogłyby zaimplementować metodę Count, zwracając właściwość List <T> .Count. Jednak metoda Count nie jest w rzeczywistości metodą zdefiniowaną w interfejsie IEnumerable <T> lub IEnumerable. (Jedynym, który w rzeczywistości jest GetEnumerator). A to oznacza, że ​​nie można zapewnić dla niego implementacji specyficznej dla klasy.

Raczej licz, to metoda rozszerzenia zdefiniowana w klasie statycznej Enumerable. Oznacza to, że można go wywołać w dowolnej instancji klasy pochodnej <T> IEnumerable, niezależnie od implementacji tej klasy. Ale oznacza to również, że jest implementowany w jednym miejscu, zewnętrznym względem którejkolwiek z tych klas. Co oczywiście oznacza, że ​​musi zostać zaimplementowany w sposób całkowicie niezależny od wewnętrznych elementów tej klasy. Jedynym takim sposobem liczenia jest iteracja.

Alternatywnie możesz wykonać następujące czynności:

Tables.ToList<string>().Count;

Nie, ogólnie nie. Jednym z punktów przy użyciu wyliczeń jest to, że rzeczywisty zestaw obiektów w wyliczeniu nie jest znany (wcześniej, a nawet wcale).

Możesz użyć System.Linq.

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

Otrzymasz wynik „2”.

Wykraczając poza twoje bezpośrednie pytanie (na które dokładnie udzielono odpowiedzi przeczącej), jeśli chcesz zgłosić postęp podczas przetwarzania wyliczenia, możesz spojrzeć na mój post na blogu Zgłaszanie postępów podczas zapytań Linq .

Pozwala ci to zrobić:

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

Kiedyś taki sposób wewnątrz metody, by sprawdzić przekazany w IEnumberabletreści

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

}

Wewnątrz metody takiej jak ta:

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

}

To zależy od wersji .Net i implementacji Twojego obiektu IEnumerable. Microsoft naprawił metodę IEnumerable.Count w celu sprawdzenia implementacji i używa ICollection.Count lub ICollection <TSource> .Count, zobacz szczegóły tutaj https://connect.microsoft.com/VisualStudio/feedback/details/454130

A poniżej znajduje się MSIL z Ildasm dla System.Core, w którym rezyduje System.Linq.

.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

Oto świetna dyskusja na temat leniwej oceny i odroczenia wykonania . Zasadniczo musisz zmaterializować listę, aby uzyskać tę wartość.

Wynik funkcji IEnumerable.Count () może być nieprawidłowy. To jest bardzo prosta próbka do przetestowania:

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

Wynik musi wynosić (7,7,3,3), ale rzeczywisty wynik to (7,7,3,17)

Najlepszym sposobem, jaki znalazłem, jest przeliczenie na listę.

IEnumerable<T> enumList = ReturnFromSomeFunction();

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

Sugerowałbym wywołanie ToList. Tak, wyliczasz wcześniej, ale nadal masz dostęp do swojej listy elementów.

Może nie dawać najlepszej wydajności, ale możesz użyć LINQ do zliczenia elementów w IEnumerable:

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

Myślę, że najłatwiej to zrobić

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

Odniesienie: system.linq.enumerable

Używam IEnum<string>.ToArray<string>().Lengthi działa dobrze.

Używam takiego kodu, jeśli mam listę ciągów:

((IList<string>)Table).Count