|
Nous présenterons cet exemple (https://dotnetfiddle.net/wVR5zA) à 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;
// le programme principal (plus bas) va ici!
static void AfficherType<T>(T obj)
{
Type type = obj.GetType();
Console.WriteLine($"Type de {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($"{type} a comme constructeur {ci}");
}
static void AfficherMéthodes<T>(T obj)
{
Type type = obj.GetType();
MethodInfo[] methInf = type.GetMethods();
foreach (MethodInfo mi in methInf)
Console.WriteLine($"{type} a comme méthode {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!
|
// programme principal (va tout en haut!)
AfficherType(3.14159f);
AfficherConstructeurs(3.14159f);
AfficherType("J'aime mon prof");
AfficherConstructeurs("J'aime mon prof");
AfficherMéthodes("J'aime mon prof");
Console.WriteLine(InvoquerDernierConstructeur
(
"J'aime mon prof", new object[] { 'Z', 3 }
));
|
