एक विशिष्ट प्रकार (बटन / टेक्स्टबॉक्स) के विंडोज फॉर्म के सभी बच्चे नियंत्रण कैसे प्राप्त करें?

120

मुझे एक फॉर्म पर सभी नियंत्रण प्राप्त करने की आवश्यकता है जो टाइप एक्स के हैं। मुझे पूरा यकीन है कि मैंने उस कोड को एक बार अतीत में देखा था जो कुछ इस तरह का उपयोग करता था:

dim ctrls() as Control
ctrls = Me.Controls(GetType(TextBox))

मुझे पता है कि मैं एक पुनरावर्ती फ़ंक्शन का उपयोग करके बच्चों को प्राप्त करने वाले सभी नियंत्रणों पर पुनरावृति कर सकता हूं, लेकिन क्या कुछ आसान या अधिक सरल है, शायद निम्नलिखित की तरह?

Dim Ctrls = From ctrl In Me.Controls Where ctrl.GetType Is Textbox
c#  .net  vb.net  winforms  controls 
— लुइस
स्रोत
1
संबंधित प्रश्न: stackoverflow.com/questions/253937/…
— Jyelton

जवाबों:

232

यहां आपके लिए एक और विकल्प है। मैंने एक नमूना एप्लिकेशन बनाकर इसका परीक्षण किया, मैंने तब एक GroupBox और एक GroupBox को प्रारंभिक GroupBox के अंदर रखा। नेस्टेड GroupBox के अंदर मैंने 3 TextBox नियंत्रण और एक बटन लगाया। यह वह कोड है जिसका मैंने उपयोग किया था (यहां तक ​​कि वह पुनरावृत्ति भी शामिल है जिसे आप खोज रहे थे)

public IEnumerable<Control> GetAll(Control control,Type type)
{
    var controls = control.Controls.Cast<Control>();

    return controls.SelectMany(ctrl => GetAll(ctrl,type))
                              .Concat(controls)
                              .Where(c => c.GetType() == type);
}

प्रपत्र लोड घटना में इसका परीक्षण करने के लिए मुझे प्रारंभिक GroupBox के अंदर सभी नियंत्रणों की एक गिनती चाहिए थी

private void Form1_Load(object sender, EventArgs e)
{
    var c = GetAll(this,typeof(TextBox));
    MessageBox.Show("Total Controls: " + c.Count());
}

और यह हर बार उचित गिनती लौटाता है, इसलिए मुझे लगता है कि आप जो खोज रहे हैं उसके लिए यह पूरी तरह से काम करेगा :)

— PsychoCoder
स्रोत
21
GetAll () को परिभाषित करने के लिए एक बहुत अच्छा उम्मीदवार है क्लास कंट्रोल के लिए एक विस्तार पद्धति
— माइकल बहिग
आपको लैम्बडा एक्सप्रेशन इस्तेमाल करने का तरीका पसंद आया। लैंबडा एक्सप्रेशन कहाँ से सीखें?
— आदित्य बोकाडे
"" System.Windows.Forms.Control.ControlCollection 'में' कास्ट 'के लिए कोई परिभाषा नहीं है और न ही कोई एक्सटेंशन विधि' कास्ट 'टाइप का पहला तर्क स्वीकार करते हुए' System.Windows.Forms.Control.ControlCollection 'पाया जा सकता है (हैं) आप एक निर्देशन या असेंबली रेफरेंस का उपयोग कर याद कर रहे हैं?) "मैं .NET 4.5 पर हूँ और" कंट्रोल "का कोई" कास्ट "फंक्शन / विधि / जो भी हो। मैं क्या खो रहा हूँ?
— सोलब्लाज़र
2
@soulblazer System.Linq नेमस्पेस जोड़ें।
— इवान-मार्क डेबोनो
var allCtl = GetAll (this.FindForm) (, टाइपोफ़ (टेक्स्टबॉक्स)); // यह एक Usercontrol रिटर्न कुछ भी नहीं है !!
— bh_earth0
33

C # में (चूंकि आपने इसे इस प्रकार टैग किया है) आप इस तरह एक LINQ अभिव्यक्ति का उपयोग कर सकते हैं:

List<Control> c = Controls.OfType<TextBox>().Cast<Control>().ToList();

पुनरावर्तन के लिए संपादित करें:

इस उदाहरण में, आप पहले नियंत्रणों की सूची बनाते हैं और फिर उसे आबाद करने के लिए एक विधि कहते हैं। चूंकि विधि पुनरावर्ती है, यह सूची वापस नहीं करता है, यह सिर्फ इसे अपडेट करता है।

List<Control> ControlList = new List<Control>();
private void GetAllControls(Control container)
{
    foreach (Control c in container.Controls)
    {
        GetAllControls(c);
        if (c is TextBox) ControlList.Add(c);
    }
}

ऐसा करने के लिए एक LINQ कथन में ऐसा करना संभव हो सकता है Descendantsफ़ंक्शन , हालांकि मैं इससे परिचित नहीं हूं। इस बारे में अधिक जानकारी के लिए इस पृष्ठ को देखें ।

संग्रह वापस करने के लिए 2 संपादित करें:

जैसा कि @ProfK ने सुझाव दिया, एक विधि जो केवल वांछित नियंत्रण लौटाती है वह शायद बेहतर अभ्यास है। इसका वर्णन करने के लिए मैंने कोड को इस प्रकार संशोधित किया है:

private IEnumerable<Control> GetAllTextBoxControls(Control container)
{
    List<Control> controlList = new List<Control>();
    foreach (Control c in container.Controls)
    {
        controlList.AddRange(GetAllTextBoxControls(c));
        if (c is TextBox)
            controlList.Add(c);
    }
    return controlList;
}
— JYelton
स्रोत
धन्यवाद, C # या VB मेरे लिए ठीक है। लेकिन समस्या यह है कि Controls.OfType <TExtbox> केवल वर्तमान नियंत्रण (मेरे मामले में फ़ॉर्म) के चिल्ड को लौटाता है, और मैं एक कॉल में फॉर्म "रिकर्सेंटली" (chililds, उप-चिल्ड) में सभी नियंत्रण प्राप्त करना चाहता हूं , सब-सब-चिल्ड, .....) ऐसिंग कलेक्शन में।
— लुइस
मुझे नियंत्रण के संग्रह को वापस करने के लिए GetAllControls नामक एक विधि की उम्मीद होगी, जिसे मैं ControlList को सौंपूंगा। बस बेहतर अभ्यास लगता है।
— ProfK
@ProfK मैं आपसे सहमत हूँ; तदनुसार बदलते उदाहरण।
— येल्टन
13

यह पुनरावर्ती GetAllControls () का एक बेहतर संस्करण है जो वास्तव में निजी संस्करणों पर काम करता है:

    private void Test()
    {
         List<Control> allTextboxes = GetAllControls(this);
    }
    private List<Control> GetAllControls(Control container, List<Control> list)
    {
        foreach (Control c in container.Controls)
        {
            if (c is TextBox) list.Add(c);
            if (c.Controls.Count > 0)
                list = GetAllControls(c, list);
        }

        return list;
    }
    private List<Control> GetAllControls(Control container)
    {
        return GetAllControls(container, new List<Control>());
    }
— VictorEspina
स्रोत
10

मैंने पिछले विचारों के एक समूह को एक विस्तार विधि में संयोजित किया। यहां लाभ यह है कि आपको सही ढंग से टाइप किए जाने योग्य वापस मिल जाते हैं, साथ ही उत्तराधिकार को सही तरीके से नियंत्रित किया जाता है OfType()।

public static IEnumerable<T> FindAllChildrenByType<T>(this Control control)
{
    IEnumerable<Control> controls = control.Controls.Cast<Control>();
    return controls
        .OfType<T>()
        .Concat<T>(controls.SelectMany<Control, T>(ctrl => FindAllChildrenByType<T>(ctrl)));
}
— Entiat
स्रोत
5

आप ऐसा करने के लिए एक LINQ क्वेरी का उपयोग कर सकते हैं। यह टेक्स्टबॉक्स टाइप करने वाले फॉर्म पर सब कुछ क्वेरी करेगा

var c = from controls in this.Controls.OfType<TextBox>()
              select controls;
— PsychoCoder
स्रोत
धन्यवाद, लेकिन उपचार के रूप में एक ही समस्या है, यह केवल चिडल्स को लौटाता है, लेकिन उपखण्डों को नहीं, आदि, और मैं चाहता हूं कि सभी ईन्स्टेड नियंत्रण हों। मुझे पूरा यकीन है कि मैंने देखा कि यह एक एकल विधि कॉल के साथ पॉसिबल है जो कि .NET 3.5 या 4.0 में नया है, याद रखें कि मैंने एक डेमो someehre में देखा
— लुइस
पुनरावृत्ति की कमी को अनदेखा करना, क्या var c = this.Controls.OfType<TextBox>()एक ही परिणाम नहीं देगा?
— कोडरडैनी
2
@ डेनिस: हाँ यह होगा, यह वरीयता (आमतौर पर) की बात है। मामले पर एक दिलचस्प चर्चा के लिए stackoverflow.com/questions/214500/… देखें ।
— जेल्टन
5

यह प्राचीन तकनीक हो सकती है, लेकिन यह आकर्षण की तरह काम करती है। मैंने नियंत्रण के सभी लेबलों का रंग बदलने के लिए पुनरावर्तन का उपयोग किया। यह बहुत अच्छा काम करता है।

internal static void changeControlColour(Control f, Color color)
{
    foreach (Control c in f.Controls)
    {

        // MessageBox.Show(c.GetType().ToString());
        if (c.HasChildren)
        {
            changeControlColour(c, color);
        }
        else
            if (c is Label)
            {
                Label lll = (Label)c;
                lll.ForeColor = color;
            }
    }
}
— आदित्य बोकाडे
स्रोत
4

मैं साइकोकोडर्स के उत्तर में संशोधन करना चाहूंगा: जैसा कि उपयोगकर्ता एक निश्चित प्रकार के सभी नियंत्रण प्राप्त करना चाहता है, हम निम्नलिखित तरीके से जेनेरिक का उपयोग कर सकते हैं:

    public IEnumerable<T> FindControls<T>(Control control) where T : Control
    {
        // we can't cast here because some controls in here will most likely not be <T>
        var controls = control.Controls.Cast<Control>();

        return controls.SelectMany(ctrl => FindControls<T>(ctrl))
                                  .Concat(controls)
                                  .Where(c => c.GetType() == typeof(T)).Cast<T>();
    }

इस तरह, हम फ़ंक्शन को निम्नानुसार कॉल कर सकते हैं:

private void Form1_Load(object sender, EventArgs e)
{
    var c = FindControls<TextBox>(this);
    MessageBox.Show("Total Controls: " + c.Count());
}
— एडम
स्रोत
इस पृष्ठ पर मेरी राय में यह सबसे अच्छा (और मेरे परीक्षणों के अनुसार सबसे तेज़) समाधान है। लेकिन मैं आपको सुझाव दूंगा कि आप नियंत्रण को एक सरणी में बदलें: var enumerable = control as control [] ?? controls.ToArray (); और फिर इसमें बदल जाएँ: enumerable.SelectMany (FindControls <T>)। ​​Concat (enumerable) .Where (c => c.GetType () == typeof (T))। Cast <T> ();
— रैंडल फ्लैग
क्या यह समान प्रभाव प्राप्त करने के .OfType<T>()बजाय लाइनक विधि का उपयोग करने के लिए अधिक कुशल नहीं .Where(c => c.GetType() == typeof(T)).Cast<T>();है?
— हेइंटरेटर
3

यह मत भूलो कि आपके पास कंटेनर नियंत्रणों के अलावा अन्य नियंत्रणों के भीतर एक टेक्स्टबॉक्स भी हो सकता है। तुम भी एक PictureBox के लिए एक TextBox जोड़ सकते हैं।

इसलिए आपको यह भी जांचना होगा कि क्या

someControl.HasChildren = True

किसी भी पुनरावर्ती कार्य में।

यह इस कोड का परीक्षण करने के लिए मेरे पास एक लेआउट से आया परिणाम है:

TextBox13   Parent = Panel5
TextBox12   Parent = Panel5
TextBox9   Parent = Panel2
TextBox8   Parent = Panel2
TextBox16   Parent = Panel6
TextBox15   Parent = Panel6
TextBox14   Parent = Panel6
TextBox10   Parent = Panel3
TextBox11   Parent = Panel4
TextBox7   Parent = Panel1
TextBox6   Parent = Panel1
TextBox5   Parent = Panel1
TextBox4   Parent = Form1
TextBox3   Parent = Form1
TextBox2   Parent = Form1
TextBox1   Parent = Form1
tbTest   Parent = myPicBox

एक फॉर्म पर एक बटन और एक रिच टेक्स्ट बॉक्स के साथ इसे आज़माएं ।

Option Strict On
Option Explicit On
Option Infer Off

Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim pb As New PictureBox
        pb.Name = "myPicBox"
        pb.BackColor = Color.Goldenrod
        pb.Size = New Size(100, 100)
        pb.Location = New Point(0, 0)
        Dim tb As New TextBox
        tb.Name = "tbTest"
        pb.Controls.Add(tb)
        Me.Controls.Add(pb)

        Dim textBoxList As New List(Of Control)
        textBoxList = GetAllControls(Of TextBox)(Me)

        Dim sb As New System.Text.StringBuilder
        For index As Integer = 0 To textBoxList.Count - 1
            sb.Append(textBoxList.Item(index).Name & "   Parent = " & textBoxList.Item(index).Parent.Name & System.Environment.NewLine)
        Next

        RichTextBox1.Text = sb.ToString
    End Sub

    Private Function GetAllControls(Of T)(ByVal searchWithin As Control) As List(Of Control)

        Dim returnList As New List(Of Control)

        If searchWithin.HasChildren = True Then
            For Each ctrl As Control In searchWithin.Controls
                If TypeOf ctrl Is T Then
                    returnList.Add(ctrl)
                End If
                returnList.AddRange(GetAllControls(Of T)(ctrl))
            Next
        ElseIf searchWithin.HasChildren = False Then
            For Each ctrl As Control In searchWithin.Controls
                If TypeOf ctrl Is T Then
                    returnList.Add(ctrl)
                End If
                returnList.AddRange(GetAllControls(Of T)(ctrl))
            Next
        End If
        Return returnList
    End Function

End Class
— जॉन एंथोनी ओलिवर
स्रोत
2

प्रतिबिंब का उपयोग करना:

// Return a list with all the private fields with the same type
List<T> GetAllControlsWithTypeFromControl<T>(Control parentControl)
{
    List<T> retValue = new List<T>();
    System.Reflection.FieldInfo[] fields = parentControl.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
    foreach (System.Reflection.FieldInfo field in fields)
    {
      if (field.FieldType == typeof(T))
        retValue.Add((T)field.GetValue(parentControl));
    }
}

List<TextBox> ctrls = GetAllControlsWithTypeFromControl<TextBox>(this);
— MiMenda
स्रोत
2

ControlLINQ का उपयोग करने के लिए , के अनुकूलन के रूप में यहाँ मेरी विस्तार विधि है @PsychoCoder संस्करण के :

इसके बजाय यह एक प्रकार की सूची लेता है जिससे आप GetAllजो चाहते हैं उसे प्राप्त करने के लिए कई कॉल की आवश्यकता नहीं होती है । मैं वर्तमान में इसे एक अधिभार संस्करण के रूप में उपयोग करता हूं।

public static IEnumerable<Control> GetAll(this Control control, IEnumerable<Type> filteringTypes)
{
    var ctrls = control.Controls.Cast<Control>();

    return ctrls.SelectMany(ctrl => GetAll(ctrl, filteringTypes))
                .Concat(ctrls)
                .Where(ctl => filteringTypes.Any(t => ctl.GetType() == t));
}

उपयोग:

//   The types you want to select
var typeToBeSelected = new List<Type>
{
    typeof(TextBox)
    , typeof(MaskedTextBox)
    , typeof(Button)
};

//    Only one call
var allControls = MyControlThatContainsOtherControls.GetAll(typeToBeSelected);

//    Do something with it
foreach(var ctrl in allControls)
{
    ctrl.Enabled = true;
}
— gfache
स्रोत
2

एक साफ और आसान समाधान (C #): 

static class Utilities {
    public static List<T> GetAllControls<T>(this Control container) where T : Control {
        List<T> controls = new List<T>();
        if (container.Controls.Count > 0) {
            controls.AddRange(container.Controls.OfType<T>());
            foreach (Control c in container.Controls) {
                controls.AddRange(c.GetAllControls<T>());
            }
        }

        return controls;
    }
}

सभी टेक्स्टबॉक्स प्राप्त करें:

List<TextBox> textboxes = myControl.GetAllControls<TextBox>();
— उमर
स्रोत
2

आप नीचे दिए गए कोड का उपयोग कर सकते हैं 

public static class ExtensionMethods
{
    public static IEnumerable<T> GetAll<T>(this Control control)
    {
        var controls = control.Controls.Cast<Control>();

        return controls.SelectMany(ctrl => ctrl.GetAll<T>())
                                  .Concat(controls.OfType<T>());
    }
}
— संतनु सरकार
स्रोत
2

यहाँ मेरा एक्सटेंशन तरीका है। यह बहुत कुशल है और यह आलसी है।

उपयोग:

var checkBoxes = tableLayoutPanel1.FindChildControlsOfType<CheckBox>();

foreach (var checkBox in checkBoxes)
{
    checkBox.Checked = false;
}

कोड है:

public static IEnumerable<TControl> FindChildControlsOfType<TControl>(this Control control) where TControl : Control
    {
        foreach (var childControl in control.Controls.Cast<Control>())
        {
            if (childControl.GetType() == typeof(TControl))
            {
                yield return (TControl)childControl;
            }
            else
            {
                foreach (var next in FindChildControlsOfType<TControl>(childControl))
                {
                    yield return next;
                }
            }
        }
    }
— जौन पोलवोरा
स्रोत
यह एक साफ-सुथरा संस्करण है जो आलसी है, जिसे मांग पर रखा जा सकता है।
— जौन पोलवोरा
1

यहाँ समाधान है।

https://stackoverflow.com/a/19224936/1147352

मैंने इस कोड के टुकड़े को लिखा है और केवल पैनलों का चयन किया है, आप अधिक स्विच या आईएफएस जोड़ सकते हैं। इस में

— साहसी
स्रोत
1 
public List<Control> GetAllChildControls(Control Root, Type FilterType = null)
{
    List<Control> AllChilds = new List<Control>();
    foreach (Control ctl in Root.Controls) {
        if (FilterType != null) {
            if (ctl.GetType == FilterType) {
                AllChilds.Add(ctl);
            }
        } else {
            AllChilds.Add(ctl);
        }
        if (ctl.HasChildren) {
            GetAllChildControls(ctl, FilterType);
        }
    }
    return AllChilds;
}
— शीर्ष सिस्टम
स्रोत
1 
   IEnumerable<Control> Ctrls = from Control ctrl in Me.Controls where ctrl is TextBox | ctrl is GroupBox select ctr;

लैंबडा एक्सप्रेशन

IEnumerable<Control> Ctrls = Me.Controls.Cast<Control>().Where(c => c is Button | c is GroupBox);
— मेमो अरफा
स्रोत
कृपया अपने उत्तर में और जोड़ें जो बताता है कि क्या हो रहा है और यह कैसे प्रश्न से संबंधित है।
— Fencer04
0

मैंने @PychoCoder से संशोधित किया। सभी नियंत्रण अब पाए जा सकते हैं (नेस्टेड शामिल हैं)।

public static IEnumerable<T> GetChildrens<T>(Control control)
{
  var type = typeof (T);

  var allControls = GetAllChildrens(control);

  return allControls.Where(c => c.GetType() == type).Cast<T>();
}

private static IEnumerable<Control> GetAllChildrens(Control control)
{
  var controls = control.Controls.Cast<Control>();
  return controls.SelectMany(c => GetAllChildrens(c))
    .Concat(controls);
}
— टेड
स्रोत
0

यह काम कर सकता है:

Public Function getControls(Of T)() As List(Of T)
    Dim st As New Stack(Of Control)
    Dim ctl As Control
    Dim li As New List(Of T)

    st.Push(Me)

    While st.Count > 0
        ctl = st.Pop
        For Each c In ctl.Controls
            st.Push(CType(c, Control))
            If c.GetType Is GetType(T) Then
                li.Add(CType(c, T))
            End If
        Next
    End While

    Return li
End Function

मुझे लगता है कि आप जिस सभी नियंत्रणों के बारे में बात कर रहे हैं वह फ़ंक्शन केवल WPF के लिए उपलब्ध है ।

— एलेक्स रॉइलार्ड
स्रोत
0

यहाँ एक परीक्षण किया गया और काम करने का सामान्य समाधान है:

मेरे पास बड़ी संख्या में UpDownNumeric नियंत्रण हैं, कुछ मुख्य रूप में, कुछ समूह बॉक्स में। मैं बैक-कलर को ग्रीन में बदलने के लिए केवल एक अंतिम चयनित नियंत्रण चाहता हूं, जिसके लिए मैंने इस विधि का उपयोग करते हुए पहले अन्य सभी को सफेद में सेट किया: (पोते के लिए भी विस्तार कर सकता है)

    public void setAllUpDnBackColorWhite()
    {
        //To set the numericUpDown background color of the selected control to white: 
        //and then the last selected control will change to green.

        foreach (Control cont in this.Controls)
        {
           if (cont.HasChildren)
            {
                foreach (Control contChild in cont.Controls)
                    if (contChild.GetType() == typeof(NumericUpDown))
                        contChild.BackColor = Color.White;
            }
            if (cont.GetType() == typeof(NumericUpDown))
                cont.BackColor = Color.White;
       }
    }
— samtal
स्रोत
यह काम नहीं करता है यदि बच्चे के नियंत्रण में स्वयं के बच्चे हैं।
— सोलब्लाज़र
0

आप यह कोशिश कर सकते हैं यदि आप चाहते हैं :)

    private void ClearControls(Control.ControlCollection c)
    {
        foreach (Control control in c)
        {
            if (control.HasChildren)
            {
                ClearControls(control.Controls);
            }
            else
            {
                if (control is TextBox)
                {
                    TextBox txt = (TextBox)control;
                    txt.Clear();
                }
                if (control is ComboBox)
                {
                    ComboBox cmb = (ComboBox)control;
                    if (cmb.Items.Count > 0)
                        cmb.SelectedIndex = -1;
                }

                if (control is CheckBox)
                {
                    CheckBox chk = (CheckBox)control;
                    chk.Checked = false;
                }

                if (control is RadioButton)
                {
                    RadioButton rdo = (RadioButton)control;
                    rdo.Checked = false;
                }

                if (control is ListBox)
                {
                    ListBox listBox = (ListBox)control;
                    listBox.ClearSelected();
                }
            }
        }
    }
    private void btnClear_Click(object sender, EventArgs e)
    {
        ClearControls((ControlCollection)this.Controls);
    }
— राशि
स्रोत
1
बस पोस्टिंग कोड ओपी को उनकी समस्या या आपके समाधान को समझने में मदद करने के लिए बहुत कम है। आपको अपने कोड के साथ किसी तरह का स्पष्टीकरण लगभग शामिल करना चाहिए।
— लीगेरो
फॉर्म क्लियर करने के बारे में सवाल कुछ भी नहीं कहा।
— लार्सटेक
हां, "प्रश्न" का उत्तर नहीं देता है, लेकिन यह एक अच्छा अतिरिक्त है। धन्यवाद!
0

हालांकि कई अन्य उपयोगकर्ताओं ने पर्याप्त समाधान पोस्ट किए हैं, मैं अधिक सामान्य दृष्टिकोण पोस्ट करना चाहूंगा जो अधिक उपयोगी हो सकता है।

यह काफी हद तक Jyelton की प्रतिक्रिया पर आधारित है।

public static IEnumerable<Control> AllControls(
    this Control control, 
    Func<Control, Boolean> filter = null) 
{
    if (control == null)
        throw new ArgumentNullException("control");
    if (filter == null)
        filter = (c => true);

    var list = new List<Control>();

    foreach (Control c in control.Controls) {
        list.AddRange(AllControls(c, filter));
        if (filter(c))
            list.Add(c);
    }
    return list;
}
— JamesFaix
स्रोत
0 
    public static IEnumerable<T> GetAllControls<T>(this Control control) where T : Control
    {
        foreach (Control c in control.Controls)
        {
            if (c is T)
                yield return (T)c;
            foreach (T c1 in c.GetAllControls<T>())
                yield return c1;
        }
    }
— Koray
स्रोत
0

Controlवर्ग के विस्तार के रूप में लिखे गए एडम के C # कोड के VB संस्करण की तलाश में किसी के लिए :

''' <summary>Collects child controls of the specified type or base type within the passed control.</summary>
''' <typeparam name="T">The type of child controls to include. Restricted to objects of type Control.</typeparam>
''' <param name="Parent">Required. The parent form control.</param>
''' <returns>An object of type IEnumerable(Of T) containing the control collection.</returns>
''' <remarks>This method recursively calls itself passing child controls as the parent control.</remarks>
<Extension()>
Public Function [GetControls](Of T As Control)(
    ByVal Parent As Control) As IEnumerable(Of T)

    Dim oControls As IEnumerable(Of Control) = Parent.Controls.Cast(Of Control)()
    Return oControls.SelectMany(Function(c) GetControls(Of T)(c)).Concat(oControls.Where(Function(c) c.GetType() Is GetType(T) Or c.GetType().BaseType Is GetType(T))
End Function

नोट: मैंने BaseTypeकिसी भी व्युत्पन्न कस्टम नियंत्रण के लिए मिलान जोड़ा है । आप चाहें तो इसे हटा सकते हैं या इसे एक वैकल्पिक पैरामीटर भी बना सकते हैं।

प्रयोग

Dim oButtons As IEnumerable(Of Button) = Me.GetControls(Of Button)()
— SteveCinq
स्रोत
0

विधि बनाएँ

public static IEnumerable<Control> GetControlsOfType<T>(Control control)
{
    var controls = control.Controls.Cast<Control>();
    return controls.SelectMany(ctrl => GetControlsOfType<T>(ctrl)).Concat(controls).Where(c => c is T);
}

और इसे लाइक करें

Var controls= GetControlsOfType<TextBox>(this);//You can replace this with your control
— लूसिफ़ेर
स्रोत
0

मैं VB का उपयोग कर नमकीन हूँ, इसलिए मैंने एक विस्तार विधि लिखी। यह एक नियंत्रण के सभी बच्चों और उप बच्चों को पुनः प्राप्त करता है

Imports System.Runtime.CompilerServices
Module ControlExt

<Extension()>
Public Function GetAllChildren(Of T As Control)(parentControl As Control) As IEnumerable(Of T)
    Dim controls = parentControl.Controls.Cast(Of Control)
    Return controls.SelectMany(Of Control)(Function(ctrl) _
        GetAllChildren(Of T)(ctrl)) _
        .Concat(controls) _
        .Where(Function(ctrl) ctrl.GetType() = GetType(T)) _
    .Cast(Of T)
End Function

End Module

फिर आप इसका उपयोग कर सकते हैं, जैसे कि "btnList" एक नियंत्रण है

btnList.GetAllChildren(Of HtmlInputRadioButton).FirstOrDefault(Function(rb) rb.Checked)

इस मामले में, यह चयनित रेडियो बटन का चयन करेगा।

— Iannick
स्रोत
-1

सीधे शब्दों में:

For Each ctrl In Me.Controls.OfType(Of Button)()
   ctrl.Text = "Hello World!"
Next
— Leebeedev
स्रोत
यह केवल "मी" के नियंत्रण संग्रह में नियंत्रणों को ढूंढेगा और बटन नियंत्रणों को नहीं ढूंढेगा जो कि किसी भी बच्चे के कंटेनर के भीतर हों क्योंकि पोस्टर "सभी" द्वारा लगाने की कोशिश कर रहा था।
— क्रिसपैकन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.