Métadonnées et composants autodescriptifsMetadata and Self-Describing Components

Par le passé, un composant logiciel (.exe or .dll) écrit dans un langage ne pouvait pas utiliser aisément un composant logiciel écrit dans un autre langage.In the past, a software component (.exe or .dll) that was written in one language could not easily use a software component that was written in another language. COM a fourni une étape vers la résolution de ce problème.COM provided a step towards solving this problem. Le .NET Framework facilite encore plus l'interopérabilité des composants en autorisant les compilateurs à émettre des informations déclaratives supplémentaires dans tous les modules et assemblys.The .NET Framework makes component interoperation even easier by allowing compilers to emit additional declarative information into all modules and assemblies. Ces informations, appelées métadonnées, aident les composants à interagir de façon transparente.This information, called metadata, helps components to interact seamlessly.

Les métadonnées sont des informations binaires décrivant votre programme ; elles sont stockées dans un fichier exécutable portable (fichier PE) du Common Language Runtime ou en mémoire.Metadata is binary information describing your program that is stored either in a common language runtime portable executable (PE) file or in memory. Lorsque vous compilez votre code dans un fichier PE, les métadonnées sont insérées dans une partie du fichier, tandis que votre code est converti en langage MSIL (Microsoft Intermediate Language) et inséré dans une autre partie du fichier.When you compile your code into a PE file, metadata is inserted into one portion of the file, and your code is converted to Microsoft intermediate language (MSIL) and inserted into another portion of the file. Les types et membre définis et référencés dans un module ou un assembly sont décrits au sein des métadonnées.Every type and member that is defined and referenced in a module or assembly is described within metadata. Quand le code est exécuté, le runtime charge les métadonnées en mémoire et y fait référence pour découvrir les informations concernant les classes de votre code, les membres, l'héritage, etc.When code is executed, the runtime loads metadata into memory and references it to discover information about your code's classes, members, inheritance, and so on.

Les métadonnées décrivent tous les types et membres définis dans votre code sous une forme indépendante du langage.Metadata describes every type and member defined in your code in a language-neutral manner. Les métadonnées stockent les informations suivantes :Metadata stores the following information:

  • Description de l'assembly.Description of the assembly.

    • Identité (nom, version, culture, clé publique).Identity (name, version, culture, public key).

    • Les types exportés.The types that are exported.

    • Les autres assemblys dont dépend cet assembly.Other assemblies that this assembly depends on.

    • Les autorisations de sécurité nécessaires à l'exécution.Security permissions needed to run.

  • Description des types.Description of types.

    • Nom, visibilité, classe de base et interfaces implémentées.Name, visibility, base class, and interfaces implemented.

    • Membres (méthodes, champs, propriétés, événements, types imbriqués).Members (methods, fields, properties, events, nested types).

  • Attributs.Attributes.

    • Éléments descriptifs supplémentaires qui modifient les types et les membres.Additional descriptive elements that modify types and members.

Avantages des métadonnéesBenefits of Metadata

Les métadonnées sont la clé d'un modèle de programmation plus simple et suppriment la nécessité de fichiers IDL (Interface Definition Language), de fichiers d'en-tête ou de toute méthode externe de référence aux composants.Metadata is the key to a simpler programming model, and eliminates the need for Interface Definition Language (IDL) files, header files, or any external method of component reference. Les métadonnées permettent aux langages du .NET Framework de se décrire eux-mêmes automatiquement d'une manière indépendante du langage, transparente aussi bien au développeur qu'à l'utilisateur.Metadata enables .NET Framework languages to describe themselves automatically in a language-neutral manner, unseen by both the developer and the user. En outre, les métadonnées sont extensibles via l'utilisation d'attributs.Additionally, metadata is extensible through the use of attributes. Les métadonnées offrent les principaux avantages suivants :Metadata provides the following major benefits:

  • Fichiers autodescriptifs.Self-describing files.

    Les modules et assemblys du Common Language Runtime sont autodescriptifs.Common language runtime modules and assemblies are self-describing. Les métadonnées d'un module contiennent tous les éléments nécessaires pour interagir avec un autre module.A module's metadata contains everything needed to interact with another module. Les métadonnées offrent automatiquement la fonctionnalité IDL du modèle COM, ce qui vous permet d'utiliser un seul fichier pour la définition et l'implémentation.Metadata automatically provides the functionality of IDL in COM, so you can use one file for both definition and implementation. Les modules et assemblys du runtime ne nécessitent même pas l'inscription dans le système d'exploitation.Runtime modules and assemblies do not even require registration with the operating system. En conséquence, les descriptions utilisées par le runtime reflètent toujours le code réel de votre fichier compilé, ce qui accroît la fiabilité de l'application.As a result, the descriptions used by the runtime always reflect the actual code in your compiled file, which increases application reliability.

  • Interopérabilité des langages et design à base de composants plus simple.Language interoperability and easier component-based design.

    Les métadonnées fournissent toutes les informations requises concernant le code compilé pour que vous puissiez hériter une classe à partir d'un fichier PE écrit dans un autre langage.Metadata provides all the information required about compiled code for you to inherit a class from a PE file written in a different language. Vous pouvez créer une instance de toute classe écrite dans un langage managé (tout langage ciblant le Common Language Runtime) sans vous préoccuper de marshaling explicite ou d'utiliser un code d'interopérabilité personnalisé.You can create an instance of any class written in any managed language (any language that targets the common language runtime) without worrying about explicit marshaling or using custom interoperability code.

  • Attributs.Attributes.

    Le .NET Framework vous permet de déclarer des types particuliers de métadonnées, appelés attributs, dans votre fichier compilé.The .NET Framework lets you declare specific kinds of metadata, called attributes, in your compiled file. Les attributs peuvent être recherchés via le .NET Framework et sont utilisés pour contrôler de façon plus détaillée comment votre programme se comporte au moment de l'exécution.Attributes can be found throughout the .NET Framework and are used to control in more detail how your program behaves at run time. En outre, vous pouvez émettre vos propres métadonnées personnalisées dans les fichiers .NET Framework via les attributs personnalisés définis par l'utilisateur.Additionally, you can emit your own custom metadata into .NET Framework files through user-defined custom attributes. Pour plus d’informations, consultez Attributs.For more information, see Attributes.

Métadonnées et structure des fichiers PEMetadata and the PE File Structure

Les métadonnées sont stockées dans une section du fichier exécutable portable (fichier PE) .NET Framework, tandis que le code MSIL (Microsoft Intermediate Language) est stocké dans une autre section.Metadata is stored in one section of a .NET Framework portable executable (PE) file, while Microsoft intermediate language (MSIL) is stored in another section of the PE file. La partie métadonnées du fichier contient un ensemble de structures de données de table et de tas.The metadata portion of the file contains a series of table and heap data structures. La partie MSIL contient le code MSIL et les jetons de métadonnées qui font référence à la partie métadonnées du fichier PE.The MSIL portion contains MSIL and metadata tokens that reference the metadata portion of the PE file. Vous pouvez rencontrer des jetons de métadonnées quand vous utilisez des outils tels que le Désassembleur MSIL (Ildasm.exe) pour consulter le MSIL de votre code, par exemple.You might encounter metadata tokens when you use tools such as the MSIL Disassembler (Ildasm.exe) to view your code's MSIL, for example.

Tas et tables de métadonnéesMetadata Tables and Heaps

Chaque table de métadonnées contient des informations sur les éléments de votre programme.Each metadata table holds information about the elements of your program. Par exemple, une table de métadonnées décrit les classes de votre code, une autre décrit les champs, etc.For example, one metadata table describes the classes in your code, another table describes the fields, and so on. Si vous disposez de dix classes dans votre code, la table des classes aura dix lignes, une par classe.If you have ten classes in your code, the class table will have tens rows, one for each class. Les tables de métadonnées font référence à d'autres tables et d'autres tas.Metadata tables reference other tables and heaps. Par exemple, la table des métadonnées pour les classes fait référence à la table pour les méthodes.For example, the metadata table for classes references the table for methods.

Les métadonnées stockent aussi des informations dans quatre structures de tas : chaîne, blob, chaîne utilisateur et un Identificateur Global Unique (GUID, Globally Unique IDentifier).Metadata also stores information in four heap structures: string, blob, user string, and GUID. Toutes les chaînes utilisées pour nommer les types et les membres sont stockées dans le tas de chaîne.All the strings used to name types and members are stored in the string heap. Par exemple, une table de méthodes ne stocke pas directement le nom d'une méthode particulière, mais pointe vers le nom de la méthode stocké dans le tas de chaîne.For example, a method table does not directly store the name of a particular method, but points to the method's name stored in the string heap.

Jetons de métadonnéesMetadata Tokens

Chaque ligne des tables de métadonnées est identifiée de façon unique dans la partie MSIL du fichier PE au moyen d'un jeton de métadonnées.Each row of each metadata table is uniquely identified in the MSIL portion of the PE file by a metadata token. Conceptuellement, les jetons de métadonnées sont similaires à des pointeurs, persistants dans le langage MSIL, qui font référence à une table de métadonnées spécifique.Metadata tokens are conceptually similar to pointers, persisted in MSIL, that reference a particular metadata table.

Un jeton de métadonnées est un nombre stocké sur quatre octets.A metadata token is a four-byte number. L'octet de poids le plus fort identifie la table de métadonnées à laquelle un jeton donné fait référence (méthode, type, etc.).The top byte denotes the metadata table to which a particular token refers (method, type, and so on). Les trois octets restants spécifient la ligne de la table de métadonnées qui correspond à l'élément de programmation en cours de description.The remaining three bytes specify the row in the metadata table that corresponds to the programming element being described. Si vous définissez une méthode en C# et la compilez dans un fichier PE, le jeton de métadonnées suivant figurera probablement dans la partie MSIL du fichier PE :If you define a method in C# and compile it into a PE file, the following metadata token might exist in the MSIL portion of the PE file:

0x06000004

L’octet de poids le plus fort (0x06) indique qu’il s’agit d’un jeton MethodDef.The top byte (0x06) indicates that this is a MethodDef token. Les trois autres octets (000004) indiquent au Common Language Runtime de rechercher dans la quatrième ligne de la table MethodDef les informations décrivant la définition de cette méthode.The lower three bytes (000004) tells the common language runtime to look in the fourth row of the MethodDef table for the information that describes this method definition.

Métadonnées au sein d'un fichier PEMetadata within a PE File

Quand un programme est compilé pour le Common Language Runtime, il est converti en fichier PE, composé de trois parties.When a program is compiled for the common language runtime, it is converted to a PE file that consists of three parts. Le tableau ci-après décrit le contenu de chaque partie.The following table describes the contents of each part.

Section PEPE section Contenu de la section PEContents of PE section
En-tête PEPE header L'index des sections principales du fichier PE et l'adresse du point d'entrée.The index of the PE file's main sections and the address of the entry point.

Le runtime utilise ces informations pour identifier le fichier comme fichier PE et pour déterminer où commence l'exécution lors du chargement du programme en mémoire.The runtime uses this information to identify the file as a PE file and to determine where execution starts when loading the program into memory.
Instructions MSILMSIL instructions Les instructions MSIL (Microsoft Intermediate Language) composant votre code.The Microsoft intermediate language instructions (MSIL) that make up your code. Nombre d'instructions MSIL sont accompagnées de jetons de métadonnées.Many MSIL instructions are accompanied by metadata tokens.
MétadonnéesMetadata Tas et tables de métadonnées.Metadata tables and heaps. Le runtime utilise cette section pour enregistrer les informations sur chaque type et membre de votre code.The runtime uses this section to record information about every type and member in your code. Cette section contient aussi des attributs personnalisés et des informations de sécurité.This section also includes custom attributes and security information.

Utilisation de métadonnées au moment de l'exécutionRun-Time Use of Metadata

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.To better understand metadata and its role in the common language runtime, it might be helpful to construct a simple program and illustrate how metadata affects its run-time life. L'exemple de code suivant montre deux méthodes à l'intérieur d'une classe intitulée MyApp.The following code example shows two methods inside a class called 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.The Main method is the program entry point, while the Add method simply returns the sum of two integer arguments.

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.When the code runs, the runtime loads the module into memory and consults the metadata for this class. 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.Once loaded, the runtime performs extensive analysis of the method's Microsoft intermediate language (MSIL) stream to convert it to fast native machine instructions. 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.The runtime uses a just-in-time (JIT) compiler to convert the MSIL instructions to native machine code one method at a time as needed.

L'exemple suivant montre une partie du MSIL générée à partir de la fonction Main du code précédent.The following example shows part of the MSIL produced from the previous code's Main function. Vous pouvez afficher le code MSIL et les métadonnées de toute application .NET Framework à l’aide du Désassembleur MSIL (Ildasm.exe).You can view the MSIL and metadata from any .NET Framework application using the MSIL Disassembler (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.The JIT compiler reads the MSIL for the whole method, analyzes it thoroughly, and generates efficient native instructions for the method. 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.At IL_000d, a metadata token for the Add method (/* 06000003 */) is encountered and the runtime uses the token to consult the third row of the MethodDef table.

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.The following table shows part of the MethodDef table referenced by the metadata token that describes the Add method. Bien qu'il existe d'autres tables de métadonnées dans cet assembly et qu'elles aient leurs propres valeurs uniques, seule cette table est prise en compte dans le tableau.While other metadata tables exist in this assembly and have their own unique values, only this table is discussed.

LigneRow Adresse RVA (Relative Virtual Address)Relative Virtual Address (RVA) ImplFlagsImplFlags IndicateursFlags NameName

(pointe vers le tas de chaîne)(Points to string heap.)
Signature (pointe vers le tas de blob)Signature (Points to blob heap.)
11 0x000020500x00002050 ILIL

ManagéManaged
PublicPublic

ReuseSlotReuseSlot

SpecialNameSpecialName

RTSpecialNameRTSpecialName

.ctor.ctor
.ctor (constructeur).ctor (constructor)
22 0x000020580x00002058 ILIL

ManagéManaged
PublicPublic

StatiqueStatic

ReuseSlotReuseSlot
MainMain ChaîneString
33 0x0000208c0x0000208c ILIL

ManagéManaged
PublicPublic

StatiqueStatic

ReuseSlotReuseSlot
AjouterAdd int, int, intint, int, int

Chaque colonne de la table contient des informations importantes concernant votre code.Each column of the table contains important information about your 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.The RVA column allows the runtime to calculate the starting memory address of the MSIL that defines this method. 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).The ImplFlags and Flags columns contain bitmasks that describe the method (for example, whether the method is public or private). La colonne Name indexe le nom de la méthode à partir du tas de chaîne.The Name column indexes the name of the method from the string heap. La colonne Signature indexe la définition de la signature de la méthode dans le tas de blob.The Signature column indexes the definition of the method's signature in the blob heap.

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.The runtime calculates the desired offset address from the RVA column in the third row and returns this address to the JIT compiler, which then proceeds to the new address. 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é.The JIT compiler continues to process MSIL at the new address until it encounters another metadata token and the process is repeated.

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.Using metadata, the runtime has access to all the information it needs to load your code and process it into native machine instructions. 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.In this manner, metadata enables self-describing files and, together with the common type system, cross-language inheritance.

TitreTitle DescriptionDescription
AttributsAttributes Décrit comment appliquer les attributs, écrire des attributs personnalisés et récupérer les informations stockées dans les attributs.Describes how to apply attributes, write custom attributes, and retrieve information that is stored in attributes.