.NET : Introduction à la réflexion (C#)

Date de publication : 11.02.2005

Par Olivier Brin (autres articles)
 

La réflexion permet de découvrir et d'utiliser dynamiquement des types, comme l'instanciation tardive d'objets ou l'invocation de méthodes à la volée.

I. Avertissement

II. Introduction

A. Qu'est-ce que la réflexion ?

Certaines personnes, dont moi, pensent que la traduction du terme anglais reflection en réflexion est inappropriée. En effet, le terme introspection est nettement plus adapté et correspond mieux à la réalité du mécanisme. Cela dit, la majorité des livres et documents en français, ainsi que le MSDN, utilisent le terme de réflexion. C'est pour cette raison que j'utiliserai également ce terme dans la suite de cet article.

CLR (Common Langage Runtime) : environnement d'exécution des programmes .NET.

B. Comment ca marche ?

C. Quelles sont ses applications ?

III. La réflexion avec C#

La réflexion fonctionne avec tous les langages managés (C#, VB.NET, Managed C++ ...)

A. Les types à utiliser

Type	Description
System.Reflection.Assembly	Définit un assemblage managé, comme un exécutable ou une DLL .NET. C'est à partir de ce type que seront appelées les principales méthodes de la réflexion. C'est directement depuis un objet de type Assembly que pourront être découverts et invoqués les membres.
System.Reflection.MemberInfo	Représente les informations d'un membre d'un type quelconque. Le membre peut être un champ ou une méthode, un objet de type MemberInfo définit sa signature.

B. Les méthodes à utiliser

Méthode	Description
Assembly.LoadFrom	Charge dynamiquement un assemblage dont le nom de fichier est passé en paramètre. Il s'agit d'un chargement physique, au contraire de la méthode Assembly.Load qui effectue un chargement logique avec le nom fort de l'assemblage.
Assembly.GetTypes	Renvoie un tableau de System.Type contenant tous les types définis dans l'assemblage.
Assembly.GetMembers	Renvoie un tableau de System.Reflection.MemberInfo contenant les signatures de tous les membres de chaque type de l'assemblage.
Activator.CreateInstance	Crée dynamiquement une instance du type spécifié. Principe de la liaison tardive (late binding).
Type.InvokeMember	Tente d'invoquer le membre spécifié sur le type. Il est possible de travailler avec des membres statiques ou sur une instance du type créée précédemment.

C. Chargement d'un assemblage

Un nom fort .NET est un nom d'assemblage composé. Il contient plusieurs attributs qui permettent de différencier les assemblages les uns des autres, non pas par leur nom de fichier, mais par des propriétés bien plus logiques, comme par exemple leur langage (culture) ou leur version. Il est ainsi possible d'éviter l'un des nombreux désavantage des DLLs natives qui étaient les multiples versions possibles d'une même DLL qui entraient en conflit. Cette notion du nom fort abolit une partie du tristement célèbre DLL Hell.

Chargement logique d'un assemblage
// On suppose que la directive using System.Reflection est présente plus haut

// Chargement en spécifiant la culture
Assembly monAssembly = Assembly.Load("assemblyName, Culture=fr");

// Chargement en spécifiant la version
Assembly monAssembly = Assembly.Load("assemblyName, version=1.2.3.4");

Chargement physique d'un assemblage
// On suppose que la directive using System.Reflection est présente plus haut

Assembly monAssembly = Assembly.LoadFrom("C:\assemblyName.dll");

Dans les deux cas, monAssembly pourra être utilisé de manière similaire dans la suite du programme.

• Un type caractérise le contenu et le sens d'un objet. En C, int et char sont des types de données. En .NET, on différencie les types de valeurs et les types de références. Les types de valeurs sont alloués sur une pile (stack) alors que les types de références sont alloués sur le tas managé (managed heap). Les premiers sont accessibles plus rapidement et plus ou moins directement. Int32, Char sont des types de valeurs, alors que ArrayList ou HttpChannel sont des types références. On peut facilement connaître le type de chaque objet .NET en utilisant la méthode GetType.
• Un membre est une méthode, propriété ou champ appartenant à une classe. En .NET, toutes les classes héritent de la classe de base Object, ce qui fait qu'elles ont toutes au moins 4 membres : ToString, Equals, GetHashCode et GetType. Chaque classe contient encore un membre spécial, le constructeur .ctor.
• Invoquer un membre signifie appeler une méthode membre, lire ou écrire un champ.

D. Découverte de types

Découverte de types
// On suppose que la directive using System.Reflection est présente plus haut

Assembly monAssembly = Assembly.LoadFrom("C:\assemblyName.dll");

foreach(Type type in monAssembly.GetTypes())
{
	Console.WriteLine("Type présent dans l'assemblage : " + type.Name);
}

Type présent dans l'assemblage : MyClasseOne
Type présent dans l'assemblage : MyClasseTwo

A la place de la propriété Name qui rend le nom simple du type, on peut utiliser la méthode ToString qui renvoit elle le nom complet du type avec les espaces de noms parents (ex. : MyNameSpace.MyClassOne).

E. Découverte de membres

Découverte de membres
// On suppose que la directive using System.Reflection est présente plus haut

Assembly monAssembly = Assembly.LoadFrom("C:\assemblyName.dll");

foreach(Type type in monAssembly.GetTypes())
{
	foreach(MemberInfo member in type.GetMembers())
	{
		Console.WriteLine("Type : " + type.Name + " \tMembre :" + member.Name);
	}
}

Principales natures des membres
• MemberType.Method : Ce membre est une méthode.
• MemberType.Field : Ce membre est un champ.
• MemberType.Property : Ce membre est une propriété.
• MemberType.Constructor : Ce membre est un constructeur du type.

Détermination de la nature des membres
// nodeTemp est un noeud de l'arbre créé plus haut (racine)

foreach(MemberInfo member in type.GetMembers())
{
	TreeNode nodeMember = nodeTemp.Nodes.Add(member.Name);			

	switch(member.MemberType)
	{
		case MemberTypes.Method :
			// On colorie les méthodes en bleu ...
			nodeMember.ForeColor = System.Drawing.Color.Blue;
			break;

		case MemberTypes.Field :
			// On colorie les champs en rouge ...
			nodeMember.ForeColor = System.Drawing.Color.Red;
			break;

		(...)
	}
}

F. Instanciation dynamique de types

Interface IAutomobile
using System;

namespace GenericAutomobile
{
	public interface IAutomobile
	{
		void Accelerer(double dIncrement);
		void Tourner(double dAngle);
	}
}

Instanciation d'un type
// Objet réalisant notre interface
IAutomobile Automobile;

// Nom de l'objet à créer
string m_sClassName = "AudiRS4";

// Chargement de l'assemblage
Assembly assembly = Assembly.LoadFrom(m_sClassName + ".dll");

// Introspection des types
foreach(Type type in assembly.GetTypes())
{
	if(m_sClassName == type.Name)
	{
		// Un type correspond, création d'un objet
		Automobile = (GenericAutomobile.IAutomobile) Activator.CreateInstance(type);
	}
}

G. Invocation de membres

Invocation d'une méthode
// Nom de la méthode à invoquer
m_sQuery = "ToString";

try
{
	object result = (object) Automobile.GetType().InvokeMember(m_sQuery, 
		BindingFlags.Default | 
		BindingFlags.Public | BindingFlags.NonPublic | 
		BindingFlags.Instance | BindingFlags.InvokeMethod, null, Automobile, null);

	Console.WriteLine("Résultat : " + result.ToString());
}
catch(System.MissingMethodException mme)
{
	// Dans le cas ou la méthode n'est pas un membre de ce type ...
	Console.WriteLine("Méthode '" + m_sQuery + "' introuvable.");
}

Plus de détails sur ces informations de laison sont disponibles  sur cette page du MSDN.

IV. Applications concrètes de la réflexion

A. Reflector

B. Complétion de code

V. Masquer la réflexion

VI. Ressources

  MSDN : Espace de noms System.Reflection.
  MSDN : Espace de noms System.Reflection.
 Site du logiciel Reflector, un puissant explorateur d'assemblages (gratuit).
 Site de l'éditeur XenoCode.

VI. Remerciements