.NET : Introduction à la réflexion (VB.NET)

La réflexion est l'art de découvrir des types et d'invoquer leurs membres à l'exécution. La réflexion permet d'inspecter dynamiquement le contenu d'assemblages, d'en lire ses types, de créer des instances de ces types durant l'exécution du programme et d'appeler leurs méthodes ou champs dynamiquement. La réflexion est également appelée introspection suivant les auteurs, mais, avec l'arrivée de .NET, le terme réflexion s'est généralisé. On utilise également le terme de liaison tardive (late binding) pour décrire une instanciation à la volée au moment de l'exécution. Il existe d'autres mécanismes s'approchant de la réflexion utilisés avant .NET, comme RTTI (Run-Time Type Identification) en C/C++ ou, dans une certaine mesure, l'interface IDispatch pour les composants COM.

Tous les assemblages managés (programmés pour le CLR .NET) comportent des métadonnées qui décrivent le contenu de l'assemblage. En lisant ces métadonnées, un programme peut inspecter les types contenus dans l'assemblage, déterminer ses membres et les invoquer.

Les applications de la réflexion sont nombreuses, et beaucoup d'entre nous s'en servent tous les jours depuis longtemps sans s'en rendre compte. L'exemple le plus flagrant reste les environnements de développement évolués et leurs multiples fenêtres et outils : un explorateur de classes utilise la réflexion. Les membres des classes et les classes elles-mêmes sont découvertes et ajoutées au fur et à mesure des actions du développeur. Un autre exemple : la complétion de code. N'est-ce pas magnifique que, lorsque l'on tape un point après un identificateur d'objet en C# dans un environnement de développement comme Visual Studio, la liste de ses membres s'affiche? Dans ce cas aussi, le mécanisme repose sur la réflexion pour découvrir à la volée tous les membres de l'objet concerné.

Il y a deux manières de charger dynamiquement un assemblage : logique ou physique. Le chargement logique s'appuie sur une des caractéristiques des assemblages .NET, les noms forts. En travaillant avec le Global Assembly Cache (GAC) de .NET, le CLR est capable de charger un assemblage en connaissant son nom, sa version ou encore sa culture. Voici un exemple :

' On suppose que la directive Imports System.Reflection est présente plus haut
 
' Chargement en spécifiant la culture
Dim monAssembly As Assembly =  Assembly.Load("assemblyName, Culture=fr") 
 
' Chargement en spécifiant la version
Dim monAssembly As Assembly =  Assembly.Load("assemblyName, version=1.2.3.4")

Voyons maintenant la manière de charger physiquement un assemblage. Celui-ci nécessite de connaître le nom du fichier de l'assemblage que l'on veut charger et sa localisation sur le système, ce qui le rend un peu plus dépendant que le chargement logique, mais plus facile à appréhender.

' On suppose que la directive Imports System.Reflection est présente plus haut

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

L'assemblage est maintenant chargé. Nous pouvons désormais inspecter ce qu'il contient. Avant cela, je vais faire un rapide rappel concernant les termes utilisés ci-dessous.

• 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 quatre 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.

En règle générale, un assemblage contient un ou plusieurs types définis (une ou plusieurs classes par exemple). Ces types appartiennent à l'espace de noms défini dans l'assemblage, et il serait utile de lister tous les types que l'assemblage contient pour, par la suite, instancier l'un d'eux. L'exemple de code suivant permet d'inspecter chaque type d'un assemblage :

' On suppose que la directive Imports System.Reflection est présente plus haut

Dim monAssembly As Assembly =  Assembly.LoadFrom("C:\assemblyName.dll") 
 
Dim MonType As Type
For Each MonType In monAssembly.GetTypes()
    Console.WriteLine("Type présent dans l'assemblage : " + MonType.Name)
Next

La méthode GetTypes permet de lire les types de l'assemblage, et renvoie un tableau d'instances de System.Type de tous les types contenus dans l'assemblage. Si la DLL .NET assemblyName.dll contient deux classes MyClassOne et MyClassTwo, GetTypes retournera ces deux types et la sortie du programme sera la suivante :

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

Chaque type comporte des membres. Ces membres peuvent être des méthodes, des champs ou des propriétés par exemple. La réflexion permet de découvrir chaque membre d'un type donné. Soit la séquence de code suivante :

' On suppose que la directive Imports System.Reflection est présente plus haut

Dim monAssembly As Assembly =  Assembly.LoadFrom("C:\assemblyName.dll") 
 
Dim MonType As Type
For Each MonType In monAssembly.GetTypes()
    Dim member As MemberInfo
    For Each member In MonType.GetMembers()
        Console.WriteLine("Type : " + MonType.Name + " \tMembre :" + member.Name)
    Next
Next

Le code ci-dessus parcourt tous les membres de chaque type présent dans l'assemblage assemblyName.dll. On affiche dans la console tous les membres découverts.

Dans le cas de la réalisation d'un simple explorateur de classes, on pourrait être amené à colorer les membres selon leur nature : méthode, champ, constructeur… Pour déterminer la nature des membres, on utilise le champ MemberType de la classe MemberInfo, qui est une énumération. Voici les principales natures que vous rencontrerez.

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.

Donc, dans le cas d'un explorateur de classes avec une vue en arbre (TreeView) où l'on veut colorer chaque membre en fonction de sa nature, le code serait le suivant :

' nodeTemp est un noeud de l'arbre créé plus haut (racine)
 
Dim member As MemberInfo
For Each member In type.GetMembers()
    Dim nodeMember As TreeNode =  nodeTemp.Nodes.Add(member.Name) 
 
    Select Case member.MemberType
        Case MemberTypes.Method
            ' On colorie les méthodes en bleu ...
            nodeMember.ForeColor = System.Drawing.Color.Blue
            Exit For
 
        Case MemberTypes.Field
            ' On colorie les champs en rouge ...
            nodeMember.ForeColor = System.Drawing.Color.Red
            Exit For
    End Select
Next

Un champ intéressant de la classe MemberInfo se nomme DeclaringType. Il contient le nom du type ou le membre est déclaré. En d'autres termes, cela permet de savoir si le membre est un membre natif du type actuel, ou s'il est hérité d'une quelconque superclasse. Par exemple, la valeur de DeclaringType sur le membre GetType de n'importe quel objet .NET sera toujours System.Object, car c'est dans cette classe que GetType est déclarée.

Dans la plupart des cas, la découverte dynamique de types est suivie d'une instanciation de l'un de ces types. On parle alors de late binding, ou liaison tardive pour décrire la création d'un objet à l'exécution. L'exemple ci-dessous permet d'instancier des types et de les utiliser comme des objets réels également lors du développement, car leur interface sera commune et connue.

Considérons le problème suivant : nous voulons créer plusieurs implémentations de classes qui réalisent une même interface, et choisir à l'exécution quelle implémentation utiliser. Par exemple, on considère une interface IAutomobile, et deux classes AudiRS4 et BmwM3. On décide de faire deux assemblages AudiRS4 et BmwM3 qui contiennent l'implémentation des méthodes décrites dans l'interface IAutomobile, elle-même dans IAutomobile.dll.

Imports System
 
Namespace GenericAutomobile
    Public Interface IAutomobile
        Accelerer(Double dIncrement)
        Tourner(Double dAngle)
    End Interface
End Namespace

Le programme principal est chargé de découvrir et d'instancier un objet de type AudiRS4 ou BmwM3. Pour ce faire, il lui faut impérativement une référence sur l'assemblage IAutomobile.dll. Ensuite, il suffira de renseigner l'application sur le nom du type que l'on veut créer, de parcourir les assemblages et de voir si le type demandé est bel et bien présent.

' Objet réalisant notre interface
Dim Automobile As IAutomobile
 
' Nom de l'objet à créer
Dim m_sClassName As String =  "AudiRS4" 
 
' Chargement de l'assemblage
Dim assembly As Assembly =  Assembly.LoadFrom(m_sClassName + ".dll") 
 
' Introspection des types
Dim type As Type
For Each type In assembly.GetTypes()
    If m_sClassName = type.Name Then
        ' Un type correspond, création d'un objet
        Automobile = CType(Activator.CreateInstance(type), GenericAutomobile.IAutomobile)
    End If
Next

Notre objet Automobile est maintenant créé. Dans l'exemple et pour que cela soit utilisable dynamiquement, il faudrait que le nom du type que l'on souhaite utiliser provienne d'un champ texte ou d'ailleurs, mais qu'il ne soit pas codé en dur.

Le code suivant permet d'appeler dynamiquement une méthode. Si la méthode n'existe pas, on affiche un message d'erreur dans la console. Si la méthode est présente, on affiche son résultat.

' Nom de la méthode à invoquer
m_sQuery = "ToString"
 
Try
    Object result as object = Automobile.GetType().InvokeMember(m_sQuery, 
        BindingFlags.Default | 
        BindingFlags.Public | BindingFlags.NonPublic | 
        BindingFlags.Instance | BindingFlags.InvokeMethod, Nothing, Automobile, Nothing)
 
    Console.WriteLine("Résultat : " + result.ToString())
Catch mme As System.MissingMethodException
    ' Dans le cas où la méthode n'est pas un membre de ce type ...
    Console.WriteLine("Méthode <" + m_sQuery + "> introuvable.")
End Try

On utilise la méthode InvokeMember pour invoquer un membre d'un type. Celle-ci prend plusieurs paramètres dont le nom de la méthode, les informations de liaison (binding flags) et éventuellement une instance d'objet sur lequel peut être effectuée l'invocation.

Les informations de liaison permettent de différencier les invocations suivant la nature du membre : méthode, champ (lecture/écriture), propriété… Il existe de nombreuses combinaisons qui permettent de restreindre ou de garantir l'accès à un membre. Par exemple, BindingFlags.Public spécifie que tous les membres publics doivent être inclus dans la recherche. BindingsFlags.Instance permet de rechercher dans les membres d'instance.

Reflector est un puissant explorateur d'assemblages. Il permet de parcourir les modules, les types et leurs membres, et permet même de décompiler le code IL (intermediate language) en code C# ou VB.NET.

La complétion de code est un mécanisme très utilisé par les environnements de développement comme Visual Studio ou celui de Borland Delphi. C'est grâce à la réflexion que cela est rendu possible en .NET. L'image ci-dessous montre le type System.Double et tous ses membres découverts par Visual Studio .NET :