Comprendre la réflexion en C#

Comprendre la réflexion en C#

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous découvrirez la réflexion en C#, une fonctionnalité puissante qui vous permet d’examiner et d’utiliser les types et les objets lors de l’exécution. Commençons !

La réflexion est la capacité d’un programme à examiner et à manipuler sa propre structure lors de l’exécution. Elle est couramment utilisée pour :

• Accéder aux métadonnées sur les types, les méthodes et les propriétés.
• Appeler dynamiquement des méthodes et accéder aux champs.
• Créer des structures logicielles et des outils tels que des sérialiseurs et des outils de mappage objet-relationnel.

Point clé : La réflexion fait partie de l’espace de noms System.Reflection.

Utilisez la classe Type pour accéder aux métadonnées d’un type. Exemple :

Astuce : Utilisez GetProperties, GetMethods et GetFields pour examiner les membres d’un type.

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

Vous pouvez utiliser la réflexion pour créer dynamiquement des instances d’une classe. Exemple :

Point clé : Utilisez Activator.CreateInstance pour créer des objets lors de l’exécution.

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

La réflexion vous permet d’appeler des méthodes lors de l’exécution sans les connaître au moment de la compilation. Exemple :

Astuce : Utilisez GetMethod et Invoke pour effectuer des appels de méthodes dynamiques.

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

La réflexion peut servir à examiner les attributes personnalisés appliqués aux types, aux méthodes ou aux propriétés. Exemple :

Point clé : Utilisez GetCustomAttributes pour récupérer les informations sur les attributes.

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

Créez un programme qui utilise la réflexion pour examiner une classe, répertorier ses méthodes et ses propriétés, puis appeler dynamiquement l’une de ses méthodes. Exemple :

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

Voici quelques bonnes pratiques :

• Utilisez la réflexion avec modération, car elle peut avoir un impact sur les performances.
• Mettez en cache les résultats de la réflexion pour améliorer l’efficacité des appels répétés.
• Préférez les solutions à la compilation à la réflexion lorsque cela est possible.
• Utilisez la réflexion dans les scénarios dynamiques, comme les modules d’extension et les structures logicielles.

Astuce : Associez la réflexion à des attributes personnalisés pour créer des applications flexibles et dynamiques.

Félicitations ! Vous avez appris à utiliser la réflexion pour examiner et manipuler les types lors de l’exécution en C#. Cette leçon conclut la catégorie « Fonctionnalités avancées de C# ». Poursuivons vers de nouvelles aventures de programmation !