Reflection in C# verstehen

Willkommen in der nächsten Lektion! In dieser Lektion lernen Sie Reflection in C# kennen, eine leistungsfähige Funktion, mit der Sie Typen und Objekte zur Laufzeit untersuchen und mit ihnen interagieren können. Beginnen wir!

Was ist Reflection?

Reflection ist die Fähigkeit eines Programms, seine eigene Struktur zur Laufzeit zu untersuchen und zu verändern. Sie wird häufig für Folgendes verwendet:

• Auf Metadaten zu Typen, Methoden und Eigenschaften zuzugreifen.
• Methoden dynamisch aufzurufen und auf Felder zuzugreifen.
• Frameworks und Tools wie Serialisierer und ORMs zu erstellen.

Wichtiger Punkt: Reflection ist Teil des System.Reflection-Namespace.

Auf Typinformationen zugreifen

Verwenden Sie die Klasse Type, um auf Metadaten zu einem Typ zuzugreifen. Beispiel:

Tipp: Verwenden Sie GetProperties, GetMethods und GetFields, um die Typmitglieder zu untersuchen.

using System;

class SampleClass {
    public int Id { get; set; }
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);

        Console.WriteLine("Type Name: " + type.Name);
        Console.WriteLine("Properties:");
        foreach (var prop in type.GetProperties()) {
            Console.WriteLine("- " + prop.Name);
        }
    }
}

Objekte dynamisch erstellen

Sie können Reflection verwenden, um Instanzen einer Klasse dynamisch zu erstellen. Beispiel:

Wichtiger Punkt: Verwenden Sie Activator.CreateInstance, um Objekte zur Laufzeit zu erstellen.

using System;

class SampleClass {
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var property = type.GetProperty("Name");
        property.SetValue(instance, "Reflection Example");

        Console.WriteLine("Name: " + property.GetValue(instance));
    }
}

Methoden dynamisch aufrufen

Reflection ermöglicht es Ihnen, Methoden zur Laufzeit aufzurufen, ohne sie zur Kompilierzeit zu kennen. Beispiel:

Tipp: Verwenden Sie GetMethod und Invoke für dynamische Methodenaufrufe.

using System;

class SampleClass {
    public void Greet(string name) {
        Console.WriteLine("Hello, " + name);
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var method = type.GetMethod("Greet");
        method.Invoke(instance, new object[] { "World" });
    }
}

Mit Attributen arbeiten

Reflection kann verwendet werden, um benutzerdefinierte Attribute zu untersuchen, die auf Typen, Methoden oder Eigenschaften angewendet wurden. Beispiel:

Wichtiger Punkt: Verwenden Sie GetCustomAttributes, um Attributinformationen abzurufen.

using System;

[AttributeUsage(AttributeTargets.Class)]
class SampleAttribute : Attribute {
    public string Description { get; }
    public SampleAttribute(string description) {
        Description = description;
    }
}

[Sample("This is a sample class.")]
class SampleClass {}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        var attributes = type.GetCustomAttributes(typeof(SampleAttribute), false);

        foreach (SampleAttribute attr in attributes) {
            Console.WriteLine("Description: " + attr.Description);
        }
    }
}

Praxisaufgabe

Erstellen Sie ein Programm, das Reflection verwendet, um eine Klasse zu untersuchen, ihre Methoden und Eigenschaften aufzulisten und eine ihrer Methoden dynamisch aufzurufen. Beispiel:

using System;

class SampleClass {
    public int Add(int a, int b) {
        return a + b;
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        Console.WriteLine("Methods:");
        foreach (var method in type.GetMethods()) {
            Console.WriteLine("- " + method.Name);
        }

        object instance = Activator.CreateInstance(type);
        var addMethod = type.GetMethod("Add");
        int result = (int)addMethod.Invoke(instance, new object[] { 5, 3 });

        Console.WriteLine("Result of Add: " + result);
    }
}

Bewährte Vorgehensweisen für die Verwendung von Reflection

Hier sind einige bewährte Vorgehensweisen:

• Verwenden Sie Reflection sparsam, da sie die Leistung beeinträchtigen kann.
• Zwischenspeichern Sie Reflection-Ergebnisse, um die Effizienz bei wiederholten Aufrufen zu verbessern.
• Bevorzugen Sie, sofern möglich, Lösungen zur Kompilierzeit gegenüber Reflection.
• Verwenden Sie Reflection für dynamische Szenarien wie Plugins und Frameworks.

Tipp: Kombinieren Sie Reflection mit benutzerdefinierten Attributen, um flexible und dynamische Anwendungen zu erstellen.

Sehr gut!

Herzlichen Glückwunsch! Sie haben gelernt, wie Sie Reflection verwenden, um Typen zur Laufzeit in C# zu untersuchen und zu verändern. Damit ist die Kategorie "Erweiterte C#-Funktionen" abgeschlossen. Machen wir mit weiteren Programmierabenteuern weiter!