Compter les éléments d'un IEnumerable <T> sans itérer?

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

Disons que je veux les itérer et écrire quelque chose comme le traitement #n de #m.

Existe-t-il un moyen de connaître la valeur de m sans itérer avant mon itération principale?

J'espère que je me suis bien fait comprendre.

IEnumerablene prend pas en charge cela. C'est par conception. IEnumerableutilise une évaluation paresseuse pour obtenir les éléments que vous demandez juste avant d'en avoir besoin.

Si vous voulez connaître le nombre d'éléments sans les répéter, vous pouvez les utiliser ICollection<T>, il a une Countpropriété.

La System.Linq.Enumerable.Countméthode d'extension on IEnumerable<T>a l'implémentation suivante:

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;

Il essaie donc de convertir en ICollection<T>, qui a une Countpropriété, et l'utilise si possible. Sinon, il itère.

Donc, votre meilleur pari est d'utiliser la Count()méthode d'extension sur votre IEnumerable<T>objet, car vous obtiendrez ainsi les meilleures performances possibles.

Il suffit d'ajouter quelques informations supplémentaires:

L' Count()extension n'itère pas toujours. Considérez Linq à Sql, où le nombre va à la base de données, mais au lieu de ramener toutes les lignes, il émet la Count()commande Sql et renvoie ce résultat à la place.

De plus, le compilateur (ou runtime) est suffisamment intelligent pour appeler la Count()méthode objets s'il en a une. Ce n'est donc pas comme d'autres intervenants le disent, étant complètement ignorant et itérant toujours pour compter les éléments.

Dans de nombreux cas où le programmeur vérifie simplement if( enumerable.Count != 0 )à l'aide de la Any()méthode d'extension, comme if( enumerable.Any() ) c'est beaucoup plus efficace avec l'évaluation paresseuse de linq car il peut court-circuiter une fois qu'il peut déterminer qu'il y a des éléments. C'est aussi plus lisible

Un de mes amis a une série de billets de blog qui illustrent pourquoi vous ne pouvez pas faire cela. Il crée une fonction qui retourne un IEnumerable où chaque itération retourne le nombre premier suivant, jusqu'à ulong.MaxValue, et l'élément suivant n'est pas calculé jusqu'à ce que vous le demandiez. Question rapide et pop: combien d'articles sont retournés?

Voici les articles, mais ils sont assez longs:

1. Beyond Loops (fournit une première classe EnumerableUtility utilisée dans les autres articles)
2. Applications d'itération (mise en œuvre initiale)
3. Méthodes d'extension folles: ToLazyList (optimisations des performances)

IEnumerable ne peut pas compter sans itérer.

Dans des circonstances "normales", il serait possible pour les classes implémentant IEnumerable ou IEnumerable <T>, telles que List <T>, d'implémenter la méthode Count en renvoyant la propriété List <T> .Count. Toutefois, la méthode Count n'est pas réellement une méthode définie sur l'interface IEnumerable <T> ou IEnumerable. (Le seul qui est, en fait, est GetEnumerator.) Et cela signifie qu'une implémentation spécifique à la classe ne peut pas être fournie pour cela.

Au contraire, Count c'est une méthode d'extension, définie sur la classe statique Enumerable. Cela signifie qu'il peut être appelé sur n'importe quelle instance d'une classe dérivée IEnumerable <T>, quelle que soit l'implémentation de cette classe. Mais cela signifie également qu'il est implémenté en un seul endroit, externe à l'une de ces classes. Ce qui bien sûr signifie qu'il doit être implémenté d'une manière complètement indépendante des internes de ces classes. La seule façon de faire le comptage est via l'itération.

Vous pouvez également effectuer les opérations suivantes:

Tables.ToList<string>().Count;

Non, pas en général. Un point dans l'utilisation des énumérables est que l'ensemble réel d'objets dans l'énumération n'est pas connu (à l'avance, ou même pas du tout).

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

Vous obtiendrez le résultat «2».

Au-delà de votre question immédiate (à laquelle une réponse négative complète a été donnée), si vous cherchez à signaler les progrès tout en traitant un énumérable, vous voudrez peut-être consulter mon article de blog Rapporter les progrès pendant les requêtes Linq .

Il vous permet de faire ceci:

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

J'ai utilisé cette méthode à l'intérieur d'une méthode pour vérifier le IEnumberablecontenu transmis

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

}

À l'intérieur d'une méthode comme celle-ci:

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

}

Cela dépend de la version de .Net et de l'implémentation de votre objet IEnumerable. Microsoft a corrigé la méthode IEnumerable.Count pour vérifier l'implémentation et utilise ICollection.Count ou ICollection <TSource> .Count, voir les détails ici https://connect.microsoft.com/VisualStudio/feedback/details/454130

Et ci-dessous se trouve le MSIL d'Ildasm pour System.Core, dans lequel réside 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

Voici une excellente discussion sur l' évaluation paresseuse et l' exécution différée . Fondamentalement, vous devez matérialiser la liste pour obtenir cette valeur.

Le résultat de la fonction IEnumerable.Count () peut être incorrect. Voici un échantillon très simple à tester:

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

Le résultat doit être (7,7,3,3) mais le résultat réel est (7,7,3,17)

La meilleure façon que j'ai trouvée est de compter en la convertissant en liste.

IEnumerable<T> enumList = ReturnFromSomeFunction();

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

Je suggère d'appeler ToList. Oui, vous faites l'énumération tôt, mais vous avez toujours accès à votre liste d'articles.

Il ne peut pas donner les meilleures performances, mais vous pouvez utiliser LINQ pour compter les éléments dans un IEnumerable:

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

Je pense que la façon la plus simple de le faire

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

Référence: system.linq.enumerable

J'utilise IEnum<string>.ToArray<string>().Lengthet ça marche bien.

J'utilise un tel code, si j'ai une liste de chaînes:

((IList<string>)Table).Count