c# - Can I have a method returning IEnumerator<T> and use it in a foreach loop?


Translate

I need to set the height of every textbox on my form, some of which are nested within other controls. I thought I could do something like this:

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

Using it like this:

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

But of course the compiler spits its dummy, because foreach expects an IEnumerable rather than an IEnumerator.

Is there a way to do this without having to create a separate class with a GetEnumerator() method?


Alle Antworten
  • Translate

    As the compiler is telling you, you need to change your return type to IEnumerable. That is how the yield return syntax works.


  • Translate

    Just to clarify

    private static IEnumerator<TextBox> FindTextBoxes(Control rootControl)
    

    Changes to

    private static IEnumerable<TextBox> FindTextBoxes(Control rootControl)
    

    That should be all :-)


  • Translate

    If you return IEnumerator, it will be a different enumerator object each time call that method (acting as though you reset the enumerator on each iteration). If you return IEnumerable then a foreach can enumerate based on the method with the yield statement.


  • Translate
    // 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;
        }
    }
    

  • Translate

    If you are given an enumerator, and need to use it in a for-each loop, you could use the following to wrap it:

    static public class enumerationHelper
    {
        public class enumeratorHolder<T>
        {
            private T theEnumerator;
            public T GetEnumerator() { return theEnumerator; }
            public enumeratorHolder(T newEnumerator) { theEnumerator = newEnumerator;}
        }
        static enumeratorHolder<T> toEnumerable<T>(T theEnumerator) { return new enumeratorHolder<T>(theEnumerator); }
        private class IEnumeratorHolder<T>:IEnumerable<T>
        {
            private IEnumerator<T> theEnumerator;
            public IEnumerator<T> GetEnumerator() { return theEnumerator; }
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return theEnumerator; }
            public IEnumeratorHolder(IEnumerator<T> newEnumerator) { theEnumerator = newEnumerator; }
        }
        static IEnumerable<T> toEnumerable<T>(IEnumerator<T> theEnumerator) { return new IEnumeratorHolder<T>(theEnumerator); }
    }
    

    The toEnumerable method will accept anything that or would regard an acceptable return type from GetEnumerator, and return something that can be used in foreach. If the parameter is an IEnumerator<> the response will be an IEnumerable<T>, though calling GetEnumerator on it once will likely yield bad results.