Utilisation de métadonnées au moment de l'exécution

Mise à jour : novembre 2007

Pour mieux comprendre les métadonnées et leur rôle dans le Common Language Runtime, il peut être utile de construire un programme simple qui illustre comment les métadonnées influencent son comportement à l'exécution. L'exemple de code suivant montre deux méthodes à l'intérieur d'une classe intitulée MyApp. La méthode Main constitue le point d'entrée du programme, tandis que la méthode Add retourne simplement le total de deux arguments de type entier.

Public Class MyApp
   Public Shared Sub Main()
      Dim ValueOne As Integer = 10
      Dim ValueTwo As Integer = 20
      Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo))
   End Sub
   
   Public Shared Function Add(One As Integer, Two As Integer) As Integer
      Return (One + Two)
   End Function
End Class

using System;  
public class MyApp
{
   public static int Main()
   {
      int ValueOne = 10;
      int ValueTwo = 20;         
      Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo));
      return 0;
   }
   public static int Add(int One, int Two)
   {
      return (One + Two);
   }
}

Quand le code s'exécute, le runtime charge le module en mémoire et consulte les métadonnées correspondant à la classe. Une fois chargé, le runtime effectue une analyse complète du flux MSIL de la méthode pour le convertir en instructions machine natives rapides. Le runtime utilise un compilateur juste-à-temps (JIT, Just-In-Time) pour convertir les instructions MSIL en code machine natif, une méthode à la fois, selon les besoins.

L'exemple suivant montre une partie du MSIL générée à partir de la fonction Main du code précédent. Vous pouvez afficher le code MSIL et les métadonnées de toute application .NET Framework à l'aide du Désassembleur MSIL (Ildasm.exe).

      .entrypoint
      .maxstack  3
      .locals ([0] int32 ValueOne,
               [1] int32 ValueTwo,
               [2] int32 V_2,
               [3] int32 V_3)
      IL_0000:  ldc.i4.s   10
      IL_0002:  stloc.0
      IL_0003:  ldc.i4.s   20
      IL_0005:  stloc.1
      IL_0006:  ldstr      "The Value is: {0}"
      IL_000b:  ldloc.0
      IL_000c:  ldloc.1
      IL_000d:  call int32 ConsoleApplication.MyApp::Add(int32,int32) /* 06000003 */

Le compilateur JIT lit le code MSIL de la totalité de la méthode, l'analyse intégralement et génère des instructions natives performantes pour la méthode. L'adresse IL_000d contient un jeton de métadonnées pour la méthode Add (/*06000003 */) et le runtime utilise ce jeton pour consulter la troisième ligne de la table MethodDef.

Le tableau suivant montre une partie de la table MethodDef référencée par le jeton de métadonnées qui décrit la méthode Add. Bien qu'il existe d'autres tables de métadonnées dans cet assembly et qu'elles aient leurs propres valeurs uniques, seule la table MethodDef est prise en compte dans le tableau.

Ligne	Adresse RVA (Relative Virtual Address)	ImplFlags	Flags	Name (pointe vers le tas de chaîne)	Signature (pointe vers le tas de blob)
1	0x00002050	IL Managed	Public ReuseSlot SpecialName RTSpecialName .ctor	.ctor (constructeur)
2	0x00002058	IL Managed	Public Static ReuseSlot	Main	String
3	0x0000208c	IL Managed	Public Static ReuseSlot	Add	int, int, int

Chaque colonne de la table contient des informations importantes concernant votre code. La colonne RVA permet au runtime de calculer l'adresse mémoire de départ du code MSIL qui définit la méthode. Les colonnes ImplFlags et Flags contiennent des masques de bits qui décrivent la méthode (par exemple, ils indiquent si la méthode est publique ou privée). La colonne Name indexe le nom de la méthode à partir du tas de chaîne. La colonne Signature indexe la définition de la signature de la méthode dans le tas de blob.

Le runtime calcule l'adresse offset souhaitée à partir de la troisième ligne de la colonne RVA et retourne cette adresse au compilateur JIT, qui poursuit alors jusqu'à la nouvelle adresse. Le compilateur JIT continue le traitement du code MSIL à la nouvelle adresse jusqu'à ce qu'il rencontre un autre jeton de métadonnées, auquel cas le processus est répété.

Grâce aux métadonnées, le runtime a accès à toutes les informations dont il a besoin pour charger votre code et le traiter en instructions machine natives. Les métadonnées permettent ainsi les fichiers autodescriptifs et, en même temps que le système de type commun (CTS, Common Type System), l'héritage interlangage.

Voir aussi

Concepts

Compilation en MSIL

Compilation du MSIL en code natif

Autres ressources

Structure et utilisation des métadonnées