Puis-je avoir une méthode retournant IEnumerator<T>, et l'utiliser dans une boucle foreach?

J'ai besoin de régler la hauteur de chaque zone de texte sur mon formulaire, dont certains sont imbriqués dans d'autres contrôles. Je pensais que je pouvais faire quelque chose comme ceci:

private static IEnumerator<TextBox> FindTextBoxes(Control rootControl)
{
    foreach (Control control in rootControl.Controls)
    {
        if (control.Controls.Count > 0)
        {
            //Recursively search for any TextBoxes within each child control
            foreach (TextBox textBox in FindTextBoxes(control))
            {
                yield return textBox;
            }
        }

        TextBox textBox2 = control as TextBox;
        if (textBox2 != null)
        {
            yield return textBox2;
        }
    }
}

De l'utiliser comme ceci:

foreach(TextBox textBox in FindTextBoxes(this))
{
    textBox.Height = height;
}

Mais bien sûr, le compilateur crache ses factice, parce que foreach s'attend à une IEnumerable plutôt qu'un IEnumerator.

Est-il un moyen de le faire sans avoir à créer une classe séparée avec un GetEnumerator() méthode?

En fait, foreach ne vous attendez pas à un IEnumerable à tous (ni un IEnumerable<T>). Il ne s'attend à quelque chose qui a une GetEnumerator méthode. Cette méthode, à leur tour, ne doivent pas nécessairement retourner un IEnumerator ou IEnumerator<T> — il seulement besoin de retourner quelque chose qui a une MoveNext() méthode et un Current de la propriété.

OriginalL'auteur littlecharva | 2008-08-06

  1. 13

    Que le compilateur est vous dire, vous avez besoin de changer le type de retour de IEnumerable. C'est ainsi que le taux de retour syntaxe fonctionne.

    yield return peut être utilisé avec les méthodes de retour IEnumerable<T> ou IEnumerator<T>. C'est seulement dans le foreach boucle où IEnumerator<T> ne peut pas être utilisé.

    OriginalL'auteur David Wengier

  2. 10

    Juste pour clarifier

    private static IEnumerator<TextBox> FindTextBoxes(Control rootControl)

    Changements à

    private static IEnumerable<TextBox> FindTextBoxes(Control rootControl)

    Qui convient à tous 🙂

    OriginalL'auteur Orion Edwards

  3. 3

    Si vous retournez IEnumerator, ça sera un autre objet énumérateur chaque appel de la méthode (agissant comme si vous réinitialisez l'agent recenseur à chaque itération). Si vous retournez IEnumerable puis un foreach peut énumérer basée sur la méthode avec l'instruction rendement.

    OriginalL'auteur Joseph Daigle

  4. 1
    //Generic function that gets all child controls of a certain type, 
//returned in a List collection
private static List<T> GetChildTextBoxes<T>(Control ctrl) where T : Control{
    List<T> tbs = new List<T>();
    foreach (Control c in ctrl.Controls) {
        //If c is of type T, add it to the collection
        if (c is T) { 
            tbs.Add((T)c);
        }
    }
    return tbs;
}

private static void SetChildTextBoxesHeight(Control ctrl, int height) {
    foreach (TextBox t in GetChildTextBoxes<TextBox>(ctrl)) {
        t.Height = height;
    }
}

    OriginalL'auteur Yaakov Ellis

  5. 0

    Si vous êtes donné un agent recenseur, et le besoin de l'utiliser dans une boucle for-each, vous pouvez utiliser les éléments suivants pour l'envelopper:

    statique de la classe publique enumerationHelper 
{ 
public class enumeratorHolder<T> 
{ 
privé T theEnumerator; 
T public GetEnumerator() { return theEnumerator; } 
public enumeratorHolder(T newEnumerator) { theEnumerator = newEnumerator;} 
} 
statique enumeratorHolder<T> toEnumerable<T> T theEnumerator) { return new enumeratorHolder<T>(theEnumerator); } 
privé de classe IEnumeratorHolder<T>:IEnumerable<T> 
{ 
privé IEnumerator<T> theEnumerator; 
public IEnumerator<T> GetEnumerator() { return theEnumerator; } 
Système.Les Collections.IEnumerator Système.Les Collections.IEnumerable.GetEnumerator() { return theEnumerator; } 
public IEnumeratorHolder(IEnumerator<T> newEnumerator) { theEnumerator = newEnumerator; } 
} 
statique IEnumerable<T> toEnumerable<T>(IEnumerator<T> theEnumerator) { return new IEnumeratorHolder<T>(theEnumerator); } 
}

    La toEnumerable méthode d'accepter tout ce qui c# ou vb serait un rendement acceptable type de GetEnumerator, et le retour de quelque chose qui peut être utilisé dans foreach. Si le paramètre est un IEnumerator<> la réponse sera un IEnumerable<T>, bien que l'appel de GetEnumerator une fois donnera probablement des mauvais résultats.

    OriginalL'auteur supercat