La réflexion donne à une application la possibilité de collecter des informations sur elle-même. Elle permet par exemple de parcourir une classe et d’afficher l’ensemble des méthodes qu’elle propose et même de les exécuter. La plupart des méthodes concernant la réflexion sont contenues dans les namespaces System.Reflection et System.Type. Voyons comment utiliser la réflexion en c#.

Quelques méthodes

La classe Type nous fournit quelques méthodes intéressantes:

• GetFields(): informations sur les champs d’une classe
• GetProperties() : informations sur les propriétés d’une classe
• GetMethods() : informations sur les méthodes d’une classe

Voyons un exemple concret avec la classe suivante.

    public class Employe
    {
        public string Nom { get; set; }
        public string Prenom { get; set; }

        public Employe()
        {
            Nom = "Toto";
            Prenom = "Tata";
        }

        public Employe(string nom, string prenom)
        {
            Nom = nom;
            Prenom = prenom;
        }

        public void Afficher()
        {
            Console.WriteLine($"Nom {Nom} Prenom {Prenom}");
        }
    }

Récupérons notre type.

Type empType = typeof(Employe);

Le code suivant affiche la liste des propriétés de notre classe.

var propertyInfos = empType.GetProperties();
Console.WriteLine($"Propriétés de la classe {empType.Name}");
foreach (var propertyInfo in propertyInfos)
{
    Console.WriteLine($"propriété {propertyInfo.Name}");
}

Le résultat

Propriétés de la classe Employe
propriété Nom
propriété Prenom


Affichons la liste des méthodes de notre classe.

var methodInfos = empType.GetMethods();
Console.WriteLine($"Méthodes de la classe {empType.Name}");
foreach (var methodInfo in methodInfos)
{
    Console.WriteLine($"méthode {methodInfo.Name}");
}

Il est possible de faire la même chose avec les champs(GetFields()), les évènements (GetEvents()). La classe Type fournit d’autres infos comme le nom (Name) et le Namespace de notre classe.

Instancier dynamiquement des types

L’instanciation dynamique des objets est un outil très puissant. Il permet par exemple à une fabrique de créer des objets de différents types en se basant sur leurs noms. Pour instancier des objets dynamiquement, nous utilisons la méthode CreateInstance de la classe Activator ou une instance de la classe Assembly.

Avec notre classe Employe ci-dessus, ça donnerait:

var employe = Assembly.GetExecutingAssembly().CreateInstance("ConsoleApp3.Employe");

Notre objet Employe est créé en utilisant simplement le nom de la classe.

Invoquer des membres

On peut invoquer les membres d’une classe grâce à la réflexion. Prenons notre classe Employe, on veut exécuter la méthode Afficher.

            var type = typeof(Employe);
            var methodInfo = type.GetMethod("Afficher");

            var employe = Assembly.GetExecutingAssembly().CreateInstance("ConsoleApp3.Employe",false, BindingFlags.CreateInstance,null, new object[]{"Jean","Pierre" }, null, null);
            methodInfo.Invoke(employe, null);

Le code ci-dessus crée une instance de la classe Employe et exécute sa méthode Afficher. Au lieu d’utiliser le constructeur par défaut, on utilise celui qui prend deux paramètres.

Conclusion

Cet article n’a fait que survoler ce que propose la réflexion, c’est un outil très puissant. Pour en savoir plus, vous pouvez consulter la documentation officiel de Microsoft.

Crédit photo Visual Hunt