L'écriture personnalisée IEnumerator<T> avec les itérateurs

Comment puis-je écrire une coutume IEnumerator<T> de mise en œuvre qui doit conserver une certaine état et toujours de commencer à utiliser un itérateur blocs de la simplifier? Le mieux que je puisse vous arriver, c'est quelque chose comme ceci:

public class MyEnumerator<T> : IEnumerator<T> {
    private IEnumerator<T> _enumerator;
    public int Position {get; private set;} //or some other custom properties

    public MyEnumerator() {
        Position = 0;
        _enumerator = MakeEnumerator();
    }

    private IEnumerator<T> MakeEnumerator() {
        //yield return something depending on Position
    } 

    public bool MoveNext() {
        bool res = _enumerator.MoveNext();
        if (res) Position++;
        return res;
    }

    //delegate Reset and Current to _enumerator as well
}

public class MyCollection<T> : IEnumerable<T> {

    IEnumerator<T> IEnumerable<T>.GetEnumerator() {
        return GetEnumerator();
    }

    public MyEnumerator<T> GetEnumerator() {
        return new MyEnumerator<T>();
    }

    ...
}

OriginalL'auteur Alexey Romanov | 2009-01-11

c#iterator

32

Pourquoi voulez-vous écrire un itérateur de classe? Le point de l'ensemble d'un bloc itérateur est de sorte que vous n'avez pas à...

c'est à dire
```
public IEnumerator<T> GetEnumerator() {
    int position = 0; //state
    while(whatever) {
        position++;
        yield return ...something...;
    }
}
```
Si vous ajoutez plus de contexte (i,e, pourquoi le ci-dessus ne peuvent pas travailler), nous pouvons probablement vous aider plus.

Mais si possible, éviter d'écrire une classe iterator. Ils sont beaucoup de travail, et il est facile de se tromper.

Par la manière, vous n'avez pas vraiment besoin de s'embêter avec Reset - c'est en grande partie obsolète, et ne devrait pas vraiment être jamais utilisée (car il ne peut pas être invoquée à travailler pour l'arbitraire d'un agent recenseur).

Si vous voulez consommer intérieure d'un itérateur, c'est très bien aussi:
```
int position = 0;
foreach(var item in source) {
   position++;
   yield return position;
}
```
ou si vous avez seulement un agent recenseur:
```
while(iter.MoveNext()) {
   position++;
   yield return iter.Current;
}
```
Vous pouvez également ajouter de l'etat (comme un n-uplet) à la chose que vous avez rendement:
```
class MyState<T> {
    public int Position {get;private set;}
    public T Current {get;private set;}
    public MyState(int position, T current) {...} //assign
}
...
yield return new MyState<Foo>(position, item);
```
Enfin, vous pouvez utiliser un style LINQ extension/délégué approche, avec un Action<int,T> pour l'approvisionnement de la position et de la valeur à l'appelant:
```
    static void Main() {
        var values = new[] { "a", "b", "c" };
        values.ForEach((pos, s) => Console.WriteLine("{0}: {1}", pos, s));            
    }
    static void ForEach<T>(
            this IEnumerable<T> source,
            Action<int, T> action) {
        if (source == null) throw new ArgumentNullException("source");
        if (action == null) throw new ArgumentNullException("action");

        int position = 0;
        foreach (T item in source) {
            action(position++, item);
        }
    }
```
Sorties:
```
0: a
1: b
2: c
```
Je suis en train de regarder le cas de l'intérieur de l'énumérateur "while(iter.MoveNext()) ... [etc]": ne sommes-nous pas des fuites de l'iter, exemple, ici ? Auto-généré extérieure agent recenseur ne sais pas, l'iter, doivent être éliminés, à droite ?
si votre bloc itérateur prend quelque chose de IDisposable, il faut alors utiliser un using de l'instruction qui sera ensuite correctement nettoyé dans la plupart des conditions normales d'utilisation,

OriginalL'auteur Marc Gravell
2

J'aurais d'accord avec Marc ici. Écrire un énumérateur de classe complètement vous-même si vous voulez vraiment (juste parce que vous pouvez?) ou tout simplement utiliser un interator bloc et le rendement des déclarations et être fait avec elle. Personnellement, je ne suis jamais toucher énumérateur classes de nouveau. 😉

Comme je l'ai dit, j'ai vraiment ne pas vous voulez 🙂

OriginalL'auteur peSHIr
1

@Marc Gravel

Mais si possible, éviter d'écrire une classe iterator. Ils sont beaucoup de travail, et il est facile de se tromper.

C'est précisément pourquoi je veux utiliser yield machines à l'intérieur de mon itérateur, pour faire le gros du travail.

Vous pouvez également ajouter de l'etat (comme un n-uplet) à la chose que vous avez rendement:

Oui, ça marche. Cependant, c'est une allocation supplémentaire à chaque étape. Si je suis intéressé seulement dans T à la plupart des étapes, c'est une surcharge je n'ai pas besoin si je peux l'éviter.

Cependant, votre dernière suggestion m'a donné une idée:
```
public IEnumerator<T> GetEnumerator(Action<T, int> action) {
    int position = 0; //state
    while(whatever) {
        position++;
        var t = ...something...;
        action(t, position);
        yield return t;
    }
}

public IEnumerator<T> GetEnumerator() {
    return GetEnumerator(DoNothing<T, int>());
}
```
Intéressant - un paresseux version de ForEach; il ne double le T, bien sûr (une fois dans le rendement, une fois dans l'action/invoke), mais intéressant.

OriginalL'auteur Alexey Romanov

J'ai fait assez simple Itérateur qui emprunte la valeur par défaut Énumérateur de faire le plus (vraiment tous) de l'œuvre. Le constructeur prend un IEnumerator<T> et ma mise en œuvre simplement les mains-il de l'œuvre. J'ai ajouté une Index domaine à mon personnalisée Itérateur.

J'ai fait un exemple simple ici: https://dotnetfiddle.net/0iGmVz

Pour utiliser cet Itérateur d'installation que vous auriez quelque chose comme ceci dans votre Collection personnalisée/List classe:

public class MyList<T> : List<T>{
    public new IEnumerator<T> GetEnumerator(){
        return new IndexedEnumerator<T>(base.GetEnumerator());
    }
}

Maintenant foreach et d'autres fonctions intégrées obtiendrez personnalisé de votre agent recenseur, et tout comportement que vous ne voulez pas remplacer normalement utilisées dans la mise en œuvre.

public static class Helpers{
    //Extension method to get the IndexEnumerator
    public static IndexedEnumerator<T> GetIndexedEnumerator<T>(this IEnumerable<T> list){
        return new IndexedEnumerator<T>(list.GetEnumerator());
    }
}

//base Enumerator methods/implementation
public class BaseEnumerator<T> : IEnumerator<T>{
    public BaseEnumerator(IEnumerator<T> enumer){
        enumerator = enumer;
    }

    protected virtual IEnumerator<T> enumerator{get;set;}

    protected virtual T current {get;set;}

    public virtual bool MoveNext(){
        return enumerator.MoveNext();
    }

    public virtual IEnumerator<T> GetEnumerator(){
        return enumerator;
    }

    public virtual T Current {get{return enumerator.Current;}}

    object IEnumerator.Current {get{return enumerator.Current;}}

    public virtual void Reset(){}

    public virtual void Dispose(){}
}

public class IndexedEnumerator<T> : BaseEnumerator<T>
{
    public IndexedEnumerator(IEnumerator<T> enumer):base(enumer){}

    public int Index {get; private set;}

    public override bool MoveNext(){
        Index++;
        return enumerator.MoveNext();
    }
}

OriginalL'auteur Chakrava

Vous devez vous connecter pour publier un commentaire.