Guide de Reflection en C# pour les débutants

Bonjour là-bas, futur superstar du codage ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde de la Reflection en C#. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - je serai votre guide amical, et nous explorerons ce sujet ensemble, pas à pas. À la fin de ce tutoriel, vous aurez une compréhension solide de ce qu'est la Reflection et comment l'utiliser. Alors, plongeons dedans !

C# - Reflection

Qu'est-ce que la Reflection ?

Imaginez que vous êtes dans un restaurant chic, et on vous tend une carte. Mais ce n'est pas n'importe quelle carte - c'est magique ! Non seulement vous pouvez voir les plats, mais vous pouvez aussi jeter un coup d'œil dans la cuisine pour voir comment ils sont faits, quels ingrédients sont utilisés, et même modifier la recette sur le vif. C'est essentiellement ce que fait la Reflection en C#, mais avec du code au lieu de la nourriture.

En termes techniques, la Reflection est une fonctionnalité en C# qui permet à un programme d'inspecter, d'interagir avec et de modifier sa propre structure et comportement à l'exécution. C'est comme donner à votre programme un miroir pour qu'il se regarde !

Applications de la Reflection

Vous vous demandez peut-être : "Pourquoi voudrais-je que mon programme se regarde lui-même ?" Excellent pregunta ! Explorons quelques applications pratiques de la Reflection :

Chargement dynamique des assemblages : La Reflection permet de charger et d'utiliser des assemblages (pensez à cela comme des paquets de code) qui n'étaient pas nécessairement connus lorsque vous avez écrit votre programme.
Création d'instances de types : Vous pouvez créer des objets d'un certain type sans connaître exactement le type au moment de la compilation.
Appel de méthodes : La Reflection vous permet d'appeler des méthodes sur des objets dynamiquement.
Accès et modification des champs et propriétés : Vous pouvez lire et écrire dans les champs et propriétés d'un objet.
Inspection des attributs : Vous pouvez examiner les attributs (informations supplémentaires) attachés à divers éléments du programme.

Voyons cela en détail avec quelques exemples de code !

Exemple 1 : Création d'une instance dynamiquement

using System;
using System.Reflection;

class Program
{
static void Main()
{
// Obtenez le type de la classe string
Type stringType = typeof(string);

// Créez une instance de string en utilisant la Reflection
object str = Activator.CreateInstance(stringType, new object[] { "Bonjour, Reflection !" });

Console.WriteLine(str); // Output : Bonjour, Reflection !
}
}

Dans cet exemple, nous utilisons la Reflection pour créer une instance de la classe string. C'est comme dire à C#, "Je veux créer quelque chose, mais je vous dirai ce que c'est à l'exécution." Cela est particulièrement utile lorsque vous ne connaissez pas le type exact que vous devez créer jusqu'à ce que votre programme soit en cours d'exécution.

Exemple 2 : Appel d'une méthode dynamiquement

using System;
using System.Reflection;

class MyClass
{
public void SayHello(string name)
{
Console.WriteLine($"Bonjour, {name} !");
}
}

class Program
{
static void Main()
{
// Créez une instance de MyClass
MyClass obj = new MyClass();

// Obtenez le type de MyClass
Type type = obj.GetType();

// Obtenez les informations de la méthode SayHello
MethodInfo methodInfo = type.GetMethod("SayHello");

// Appelez la méthode
methodInfo.Invoke(obj, new object[] { "Reflection" });
// Output : Bonjour, Reflection !
}
}

Ici, nous utilisons la Reflection pour appeler la méthode SayHello sur notre objet MyClass. C'est comme dire à C#, "Je sais que cet objet a une méthode appelée 'SayHello', veuillez l'appeler pour moi." Cela est super pratique lorsque vous devez appeler des méthodes sur des objets dont vous ne connaissez pas le type au moment de la compilation.

Visualisation des métadonnées

Une des choses les plus impressionnantes à propos de la Reflection est qu'elle nous permet de jeter un coup d'œil sous le capot de notre code. Nous pouvons voir des métadonnées sur les types, les méthodes, les propriétés, et plus encore. Jetons un coup d'œil !

Exemple 3 : Visualisation des métadonnées de type

using System;
using System.Reflection;

class Program
{
static void Main()
{
Type stringType = typeof(string);

Console.WriteLine($"Nom du type : {stringType.Name}");
Console.WriteLine($"Nom complet : {stringType.FullName}");
Console.WriteLine($"Espace de noms : {stringType.Namespace}");
Console.WriteLine($"Est-ce une classe ? {stringType.IsClass}");
Console.WriteLine($"Type de base : {stringType.BaseType}");

Console.WriteLine("\nMéthodes :");
foreach (MethodInfo method in stringType.GetMethods())
{
Console.WriteLine(method.Name);
}
}
}

Ce code est comme demander à la classe string de nous dire tout sur elle-même. Nous découvrons son nom, l'espace de noms dans lequel elle vit, si elle est une classe (spoiler : elle l'est !), ce qu'elle hérite, et même lister toutes ses méthodes. C'est comme avoir une conversation avec votre code !

Un exemple complet

Mettons tout cela ensemble avec un exemple plus complexe qui présente divers aspects de la Reflection :

using System;
using System.Reflection;

public class Person
{
public string Name { get; set; }
public int Age { get; set; }

public Person(string name, int age)
{
Name = name;
Age = age;
}

public void Introduce()
{
Console.WriteLine($"Salut, je suis {Name} et j'ai {Age} ans.");
}
}

class Program
{
static void Main()
{
// Créez un objet Person en utilisant la Reflection
Type personType = typeof(Person);
object[] constructorArgs = { "Alice", 30 };
Person person = (Person)Activator.CreateInstance(personType, constructorArgs);

// Obtenez et modifiez les valeurs des propriétés en utilisant la Reflection
PropertyInfo nameProperty = personType.GetProperty("Name");
PropertyInfo ageProperty = personType.GetProperty("Age");

Console.WriteLine($"Nom actuel : {nameProperty.GetValue(person)}");
nameProperty.SetValue(person, "Bob");
ageProperty.SetValue(person, 25);

// Appelez une méthode en utilisant la Reflection
MethodInfo introduceMethod = personType.GetMethod("Introduce");
introduceMethod.Invoke(person, null);

// Affichez toutes les méthodes de la classe Person
Console.WriteLine("\nMéthodes de la classe Person :");
foreach (MethodInfo method in personType.GetMethods())
{
Console.WriteLine(method.Name);
}
}
}

Cet exemple montre la création d'un objet, l'obtention et la modification des valeurs des propriétés, l'appel d'une méthode, et la liste de toutes les méthodes d'une classe, tout en utilisant la Reflection. C'est comme être des marionnettistes, contrôlant notre objet Person entièrement par la Reflection !

Table des méthodes de Reflection

Voici un tableau pratique des méthodes courantes de Reflection :

Méthode	Description
`Type.GetType()`	Obtient le Type avec le nom spécifié
`Object.GetType()`	Obtient le Type de l'instance actuelle
`Type.GetMethods()`	Retourne toutes les méthodes publiques du Type actuel
`Type.GetProperties()`	Retourne toutes les propriétés publiques du Type actuel
`Type.GetFields()`	Retourne tous les champs publiques du Type actuel
`Type.GetConstructors()`	Retourne tous les constructeurs publiques du Type actuel
`Activator.CreateInstance()`	Crée une instance d'un type
`MethodInfo.Invoke()`	Appelle une méthode
`PropertyInfo.GetValue()`	Obtient la valeur d'une propriété
`PropertyInfo.SetValue()`	Définit la valeur d'une propriété

Conclusion

Whaou ! Nous avons couvert beaucoup de terrain aujourd'hui. La Reflection peut sembler un peu déroutante au départ, mais c'est un outil incroyablement puissant dans votre boîte à outils C#. Il permet à vos programmes d'être plus flexibles et dynamiques, s'adaptant aux conditions à l'exécution.

Souvenez-vous, avec grand pouvoir vient grande responsabilité. La Reflection peut être plus lente que du code direct et peut potentiellement briser la sécurité des types si elle n'est pas utilisée avec précaution. Mais utilisée avec discernement, elle peut résoudre des problèmes difficiles ou impossibles à traiter autrement.

Continuez à pratiquer, continuez à explorer, et avant de savoir dire, vous serez un pro de la Reflection ! Bon codage, futur maître C# !

Credits: Image by storyset