IEnumerable <T> öğelerini yinelemeden saymak ister misiniz?

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

Diyelim ki bunlar üzerinde yineleme istiyorum ve #n # # işleme gibi bir şey yazıyorum.

Ana yinelememden önce yinelemeden m'nin değerini öğrenmenin bir yolu var mı?

Umarım kendimi açıklığa kavuşturmuşumdur.

IEnumerablebunu desteklemiyor. Bu tasarım gereğidir. IEnumerableİstediğiniz öğeleri ihtiyaç duymadan hemen önce almak için tembel değerlendirme kullanır.

Kullanabileceğiniz öğelerin sayısını yinelemeden bilmek istiyorsanız ICollection<T>, bir Countözelliği vardır.

Üzerindeki System.Linq.Enumerable.Countuzantı yöntemi IEnumerable<T>aşağıdaki uygulamaya sahiptir:

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;

Bu nedenle ICollection<T>, bir Countözelliğe sahip olan yayın yapmaya çalışır ve mümkünse bunu kullanır. Aksi takdirde yinelenir.

Bu yüzden en iyi seçeneğiniz, nesnenizdeki Count()uzantı yöntemini kullanmaktır IEnumerable<T>, çünkü bu şekilde mümkün olan en iyi performansı elde edersiniz.

Ekstra bilgi eklemek yeterlidir:

Count()Uzatma hep yineleme etmez. Sayının veritabanına gittiği Linq to Sql'yi düşünün, ancak tüm satırları geri getirmek yerine Sql Count()komutunu verir ve bunun yerine bu sonucu döndürür.

Ayrıca, derleyici (veya çalışma zamanı), Count()eğer varsa , nesne yöntemini çağıracak kadar akıllıdır . Yani bu kadar değil diğer müdahale tamamen cahil olmak ve her zaman elemanlarını saymak amacıyla yineleme, dedikleri gibi.

Programlayıcının sadece uzatma yöntemini if( enumerable.Count != 0 )kullanarak kontrol ettiği birçok durumda Any(), çünkü if( enumerable.Any() ) linq'in tembel değerlendirmesinde çok daha etkilidir, çünkü herhangi bir eleman olduğunu belirleyebildiğinden kısa devre yapabilir. Ayrıca daha okunabilir

Bir arkadaşımın bunu neden yapamayacağınıza dair bir örnek sağlayan bir dizi blog yazısı var. Her yinelemenin bir sonraki asal sayıyı sonuna kadar döndürdüğü ulong.MaxValueve bir sonraki öğe siz sorana kadar hesaplanmadığı bir IEnumerable döndüren işlev oluşturur . Hızlı, pop soru: kaç öğe iade edildi?

İşte gönderiler, ama biraz uzun:

1. Beyond Loops (diğer yazılarda kullanılan bir ilk EnumerableUtility sınıfı sağlar)
2. İterat Uygulamaları (İlk uygulama)
3. Çılgın Uzantı Yöntemleri: ToLazyList (Performans optimizasyonları)

IEnumerable yinelemeden sayamaz.

"Normal" koşullar altında, Liste <T> gibi IEnumerable veya IEnumerable <T> uygulayan sınıfların List <T> .Count özelliğini döndürerek Count yöntemini uygulaması mümkün olabilir. Ancak, Count yöntemi aslında IEnumerable <T> veya IEnumerable arabiriminde tanımlanan bir yöntem değildir. (Aslında tek olan GetEnumerator'tur.) Ve bu, sınıfa özgü bir uygulamanın sağlanamayacağı anlamına gelir.

Aksine, Say say statik sınıfında tanımlanan bir uzantı yöntemidir. Bu, söz konusu sınıfın uygulamasından bağımsız olarak IEnumerable <T> türetilmiş sınıfın herhangi bir örneğinde çağrılabileceği anlamına gelir. Ancak aynı zamanda, bu sınıfların herhangi birinin dışında tek bir yerde uygulandığı anlamına gelir. Tabii ki bu, bu sınıfın içlerinden tamamen bağımsız bir şekilde uygulanması gerektiği anlamına gelir. Saymayı yapmanın tek yolu yinelemedir.

Alternatif olarak aşağıdakileri yapabilirsiniz:

Tables.ToList<string>().Count;

Hayır, genel olarak değil. Numaralandırılabilirleri kullanmanın bir noktası, numaralandırmadaki gerçek nesne kümesinin bilinmemesidir (önceden veya hatta hiç).

System.Linq kullanabilirsiniz.

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

'2' sonucunu alırsınız.

Anlık sorunuzun ötesine geçerek (negatif olarak iyice cevaplanmıştır), bir numaralandırılabilir işlemi gerçekleştirirken ilerlemeyi rapor etmek istiyorsanız, blog yayınım Linq Sorguları Sırasında Raporlama İlerlemesi'ne bakmak isteyebilirsiniz .

Bunu yapmanıza izin verir:

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

IEnumberableİçeriğe aktarılan içeriği kontrol etmek için bir yöntem içinde böyle kullandım

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

}

Böyle bir yöntem içinde:

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

}

.Net'in hangi sürümüne ve IEnumerable nesnenizin uygulanmasına bağlıdır. Microsoft, uygulamayı denetlemek için IEnumerable.Count yöntemini düzeltti ve ICollection.Count veya ICollection <TSource> .Count kullanıyor, ayrıntılara buradan bakın https://connect.microsoft.com/VisualStudio/feedback/details/454130

Ve System.Linq'in bulunduğu Ildasm for System.Core'dan MSIL aşağıdadır.

.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

İşte tembel değerlendirme ve ertelenmiş icra hakkında harika bir tartışma . Temel olarak, bu değeri elde etmek için listeyi gerçekleştirmeniz gerekir.

IEnumerable.Count () işlevinin sonucu yanlış olabilir. Bu test etmek için çok basit bir örnektir:

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

Sonuç (7,7,3,3) olmalı ancak gerçek sonuç (7,7,3,17)

Bulduğum en iyi yol, listeye dönüştürerek saymak.

IEnumerable<T> enumList = ReturnFromSomeFunction();

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

ToList'i aramanızı öneririm. Evet, numaralandırmayı erkenden yapıyorsunuz, ancak yine de öğe listenize erişebiliyorsunuz.

En iyi performansı vermeyebilir, ancak bir IEnumerable'daki öğeleri saymak için LINQ kullanabilirsiniz:

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

Bence bunu yapmanın en kolay yolu

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

Referans: system.linq.enumerable

Ben kullanıyorum IEnum<string>.ToArray<string>().Lengthve iyi çalışıyor.

Dizeleri listesi varsa, böyle bir kod kullanın:

((IList<string>)Table).Count