Foreach soll Parameter als Klasse nutzen (übergeben durch Funktion)

  • C#

Es gibt 6 Antworten in diesem Thema. Der letzte Beitrag () ist von Bluespide.

    Foreach soll Parameter als Klasse nutzen (übergeben durch Funktion)

    Lange nicht mehr gesehen! Ich bin mal wieder hier, um euch über euer professionelles Wissen zu erfragen.

    Die Frage ist einfach: Wie kann ich durch eine Funktion eine Klasse übergeben, welche ich in foreach (in der Funktion) nutzen kann? Ich weiß zwar, dass eine Klasse kein Bezeichner ist und es deshalb schwer ist sie zu übergeben, aber irgendwie müsste es eine Lösung geben, da bin ich mir sicher. In der Theorie sieht die Funktion so aus:

    C#-Quellcode

    1. private void Test(class MeineKlasse)
    2. {
    3. foreach (MeineKlasse item in items)
    4. {
    5. //blabla
    6. }
    7. }


    So einfach ist es in der Praxis aber nicht, soweit ich das verstanden habe. Wie immer, sitze ich mal wieder Stunden daran und komme zu keiner Lösung. Ich habe einen Lösungsweg angeschlagen, welcher ziemlich plausibel für mich aussieht, jedoch nicht funktioniert. Und zwar habe ich es mal so versucht:

    C#-Quellcode

    1. private void Test(string MeineKlasse)
    2. {
    3. Type type = Type.GetType(MeineKlasse);
    4. object instance = Activator.CreateInstance(type);
    5. foreach (instance item in items)
    6. {
    7. //blabla
    8. }
    9. }


    Aber das ergibt ungefähr genauso wenig Sinn, wie meine Theorie. Ich habe einfach die Klasse als String übergeben und versucht sie mit "Type" als Klasse zu identifizieren und in ein Objekt zu instanziieren, doch die Variable "instance" kann ich logischer Weise nicht als Klasse nutzen und somit auch nicht in die foreach übergeben. Ich bin ratlos, ich brauche Hilfe. Ich hoffe, meine Frage ist bei euch richtig angekommen.
    Wenn ich eine Frage stelle, habe ich sie bereits gegooglet. Ja, es kommt vor, dass ich die Antwort übersehe. Ja, es kommt vor, dass ich sie nicht verstehe. Deshalb bin ich hier. Wenn dies eure Frage war, dann antwortet bitte nicht. Es stiehlt sämtliche Motivation.
    @Sekki Wenn die Klasse eine IEnumerable-Funktion bereitstellt, die mit yield die Objekte durchiteriert.
    Ich hab mal ne Klasse gebaut, die über die Punkte einer Rectangle-Instanz iteriert.
    Vielleicht nützt Dir das als Anhaltspunkt:
    Spoiler anzeigen

    C#-Quellcode

    1. using System.Collections.Generic;
    2. using System.Drawing;
    3. namespace Helper
    4. {
    5. /// <summary>
    6. /// "Rectangle Yield", Klasse, die es gestattet, über alle
    7. /// Integer-Koordinatenpunkte eines Rectangle zu iterieren
    8. /// </summary>
    9. public sealed class RectangleY
    10. {
    11. // Rectangle ist eine Struktur, davon kann nicht abgeleitet werden
    12. private Rectangle MyRect = Rectangle.Empty;
    13. /// <summary>
    14. /// Auslesen der Fläche des Rectangles
    15. /// </summary>
    16. public int Area { get { return this.MyRect.Width * this.MyRect.Height; } }
    17. /// <summary>
    18. /// Erstellt ein RectangleY aus dem gegebenen Rectangle.
    19. /// </summary>
    20. /// <param name="rect">Das Rechteck</param>
    21. public RectangleY(Rectangle rect)
    22. {
    23. this.MyRect = rect;
    24. }
    25. /// <summary>
    26. /// Erstellt ein RectangleY mit der angegebenen Position und Größe.
    27. /// </summary>
    28. /// <param name="x">Die x-Koordinate der linken oberen Ecke des Rechtecks.</param>
    29. /// <param name="y">Die y-Koordinate der linken oberen Ecke des Rechtecks.</param>
    30. /// <param name="width">Die Breite des Rechtecks.</param>
    31. /// <param name="height">Die Höhe des Rechtecks.</param>
    32. public RectangleY(int x, int y, int width, int height)
    33. {
    34. this.MyRect = new Rectangle(x, y, width, height);
    35. }
    36. /// <summary>
    37. /// Erstellt ein RectangleY mit der angegebenen Position und Größe.
    38. /// </summary>
    39. /// <param name="location">Ein Point, der die linke obere Ecke des rechteckigen Bereichs darstellt</param>
    40. /// <param name="size">Eine Size, die die Breite und Höhe des rechteckigen Bereichs darstellt</param>
    41. public RectangleY(Point location, Size size)
    42. {
    43. this.MyRect = new Rectangle(location, size);
    44. }
    45. /// <summary>
    46. /// Erstellt ein RectangleY mit den angegebenen Randpositionen.
    47. /// </summary>
    48. /// <param name="left">Die x-Koordinate der linken oberen Ecke dieser Rectangle-Struktur.</param>
    49. /// <param name="top">Die y-Koordinate der linken oberen Ecke dieser Rectangle-Struktur</param>
    50. /// <param name="right">Die x-Koordinate der rechten unteren Ecke dieser Rectangle-Struktur.</param>
    51. /// <param name="bottom">Die y-Koordinate der rechten unteren Ecke dieser Rectangle-Struktur.</param>
    52. /// <returns></returns>
    53. public static RectangleY FromLTRB(int left, int top, int right, int bottom)
    54. {
    55. RectangleY rectY = new RectangleY(Rectangle.FromLTRB(left, top, right, bottom));
    56. return rectY;
    57. }
    58. /// <summary>
    59. /// Mit foreach über alle Koordinaten des Rectangles iterieren
    60. /// </summary>
    61. /// <returns>die aktuelle Koordinate</returns>
    62. public IEnumerable<Point> CoOrdinates()
    63. {
    64. for (int y = this.MyRect.Top; y < this.MyRect.Bottom; y++)
    65. {
    66. for (int x = this.MyRect.Left; x < this.MyRect.Right; x++)
    67. {
    68. yield return new Point(x, y);
    69. }
    70. }
    71. }
    72. }
    73. }
    Aufgerufen wird das ganze so:

    C#-Quellcode

    1. RectangleY rcy = new RectangleY(rect);
    2. foreach (Point pt in rcy.CoOrdinates())
    3. {
    4. // mit pt was tun
    5. }

    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!
    Du kannst keine „Klasse“ als Parameter übergeben. Nur Objekte, sprich Instanzen einer Klasse. Diese können auch als Liste übergeben werden. Der Code ist frei auf dem Handy aus dem Kopf geschrieben. Läuft also sicher nicht, sollte aber verdeutlichen was ich meine.

    [csharp]
    private void Test(IO.FileInfo MeineKlasse)
    {
    string s = MeineKlasse.FullName;
    }
    [\csharp]

    [csharp]
    private void Test(List(Of IO.FileInfo) lstFiles)
    {
    foreach (IO.FileInfo fi in lstFiles)
    {
    //string s = fi.FullName;
    }
    }
    [\csharp]

    aufruf
    [csharp]
    private void foo()
    {
    Test(New IO.FileInfo(„pfadzurdatei“);
    List(Of IO.FileInfo) Liste = New List(Of IO.FileInfo);
    Liste.Add( New IO.FileInfo(„pfadzurdatei“);
    Test(Liste);
    }
    [\csharp]

    Edit: Sorry kenn die C# Code Tags nicht auswendig und auf dem Handy kann man die nicht im Editor wählen.
    "Gib einem Mann einen Fisch und du ernährst ihn für einen Tag. Lehre einen Mann zu fischen und du ernährst ihn für sein Leben."

    Wie debugge ich richtig? => Debuggen, Fehler finden und beseitigen
    Wie man VisualStudio nutzt? => VisualStudio richtig nutzen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „mrMo“ ()

    @RodFromGermany

    [/cs][/spoiler]// Aufgerufen wird das ganze so:

    C#-Quellcode

    1. RectangleY rcy = new RectangleY(rect);
    2. foreach (Point pt in rcy.CoOrdinates())
    3. {
    4. // mit pt was tun
    5. }
    [/quote]

    Leider ist das nicht ganz, was ich suche. In deinem genannten Fall, wäre die Klasse die ich übergeben möchte "Point". Vielleicht mal ein anderes Beispiel:

    C#-Quellcode

    1. private void Main()
    2. {
    3. Test(MeineKlasse); //Ich übergebe die Klasse an die Funktion als Parameter
    4. }
    5. private void Test(Class class_) // "class_" ist nun "MeineKlasse"
    6. {
    7. foreach (class_ item in items) // foreach (MeineKlasse item in items)
    8. {
    9. //blabla
    10. }
    11. }


    @mrMo
    Das sieht einleuchtend aus, leuchtet mir leider dennoch nicht ein. :/
    Wenn ich eine Frage stelle, habe ich sie bereits gegooglet. Ja, es kommt vor, dass ich die Antwort übersehe. Ja, es kommt vor, dass ich sie nicht verstehe. Deshalb bin ich hier. Wenn dies eure Frage war, dann antwortet bitte nicht. Es stiehlt sämtliche Motivation.
    Was ist Dein Plan? Welches Ziel verfolgst Du konkret? Klassenanalyse? Objektanalyse? Auch wenn ich eigentlich erstmal da auf Antwort warten sollte, hier für beide Spekulatius eine Möglichkeit:

    VB.NET-Quellcode

    1. Private Sub AnalyzeClass(ClassType As Type)
    2. For Each Field In ClassType.GetFields(Reflection.BindingFlags.Public Or Reflection.BindingFlags.NonPublic Or Reflection.BindingFlags.Instance)
    3. MessageBox.Show(Field.Name)
    4. Next
    5. End Sub
    6. Private Sub AnalyzeInstance(InstanceOfClass As Foo)
    7. For Each Field In InstanceOfClass.GetType.GetFields(Reflection.BindingFlags.Public Or Reflection.BindingFlags.NonPublic Or Reflection.BindingFlags.Instance)
    8. MessageBox.Show(Field.GetValue(InstanceOfClass).ToString)
    9. Next
    10. End Sub
    11. End Class


    @mrMo: [csharp] => [cs]
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.