Finden aller Controls mit gemeinsamer Basisklasse in einer Form mit TabControls

    • C#

      Finden aller Controls mit gemeinsamer Basisklasse in einer Form mit TabControls

      Zum Finden oder Ansprechen aller Label in einer Form genügt ja eine Schleife über die Controls-Property des Parents:

      C#-Quellcode

      1. foreach (Label lbl in this.Controls.OfType<Label>())
      2. {
      3. lbl.Text = "bla";
      4. }

      Befindet sich auf der Form ein TabControl mit mehreren Tabs, auf denen ebenfalls alle Labels erwischt werden sollen, müssen wir mit Rekursion arbeiten.
      Ich hab da mal auf Stackoverflow eine Vorlage gefunden, kann aber leider die Quelle nicht mehr finden:
      Auflisten aller Labels auf der Form

      C#-Quellcode

      1. /// <summary>
      2. /// Auflisten aller Labels auf der Form,
      3. /// auch aus Child-Controls
      4. /// </summary>
      5. private void button1_Click(object sender, EventArgs e)
      6. {
      7. IEnumerable<Control> c = GetAllType(this, typeof(Label));
      8. // was damit tun:
      9. //MessageBox.Show("Total Controls: " + c.Count());
      10. foreach (Label lbl in c)
      11. {
      12. lbl.Text = "bla";
      13. }
      14. }
      16. /// <summary>
      17. /// alle Objekte aufsammeln, deren aktuelle Instanz vom Type type ist
      18. /// </summary>
      19. /// <param name="control">das Parent-Control</param>
      20. /// <param name="type">der Ziel-Type</param>
      21. /// <returns>Auflistung der Controls</returns>
      22. private static IEnumerable<Control> GetAllType(Control control, Type type)
      23. {
      24. // alle Controls aufsammeln
      25. IEnumerable<Control> controls = control.Controls.Cast<Control>();
      26. // aus dieser nur die Ziel-Controls zurückgeben
      27. return controls.SelectMany(ctrl => GetAllType(ctrl, type))
      28. .Concat(controls)
      29. .Where(c => c.GetType() == type);
      30. }

      Nun wollen wir gezielt unsere meigenen UserControls ansprechen.
      Das ist im wesentlichen derselbe Code, nur dass wir in der static Prozedur GetType() durch eine Extension ersetzen müssen:
      Aufsammeln aller Objekte, die vom Type type abgeleitet sind

      C#-Quellcode

      1. /// <summary>
      2. /// Auflisten aller von UserControl abgeleiteten Controls auf der Form
      3. /// </summary>
      4. private void button2_Click(object sender, EventArgs e)
      5. {
      6. IEnumerable<Control> c = GetAllClasses(this, typeof(UserControl));
      7. // was damit tun:
      8. MessageBox.Show("Total UserControls: " + c.Count());
      9. foreach (UserControl ctrl in c)
      10. {
      11. UserControl1 ctrl1 = ctrl as UserControl1;
      12. UserControl2 ctrl2 = ctrl as UserControl2;
      14. if (ctrl1 != null) { ctrl1.SetText(); }
      15. if (ctrl2 != null) { ctrl2.SetText(); }
      16. }
      17. }
      19. /// <summary>
      20. /// alle Objekte aufsammeln, die vom Type type abgeleitet sind
      21. /// </summary>
      22. /// <param name="control">das Parent-Control</param>
      23. /// <param name="cls">der Ziel-Type</param>
      24. /// <returns>Auflistung der Controls</returns>
      25. private static IEnumerable<Control> GetAllClasses(Control control, Type cls)
      26. {
      27. // alle Controls aufsammeln
      28. IEnumerable<Control> controls = control.Controls.Cast<Control>();
      29. // aus dieser nur die Ziel-Controls zurückgeben
      30. return controls.SelectMany(ctrl => GetAllClasses(ctrl, cls))
      31. .Concat(controls)
      32. .Where(c => c.TestClass(cls));
      33. }

      Als Letztes sammeln wir alle Objekte auf, die ein gemeinsames Interface implementieren.
      Der Code ist wie der letzte, nur verwenden wir eine auf Interfaces zugeschnittene Extension:
      Aufsammeln aller Objekte, die das Interface interf implementieren

      C#-Quellcode

      1. /// <summary>
      2. /// Auflisten aller das Interface Interface1 implementierenden Controls auf der Form
      3. /// </summary>
      4. private void button3_Click(object sender, EventArgs e)
      5. {
      6. IEnumerable<Control> c = GetAllInterfaces(this, typeof(Interface1));
      7. // was damit tun:
      8. MessageBox.Show("Total Interfaces: " + c.Count());
      9. foreach (Interface1 ctrl in c) // VB2019 macht dies automatisch
      10. {
      11. if (ctrl != null) { ctrl.SetTextEx(); }
      12. }
      13. }
      15. /// <summary>
      16. /// alle Objekte aufsammeln, die das Interface interf implementieren
      17. /// </summary>
      18. /// <param name="control">das Parent-Control</param>
      19. /// <param name="interf">das Ziel-Interface</param>
      20. private static IEnumerable<Control> GetAllInterfaces(Control control, Type interf)
      21. {
      22. // alle Controls aufsammeln
      23. IEnumerable<Control> controls = control.Controls.Cast<Control>();
      24. // aus dieser nur die Ziel-Controls zurückgeben
      25. return controls.SelectMany(ctrl => GetAllInterfaces(ctrl, interf))
      26. .Concat(controls)
      27. .Where(c => c.TestInterface(interf));
      28. }

      Als Abschluss noch die Extensions:
      Extensions

      C#-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      5. namespace WindowsFormsApp2
      6. {
      7. /// <summary>
      8. /// Klasse mit Extension-Methoden
      9. /// </summary>
      10. static class MyExtensions
      11. {
      12. /// <summary>
      13. /// Überladung zum Testen, ob this Object
      14. /// von der Klasse cls abgeleitet ist
      15. /// </summary>
      16. /// <param name="ob">das Object</param>
      17. /// <param name="cls">die Klasse</param>
      18. /// <returns></returns>
      19. public static bool TestClass(this object ob, Type cls)
      20. {
      21. // Basisklassen abfragen
      22. return ob.GetType().IsSubclassOf(cls);
      23. }
      25. /// <summary>
      26. /// Überladung zum Testen, ob this Object
      27. /// das Interface interf implementiert
      28. /// </summary>
      29. /// <param name="ob">das Object</param>
      30. /// <param name="interf">das Interface</param>
      31. /// <returns></returns>
      32. public static bool TestInterface(this object ob, Type interf)
      33. {
      34. // Interfaces abfragen
      35. Type obType = ob.GetType();
      36. List<Type> inter = obType.GetInterfaces().ToList();
      37. return inter.Contains(interf);
      38. }
      39. }
      40. }

      Beim Testen hat mich das Studio 2019 überrascht, dass dort eine Reihe von Casts automatisiert werden.
      Im Teil mit den Interfaces habe ich das übernommen, bei den Basisklassen nicht, dort kam dieser Vorschlag:

      Und für alle, die den Code nicht kopieren wollen, die komplette Solution:
      WindowsFormsApp2.zip
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

    Facebook
    Telefonspende