La classe doit-elle implémenter IEnumerable pour utiliser Foreach

C'est en C#, j'ai une classe que je suis à l'aide de quelque chose de la DLL. Il ne met pas en œuvre IEnumerable mais a 2 méthodes de passer de nouveau un IEnumerator. Est-il une manière que je peux utiliser une boucle foreach sur ces. La classe que j'utilise est scellé.

source d'informationauteur Brian G

c#foreach ienumerable

15

foreach ne pas besoin IEnumerablecontrairement à la croyance populaire. Il suffit de disposer d'une méthode GetEnumerator qui retourne un objet qui a la méthode MoveNext et le bien Current avec les signatures appropriées.

/EDIT: Dans votre cas, cependant, vous êtes hors de la chance. Vous pouvez trivialement l'enveloppe de votre objet, cependant, faire énumérable:
```
class EnumerableWrapper {
    private readonly TheObjectType obj;

    public EnumerableWrapper(TheObjectType obj) {
        this.obj = obj;
    }

    public IEnumerator<YourType> GetEnumerator() {
        return obj.TheMethodReturningTheIEnumerator();
    }
}

//Called like this:

foreach (var xyz in new EnumerableWrapper(yourObj))
    …;
```
/EDIT: La méthode suivante, proposée par plusieurs personnes, qui n' pas travail si la méthode retourne une IEnumerator:
```
foreach (var yz in yourObj.MethodA())
    …;
```

Re: Si foreach ne nécessite pas d'interface explicite contrat, est-il trouver GetEnumerator l'aide de la réflexion?

(Je ne peux pas commenter car je n'ai pas une assez grande réputation.)

Si vous êtes impliquant runtime réflexion alors non. Il fait tout compile-time, une autre moins connue, c'est qu'il vérifie également si l'objet retourné que pourrait mettre en Œuvre IEnumerator est jetable.

Pour le voir en action considérer ce (runnable) extrait.


using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication3
{
    class FakeIterator
    {
        int _count;

        public FakeIterator(int count)
        {
            _count = count;
        }
        public string Current { get { return "Hello World!"; } }
        public bool MoveNext()
        {
            if(_count-- > 0)
                return true;
            return false;
        }
    }

    class FakeCollection
    {
        public FakeIterator GetEnumerator() { return new FakeIterator(3); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            foreach (string value in new FakeCollection())
                Console.WriteLine(value);
        }
    }
}

6

Selon MSDN:
```
foreach (type identifier in expression) statement
```
où l'expression est:

Objet de collection ou un tableau d'expression.
Le type de l'élément de la collection
doit être convertible à l'identifiant
type. Ne pas utiliser une expression qui
la valeur est null. Évalue à un type
implémentant IEnumerable ou un type
qui déclare une méthode GetEnumerator.
Dans ce dernier cas, GetEnumerator
de rendre un type qui
met en œuvre IEnumerator ou déclare tous
les méthodes définies dans IEnumerator.
4

Réponse courte:

Vous besoin d'une classe avec une méthode nommée GetEnumeratorqui renvoie le IEnumerator que vous avez déjà. Réaliser cela avec un simple wrapper:
```
class ForeachWrapper
{
  private IEnumerator _enumerator;

  public ForeachWrapper(Func<IEnumerator> enumerator)
  {
    _enumerator = enumerator;
  }

  public IEnumerator GetEnumerator()
  {
    return _enumerator();
  }
}
```
Utilisation:
```
foreach (var element in new ForeachWrapper(x => myClass.MyEnumerator()))
{
  ...
}
```
De la Spécification Du Langage C# :
Le moment de la compilation de traitement d'un
instruction foreach détermine d'abord la
type de collection, type d'énumérateur et
type d'élément de l'expression. Cette
détermination procède comme suit:
- Si le type X de l'expression est de type tableau, puis il est implicite
  référence conversion de X à l'
  Système.Les Collections.IEnumerable
  interface (depuis le Système.Tableau
  implémente cette interface). L'
  type de collection est la
  Système.Les Collections.IEnumerable
  l'interface, le type d'énumérateur est l'
  Système.Les Collections.IEnumerator
  l'interface et le type d'élément est l'
  type d'élément de la matrice de type X.
- Sinon, déterminer si le type de X a une
  Méthode GetEnumerator:
  
  Effectuer la recherche de membre sur le type X avec identifiant GetEnumerator et pas de
  type d'arguments. Si la recherche d'un membre
  ne produit pas un match, ou il
  produit une ambiguïté, ou qui produit une
  match qui n'est pas une méthode de groupe,
  vérifier pour une énumération interface
  décrites ci-dessous. Il est recommandé de
  un avertissement sera émis si le membre
  recherche produit rien, sauf un
  méthode de groupe ou pas de match.
  
  Effectuer la résolution de surcharge à l'aide de l'résultant de la méthode de groupe et une
  vide de la liste d'arguments. Si la surcharge
  résolution non applicable
  les méthodes, les résultats dans une ambiguïté, ou
  résultats dans une meilleure méthode, mais
  cette méthode est statique ou non
  public, vérifier une énumérable
  interface comme décrit ci-dessous. Il est
  recommandé qu'un avertissement soit publié
  si la résolution de surcharge produit
  rien, sauf une sans ambiguïté public
  méthode d'instance ou non applicable
  des méthodes.
  
  Si le type de retour de la méthode GetEnumerator n'est pas une classe,
  struct ou type d'interface, une erreur est
  produits et pas d'autres étapes sont
  prises.
  
  Membre recherche est effectuée sur E avec l'identifiant de Courant et pas de
  type d'arguments. Si la recherche d'un membre
  ne produit pas de match, le résultat est un
  erreur, ou que le résultat est tout
  à l'exception d'une instance publique de la propriété que
  permet la lecture, une erreur se produit
  et pas d'autres mesures sont prises.
  
  Membre recherche est effectuée sur E avec l'identifiant MoveNext et pas de
  type d'arguments. Si la recherche d'un membre
  ne produit pas de match, le résultat est un
  erreur, ou que le résultat est tout
  à l'exception d'une méthode de groupe, une erreur est
  produits et pas d'autres étapes sont
  prises.
  
  Résolution de surcharge est effectuée sur la méthode de groupe avec un vide
  liste d'arguments. Si la résolution de surcharge
  résultats dans les pas de méthodes applicables,
  résultats dans une ambiguïté, ou les résultats dans
  une meilleure méthode, mais la méthode
  est soit statique ou pas du public, ou de ses
  de retour n'est pas de type booléen, une erreur est
  produits et pas d'autres étapes sont
  prises.
  
  Le type de collection est X, l'agent recenseur est de type E, et l'élément
  type est le type de l'Actuel
  de la propriété.
- Sinon, vérifiez pour une énumération interface:
  
  Si il y a exactement un type de T tel qu'il est implicite
  la conversion de X à l'interface
  Système.Les Collections.Génériques.IEnumerable<T>,
  ensuite, le type de collection est-ce
  l'interface, le type d'énumérateur est l'
  interface
  Système.Les Collections.Génériques.IEnumerator<T>,
  et le type de l'élément est T.
  
  Sinon, si il n'y a plus d'un type T, alors une erreur est
  produits et pas d'autres étapes sont
  prises.
  
  Sinon, si il y a une conversion implicite de X à l'
  Système.Les Collections.IEnumerable
  l'interface, puis le type de collection est
  cette interface, l'agent recenseur est de type
  l'interface
  Système.Les Collections.IEnumerator, et
  le type d'élément est l'objet.
  
  Sinon, une erreur se produit et pas d'autres mesures sont prises.
3

Pas strictement. Tant que la classe a les GetEnumerator, MoveNext, Reset, et les membres Actuels, il travaillera avec foreach

Non, vous n'avez pas et vous n'avez même pas besoin d'une méthode GetEnumerator, par exemple:

class Counter
{
    public IEnumerable<int> Count(int max)
    {
        int i = 0;
        while (i <= max)
        {
            yield return i;
            i++;
        }
        yield break;
    }
}

qui est appelé de cette façon:

Counter cnt = new Counter();

foreach (var i in cnt.Count(6))
{
    Console.WriteLine(i);
}

Vous pouvez toujours l'envelopper, et comme un de côté pour être "foreachable" vous avez seulement besoin d'avoir une méthode appelée "GetEnumerator" avec la bonne signature.


class EnumerableAdapter
{
  ExternalSillyClass _target;

  public EnumerableAdapter(ExternalSillyClass target)
  {
    _target = target;
  }

  public IEnumerable GetEnumerator(){ return _target.SomeMethodThatGivesAnEnumerator(); }

}

0

Compte tenu de la classe X avec les méthodes A et B, que les deux de retour IEnumerable, vous pouvez utiliser un foreach sur la classe comme ceci:
```
foreach (object y in X.A())
{
    //...
}

//or

foreach (object y in X.B())
{
   //...
}
```
Sans doute le sens de la enumerables retourné par A et B sont bien définis.
0

@Brian: Pas sûr que vous essayez de faire une boucle sur la valeur de retour de l'appel de la méthode ou de la classe elle-même,
Si ce que vous voulez, c'est la classe alors en faire un tableau, vous pouvez utiliser foreach.

Pour une classe pour être utilisable avec foeach tout ce qu'il faut faire est d'avoir une méthode publique qui renvoie et IEnumerator nommé GetEnumerator(), c'est ça:

Prendre la classe suivante, il n'est pas de mettre en œuvre IEnumerable ou IEnumerator :

public class Foo
{
    private int[] _someInts = { 1, 2, 3, 4, 5, 6 };
    public IEnumerator GetEnumerator()
    {
        foreach (var item in _someInts)
        {
            yield return item;
        }
    }
}

sinon le GetEnumerator() la méthode peut être écrite:

    public IEnumerator GetEnumerator()
    {
        return _someInts.GetEnumerator();
    }

Lorsque utilisé dans un foreach ( à Noter que le pas de wrapper est utilisé, il suffit d'une instance de classe ):

    foreach (int item in new Foo())
    {
        Console.Write("{0,2}",item);
    }

imprime:

1 2 3 4 5 6

Le type de disposer d'un public/non-statique/non-générique/méthode sans paramètre nommé GetEnumerator qui doit retourner quelque chose qui a un public MoveNext méthode et un public Current de la propriété. Lorsque je me souviens de M. Eric Lippert quelque part, cela a été conçu de façon à tenir compte de la pré générique ère pour les deux type de la sécurité et de la boxe des problèmes de performances liés dans le cas de types de valeur.

Par exemple cela fonctionne:

class Test
{
    public SomethingEnumerator GetEnumerator()
    {

    }
}

class SomethingEnumerator
{
    public Something Current //could return anything
    {
        get { }
    }

    public bool MoveNext()
    {

    }
}

//now you can call
foreach (Something thing in new Test()) //type safe
{

}

C'est alors traduite par le compilateur:

var enumerator = new Test().GetEnumerator();
try {
   Something element; //pre C# 5
   while (enumerator.MoveNext()) {
      Something element; //post C# 5
      element = (Something)enumerator.Current; //the cast!
      statement;
   }
}
finally {
   IDisposable disposable = enumerator as System.IDisposable;
   if (disposable != null) disposable.Dispose();
}

De 8.8.4 section de la spécification.

Quelque chose à noter est l'agent recenseur priorité impliquée - c'est comme si vous avez un public GetEnumerator méthode, alors que c'est le choix par défaut de foreachindépendamment de ce qui est de la mettre en œuvre. Par exemple:

class Test : IEnumerable<int>
{
    public SomethingEnumerator GetEnumerator()
    {
        //this one is called
    }

    IEnumerator<int> IEnumerable<int>.GetEnumerator()
    {

    }
}

(Si vous n'avez pas un public de mise en œuvre (c'est à dire uniquement explicite de mise en œuvre), alors la priorité va comme IEnumerator<T> > IEnumerator.)

Vous devez vous connecter pour publier un commentaire.

Réponse courte:

Utilisation:

De la Spécification Du Langage C# :