Find a solution

c# - क्या मेरे पास IEnumerator लौटाने की कोई विधि हो सकती है <T> और इसे एक फॉरेस्ट लूप में उपयोग करें?

original title: "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?

मुझे अपने प्रपत्र पर प्रत्येक टेक्स्टबॉक्स की ऊंचाई निर्धारित करने की आवश्यकता है, जिनमें से कुछ अन्य नियंत्रणों के भीतर निहित हैं। मैंने सोचा कि मैं ऐसा कुछ कर सकता हूं: निजी स्थिर IEnumerator <TextBox> FindTextBox ...

यह अनुवाद के बाद का सारांश है, अगर आपको पूरा अनुवाद देखने की आवश्यकता है, तो कृपया 'अनुवाद' आइकन पर क्लिक करें

सभी उत्तर
  • David Wengier
    Translate

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

  • Orion Edwards
    Translate

    Just to clarify

    private static IEnumerator<TextBox> FindTextBoxes(Control rootControl)

    Changes to

    private static IEnumerable<TextBox> FindTextBoxes(Control rootControl)

    That should be all :-)

  • Joseph Daigle
    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.

  • Yaakov Ellis
    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;
    }
}
  • supercat
    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.

इसी तरह की समस्याएं

हाल के मुद्दे