C# – Réflexivité

Ceci est un exemple implémentant un exemple de réflexivité en C#. Vous pourrez comparer par vous-mêmes avec des programmes équivalents dans les langages que vous connaissez.

Nous présenterons cet exemple à l'aide de quelques méthodes explicatives très simples.

La première, AfficherType(), reçoit une référence sur une instance d'un type T quelconque (T dérivant d'object), en obtient le type (sous forme OO, représenté par une référence sur une instance du type Type) et en affiche le nom (sous la forme décrite par le Framework de .NET, qui peut être différente de celle du langage C# en tant que telle).

using System;
using System.Reflection;

namespace Réflexivité
{
   class Program
   {
      static void AfficherType<T>(T obj)
      {
         Type type = obj.GetType();
         Console.WriteLine("Type de {0}: {1}", obj, type);
      }

D'autres méthodes semblables sont proposées :

  • la méthode AfficherConstructeurs(), qui liste les constructeurs d'un type T donné;
  • la méthode AfficherMéthodes(), qui liste les méthodes d'un type T donné; et
  • une méthode nommée InvoquerDernierConstructeur(), qui instancie un objet du même type qu'un autre objet (reçu en paramètre) en invoquant l'un de ses constructeurs, identifié dynamiquement. Dans le programme principal, plus bas, je prendrai volontairement le dernier constructeur de System.String pour que le code soit simple; ce constructeur reçoit en paramètre un char, disons c, et un entier, disons n, puis crée une instance de string contenant n occurrences de c.

L'intention ici est de donner un aperçu de ce qu'il est possible de faire, pas de faire un inventaire exhaustif des mécanismes de réflexivité de .NET.

      static void AfficherConstructeurs<T>(T obj)
      {
         Type type = obj.GetType();
         ConstructorInfo[] ctorInf = type.GetConstructors();
         foreach (ConstructorInfo ci in ctorInf)
            Console.WriteLine("{0} a comme constructeur {1}", type, ci);
      }
      static void AfficherMéthodes<T>(T obj)
      {
         Type type = obj.GetType();
         MethodInfo[] methInf = type.GetMethods();
         foreach (MethodInfo mi in methInf)
            Console.WriteLine("{0} a comme méthode {1}", type, mi);
      }
      static T InvoquerDernierConstructeur<T>(T obj, object[] paramètres)
      {
         int nCtors = obj.GetType().GetConstructors().Length;
         return (T)obj.GetType().GetConstructors()[nCtors - 1].Invoke(paramètres);
      }

Le programme principal donne quelques exemples d'invocation de ces méthodes pour des objets arbitraires. Si vous l'essayez, vous constaterez que 3.14159f, qui est un float (donc un struct, plus précisément un System.Single du Framework) n'a pas de constructeurs... et vous constaterez que System.String expose beaucoup de méthodes!

      static void Main(string[] args)
      {
         AfficherType(3.14159f);
         AfficherConstructeurs(3.14159f);
         AfficherType("J'aime mon prof");
         AfficherConstructeurs("J'aime mon prof");
         AfficherMéthodes("J'aime mon prof");
         Console.WriteLine("{0}",
            InvoquerDernierConstructeur
               ("J'aime mon prof", new object[] { 'Z', 3 }));
      }
   }
}

Lectures complémentaires

Quelques liens supplémentaires pour enrichir le propos.


Valid XHTML 1.0 Transitional

CSS Valide !