Zrozumienie refleksji w języku C#

Witamy w kolejnej lekcji! W tej lekcji poznają Państwo refleksję w języku C# — zaawansowaną funkcję, która umożliwia inspekcję typów i obiektów oraz interakcję z nimi w czasie wykonywania. Zaczynajmy!

Czym jest refleksja?

Refleksja to możliwość analizowania i modyfikowania przez program własnej struktury w czasie wykonywania. Jest powszechnie używana do:

• Uzyskiwania metadanych dotyczących typów, metod i właściwości.
• Dynamicznego wywoływania metod i uzyskiwania dostępu do pól.
• Tworzenia struktur i narzędzi, takich jak serializatory i systemy ORM.

Najważniejsza informacja: Refleksja jest częścią przestrzeni nazw System.Reflection.

Uzyskiwanie informacji o typie

Proszę używać klasy Type do uzyskiwania metadanych dotyczących typu. Przykład:

Wskazówka: Proszę używać metod GetProperties, GetMethods i GetFields do analizowania elementów członkowskich typu.

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);
        }
    }
}

Dynamiczne tworzenie obiektów

Refleksji można używać do dynamicznego tworzenia instancji klasy. Przykład:

Najważniejsza informacja: Proszę używać Activator.CreateInstance do tworzenia obiektów w czasie wykonywania.

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));
    }
}

Dynamiczne wywoływanie metod

Refleksja umożliwia wywoływanie metod w czasie wykonywania bez znajomości ich definicji w czasie kompilacji. Przykład:

Wskazówka: Proszę używać GetMethod i Invoke do dynamicznego wywoływania metod.

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" });
    }
}

Praca z atrybutami

Refleksji można używać do analizowania niestandardowych atrybutów zastosowanych do typów, metod lub właściwości. Przykład:

Najważniejsza informacja: Proszę używać GetCustomAttributes do pobierania informacji o atrybutach.

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);
        }
    }
}

Zadanie praktyczne

Proszę utworzyć program, który używa refleksji do przeanalizowania klasy, wyświetlenia jej metod i właściwości oraz dynamicznego wywołania jednej z jej metod. Przykład:

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);
    }
}

Najlepsze praktyki korzystania z refleksji

Oto kilka najlepszych praktyk:

• Proszę używać refleksji oszczędnie, ponieważ może ona negatywnie wpływać na wydajność.
• Proszę buforować wyniki refleksji, aby zwiększyć wydajność powtarzanych wywołań.
• Jeśli to możliwe, proszę wybierać rozwiązania działające w czasie kompilacji zamiast refleksji.
• Proszę używać refleksji w scenariuszach dynamicznych, takich jak wtyczki i struktury programistyczne.

Wskazówka: Proszę łączyć refleksję z niestandardowymi atrybutami w celu tworzenia elastycznych i dynamicznych aplikacji.

Świetna robota!

Gratulacje! Nauczyli się Państwo używać refleksji do analizowania i modyfikowania typów w czasie wykonywania w języku C#. To kończy kategorię "Zaawansowane funkcje języka C#". Proszę przejść dalej i odkrywać kolejne zagadnienia programistyczne!