Hitung item dari IEnumerable <T> tanpa iterasi?

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

Katakanlah saya ingin mengulanginya dan menulis sesuatu seperti memproses #n dari #m.

Apakah ada cara saya bisa mengetahui nilai m tanpa iterasi sebelum iterasi utama saya?

Saya harap saya membuat diri saya jelas.

IEnumerabletidak mendukung ini. Ini dengan desain. IEnumerablemenggunakan evaluasi malas untuk mendapatkan elemen yang Anda minta tepat sebelum Anda membutuhkannya.

Jika Anda ingin mengetahui jumlah item tanpa mengulanginya, Anda dapat menggunakannya ICollection<T>, ia memiliki Countproperti.

The System.Linq.Enumerable.Countmetode penyuluhan IEnumerable<T>memiliki pelaksanaan berikut:

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;

Jadi ia mencoba untuk menggunakan ICollection<T>, yang memiliki Countproperti, dan menggunakannya jika memungkinkan. Kalau tidak, iterates.

Jadi taruhan terbaik Anda adalah menggunakan Count()metode ekstensi pada IEnumerable<T>objek Anda , karena Anda akan mendapatkan kinerja terbaik dengan cara itu.

Cukup tambahkan beberapa info tambahan:

The Count()ekstensi tidak selalu iterate. Pertimbangkan Linq ke Sql, tempat penghitungan menuju database, tetapi alih-alih mengembalikan semua baris, ia mengeluarkan Count()perintah Sql dan mengembalikan hasilnya.

Selain itu, kompiler (atau runtime) cukup pintar sehingga akan memanggil Count()metode objek jika memilikinya. Jadi tidak seperti yang dikatakan responden lain, benar-benar bodoh dan selalu berulang untuk menghitung elemen.

Dalam banyak kasus di mana programmer hanya memeriksa if( enumerable.Count != 0 )menggunakan Any()metode ekstensi, karena if( enumerable.Any() ) jauh lebih efisien dengan evaluasi malas linq karena dapat mengalami hubungan pendek setelah dapat menentukan ada elemen. Ini juga lebih mudah dibaca

Seorang teman saya memiliki serangkaian posting blog yang memberikan ilustrasi mengapa Anda tidak bisa melakukan ini. Dia menciptakan fungsi yang mengembalikan IEnumerable di mana setiap iterasi mengembalikan bilangan prima berikutnya, sampai ke sana ulong.MaxValue, dan item berikutnya tidak dihitung sampai Anda memintanya. Cepat, pertanyaan pop: berapa banyak barang yang dikembalikan?

Ini postingannya, tapi agak panjang:

1. Beyond Loops (menyediakan kelas EnumerableUtility awal yang digunakan dalam posting lain)
2. Aplikasi Iterate (Implementasi awal)
3. Metode Ekstensi Gila: ToLazyList (Optimalisasi Kinerja)

IEnumerable tidak dapat dihitung tanpa iterasi.

Dalam keadaan "normal", dimungkinkan untuk kelas yang mengimplementasikan IEnumerable atau IEnumerable <T>, seperti List <T>, untuk mengimplementasikan metode Count dengan mengembalikan properti Daftar <T> .Count. Namun, metode Count sebenarnya bukan metode yang didefinisikan pada antarmuka IEnumerable <T> atau IEnumerable. (Satu-satunya yang, pada kenyataannya, adalah GetEnumerator.) Dan ini berarti bahwa implementasi khusus kelas tidak dapat disediakan untuk itu.

Sebaliknya, Hitung itu adalah metode ekstensi, didefinisikan pada kelas statis Enumerable. Ini berarti dapat dipanggil pada instance kelas turunan <n> IEnumerable, terlepas dari implementasi kelas itu. Tetapi itu juga berarti itu diterapkan di satu tempat, di luar kelas-kelas tersebut. Yang tentu saja berarti bahwa itu harus diimplementasikan dengan cara yang sepenuhnya independen dari internal kelas ini. Satu-satunya cara untuk melakukan penghitungan adalah melalui iterasi.

Atau Anda dapat melakukan hal berikut:

Tables.ToList<string>().Count;

Tidak, tidak secara umum. Satu poin dalam menggunakan enumerables adalah bahwa set sebenarnya objek dalam enumerasi tidak diketahui (sebelumnya, atau bahkan sama sekali).

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

Anda akan mendapatkan hasil '2'.

Melampaui pertanyaan langsung Anda (yang telah dijawab sepenuhnya dalam negatif), jika Anda ingin melaporkan kemajuan sambil memproses enumerable, Anda mungkin ingin melihat posting blog saya Kemajuan Pelaporan Selama Pertanyaan Linq .

Ini memungkinkan Anda melakukan ini:

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

Saya menggunakan cara seperti di dalam sebuah metode untuk memeriksa disahkan pada IEnumberablekonten

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

}

Di dalam metode seperti ini:

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

}

Tergantung pada versi .Net dan implementasi objek IEnumerable Anda. Microsoft telah memperbaiki metode IEnumerable.Count untuk memeriksa implementasi, dan menggunakan ICollection.Count atau ICollection <TSource> .Count, lihat detailnya di sini https://connect.microsoft.com/VisualStudio/feedback/details/454130

Dan di bawah ini adalah MSIL dari Ildasm untuk System.Core, di mana System.Linq berada.

.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

Berikut ini adalah diskusi yang bagus tentang evaluasi malas dan eksekusi yang ditangguhkan . Pada dasarnya Anda harus mematerialisasikan daftar untuk mendapatkan nilai itu.

Hasil dari fungsi IEnumerable.Count () mungkin salah. Ini adalah sampel yang sangat sederhana untuk diuji:

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

Hasil harus (7,7,3,3) tetapi hasil aktualnya adalah (7,7,3,17)

Cara terbaik yang saya temukan adalah menghitung dengan mengubahnya menjadi daftar.

IEnumerable<T> enumList = ReturnFromSomeFunction();

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

Saya sarankan memanggil ToList. Ya, Anda melakukan enumerasi lebih awal, tetapi Anda masih memiliki akses ke daftar item Anda.

Ini mungkin tidak menghasilkan kinerja terbaik, tetapi Anda dapat menggunakan LINQ untuk menghitung elemen dalam IEnumerable:

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

Saya pikir cara termudah untuk melakukan ini

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

Referensi: system.linq.enumerable

Saya menggunakan IEnum<string>.ToArray<string>().Lengthdan berfungsi dengan baik.

Saya menggunakan kode seperti itu, jika saya memiliki daftar string:

((IList<string>)Table).Count