Metadaten und selbstbeschreibende KomponentenMetadata and Self-Describing Components

Früher konnte eine in einer bestimmten Sprache geschriebene Softwarekomponente (.exe oder .dll) nicht einfach eine andere Softwarekomponente verwenden, die in einer anderen Sprache geschrieben war.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 ist die Lösung dieses Problems angegangen.COM provided a step towards solving this problem. Mit .NET Framework wird die Interoperation von Komponenten erleichtert, indem zusätzliche deklarative Informationen von Compilern an alle Module und Assemblys weitergegeben werden.The .NET Framework makes component interoperation even easier by allowing compilers to emit additional declarative information into all modules and assemblies. Diese Informationen, so genannte Metadaten, ermöglichen eine nahtlose Interaktion der Komponenten.This information, called metadata, helps components to interact seamlessly.

Metadaten sind binäre Informationen, die ein Programm beschreiben, das entweder im Speicher oder in einer PE (Portable Executable)-Datei von Common Language Runtime gespeichert ist.Metadata is binary information describing your program that is stored either in a common language runtime portable executable (PE) file or in memory. Wenn Sie Code in eine PE-Datei kompilieren, werden in einen Bereich der Datei Metadaten eingefügt, während der Code in MSIL (Microsoft Intermediate Language) konvertiert und in einen anderen Bereich der Datei eingefügt wird.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. Jeder Typ und jeder Member, auf den in einem Modul oder in einer Assembly verwiesen wird, wird mit Metadaten beschrieben.Every type and member that is defined and referenced in a module or assembly is described within metadata. Beim Ausführen von Code lädt Common Language Runtime Metadaten in den Speicher und verweist darauf, um Informationen zu Codeklassen, Membern, Vererbung usw. zu finden.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.

Metadaten beschreiben auf sprachneutrale Weise alle im Code definierten Typen und Member.Metadata describes every type and member defined in your code in a language-neutral manner. In Metadaten werden folgende Informationen gespeichert:Metadata stores the following information:

  • Beschreibung der AssemblyDescription of the assembly.

    • Identität (Name, Version, Kultur, öffentlicher Schlüssel).Identity (name, version, culture, public key).

    • Typen, die exportiert werden.The types that are exported.

    • Andere Assemblys, von denen diese Assembly abhängt.Other assemblies that this assembly depends on.

    • Sicherheitsberechtigungen, die zur Ausführung benötigt werden.Security permissions needed to run.

  • TypenbeschreibungDescription of types.

    • Name, Sichtbarkeit, Basisklasse und implementierte Schnittstellen.Name, visibility, base class, and interfaces implemented.

    • Member (Methoden, Felder, Eigenschaften, Ereignisse, geschachtelte Typen).Members (methods, fields, properties, events, nested types).

  • AttributeAttributes.

    • Zusätzliche beschreibende Elemente, die Änderungen an Typen und Membern vornehmen.Additional descriptive elements that modify types and members.

Vorteile von MetadatenBenefits of Metadata

Metadaten ermöglichen ein einfacheres Programmierungsmodell und machen IDL (Interface Definition Language)-Dateien, Headerdateien oder andere externe Methoden zum Verweisen auf Komponenten überflüssig.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. Mit Metadaten können .NET Framework-Sprachen automatisch auf sprachneutrale Weise beschrieben werden, unabhängig vom Entwickler und Benutzer.Metadata enables .NET Framework languages to describe themselves automatically in a language-neutral manner, unseen by both the developer and the user. Metadaten sind zudem mithilfe von Attributen erweiterbar.Additionally, metadata is extensible through the use of attributes. Sie bieten die folgenden wesentlichen Vorteile:Metadata provides the following major benefits:

  • Selbstbeschreibende DateienSelf-describing files.

    Common Language Runtime-Module und Assemblys sind selbstbeschreibend.Common language runtime modules and assemblies are self-describing. Die Metadaten eines Moduls enthalten alle zur Interaktion mit einem anderen Modul benötigten Informationen.A module's metadata contains everything needed to interact with another module. Metadaten stellen automatisch die gleichen Funktionalitäten zur Verfügung, die IDL in COM bereitstellt. Auf diese Weise können Sie eine Datei sowohl für Definition als auch für Implementierung verwenden.Metadata automatically provides the functionality of IDL in COM, so you can use one file for both definition and implementation. Laufzeitmodule und Assemblys erfordern nicht einmal eine Registrierung beim Betriebssystem.Runtime modules and assemblies do not even require registration with the operating system. Die von Common Language Runtime verwendeten Beschreibungen geben daher den tatsächlichen Code in der kompilierten Datei wieder. Dies erhöht die Zuverlässigkeit von Anwendungen.As a result, the descriptions used by the runtime always reflect the actual code in your compiled file, which increases application reliability.

  • Sprachübergreifende Interoperabilität und einfacheres, komponentenbasiertes DesignLanguage interoperability and easier component-based design.

    Metadaten stellen alle Informationen über kompilierten Code zur Verfügung, die für das Erben einer Klasse aus einer PE-Datei, die in einer anderen Sprache geschrieben wurde, benötigt werden.Metadata provides all the information required about compiled code for you to inherit a class from a PE file written in a different language. Sie können eine Instanz einer beliebigen Klasse erstellen, die in einer beliebigen verwalteten Sprache geschrieben wurde (jede Sprache, die Common Language Runtime anspricht), ohne auf explizites Marshallen oder die Verwendung von benutzerdefiniertem Interoperabilitätscode zurückgreifen zu müssen.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.

  • AttributeAttributes.

    Mit .NET Framework können Sie bestimmte Arten von Metadaten, so genannte Attribute, in der kompilierten Datei deklarieren.The .NET Framework lets you declare specific kinds of metadata, called attributes, in your compiled file. Attribute befinden sich überall in .NET Framework und dienen zur detaillierteren Steuerung des Programms zur Laufzeit.Attributes can be found throughout the .NET Framework and are used to control in more detail how your program behaves at run time. Außerdem können Sie mithilfe von benutzerdefinierten Attributen Ihre eigenen benutzerdefinierten Metadaten in .NET Framework-Dateien ausgeben.Additionally, you can emit your own custom metadata into .NET Framework files through user-defined custom attributes. Weitere Informationen finden Sie unter Attribute.For more information, see Attributes.

Metadaten und die PE-DateistrukturMetadata and the PE File Structure

Metadaten werden in einem Bereich einer .NET Framework-PE (Portable Executable)-Datei gespeichert, während MSIL (Microsoft Intermediate Language) in einem anderen Bereich der PE-Datei gespeichert wird.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. Der Metadatenbereich der Datei enthält eine Reihe von Tabellen und Heapdatenstrukturen.The metadata portion of the file contains a series of table and heap data structures. Der MSIL-Bereich enthält MSIL und Metadatentokens, die auf den Metadatenbereich der PE-Datei verweisen.The MSIL portion contains MSIL and metadata tokens that reference the metadata portion of the PE file. Möglicherweise werden Metadatentoken verwendet, wenn Sie Tools wie MSIL Disassembler-Tool (Ildasm.exe) verwenden, um z.B. die MSIL des Codes anzuzeigen.You might encounter metadata tokens when you use tools such as the MSIL Disassembler (Ildasm.exe) to view your code's MSIL, for example.

Metadatentabellen und -heapsMetadata Tables and Heaps

Jede Metadatentabelle beinhaltet Informationen über die Elemente Ihres Programms.Each metadata table holds information about the elements of your program. Eine Metadatentabelle beschreibt zum Beispiel die Klassen des Codes, eine andere beschreibt die Felder usw.For example, one metadata table describes the classes in your code, another table describes the fields, and so on. Falls der Code z. B. zehn Klassen besitzt, enthält die Klassentabelle zehn Zeilen, eine für jede Klasse.If you have ten classes in your code, the class table will have tens rows, one for each class. Metadatentabellen verweisen auf andere Tabellen und Heaps.Metadata tables reference other tables and heaps. Die Metadatentabelle für Klassen verweist z. B. auf die Tabelle für Methoden.For example, the metadata table for classes references the table for methods.

Zusätzlich speichern Metadaten Informationen in vier Heapstrukturen: Zeichenfolge, BLOB, Benutzerzeichenfolge und GUID.Metadata also stores information in four heap structures: string, blob, user string, and GUID. Alle Zeichenfolgen zum Benennen von Typen und Membern werden im Stringheap gespeichert.All the strings used to name types and members are stored in the string heap. Eine Methodentabelle speichert den Namen einer bestimmten Methode nicht direkt, sondern verweist auf dem im Stringheap gespeicherten Namen einer Methode.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.

MetadatentokensMetadata Tokens

Jede Zeile einer Metadatentabelle wird im MSIL-Bereich einer PE-Datei durch ein Metadatentoken eindeutig identifiziert.Each row of each metadata table is uniquely identified in the MSIL portion of the PE file by a metadata token. Metadatentokens sind konzeptionell identisch mit in MSIL beibehaltenen Zeigern, die auf eine bestimmte Metadatentabelle verweisen.Metadata tokens are conceptually similar to pointers, persisted in MSIL, that reference a particular metadata table.

Ein Metadatentoken ist eine Vier-Byte-Zahl.A metadata token is a four-byte number. Das oberste Byte kennzeichnet die Metadatentabelle, auf die ein bestimmtes Token verweist (Methode, Typ usw.).The top byte denotes the metadata table to which a particular token refers (method, type, and so on). Die restlichen drei Bytes geben die Zeile in der Metadatentabelle an, die dem beschriebenen Programmierelement entspricht.The remaining three bytes specify the row in the metadata table that corresponds to the programming element being described. Wenn Sie eine Methode in C# definieren und in eine PE-Datei kompilieren, befindet sich möglicherweise folgendes Metadatentoken im MSIL-Bereich der PE-Datei: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  

Das oberste Byte (0x06) gibt an, dass es sich um ein MethodDef-Token handelt.The top byte (0x06) indicates that this is a MethodDef token. Die unteren drei Bytes (000004) weisen die Common Language Runtime an, in der vierten Zeile der MethodDef-Tabelle nach Informationen zu suchen, welche die Methodendefinition beschreiben.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.

Metadaten in einer PE-DateiMetadata within a PE File

Beim Kompilieren eines Programms für Common Language Runtime wird es in eine PE-Datei konvertiert, die aus drei Teilen besteht.When a program is compiled for the common language runtime, it is converted to a PE file that consists of three parts. In der folgenden Tabelle werden die einzelnen Teile beschrieben.The following table describes the contents of each part.

PE-AbschnittPE section Inhalt des PE-AbschnittsContents of PE section
PE-HeaderPE header Index der Hauptabschnitte der PE-Datei und Adresse des Einstiegspunktes.The index of the PE file's main sections and the address of the entry point.

Common Language Runtime verwendet diese Informationen, um die Datei als PE-Datei zu identifizieren und festzulegen, wo die Ausführung beginnt, wenn das Programm in den Speicher geladen wird.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.
MSIL-AnweisungenMSIL instructions MSIL-Anweisungen (Microsoft Intermediate Language), aus denen der Code besteht.The Microsoft intermediate language instructions (MSIL) that make up your code. Viele MSIL-Anweisungen werden von Metadatentokens begleitet.Many MSIL instructions are accompanied by metadata tokens.
MetadatenMetadata Metadatentabellen und Heaps.Metadata tables and heaps. Dieser Abschnitt wird von Common Language Runtime verwendet, um Informationen über jeden Typ und jeden Member des Codes aufzuzeichnen.The runtime uses this section to record information about every type and member in your code. Dieser Abschnitt enthält auch benutzerdefinierte Attribute und Sicherheitsinformationen.This section also includes custom attributes and security information.

Verwenden von Metadaten zur LaufzeitRun-Time Use of Metadata

Zum besseren Verständnis von Metadaten und ihrer Rolle in Common Language Runtime kann es hilfreich sein, ein einfaches Programm zu schreiben, das zeigt, wie Metadaten das Verhalten der Laufzeit beeinflussen.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. Folgendes Codebeispiel zeigt zwei Methoden innerhalb der Klasse MyApp.The following code example shows two methods inside a class called MyApp. Die Main-Methode ist der Einstiegspunkt des Programms, während die Add-Methode einfach die Summe zweier Ganzzahlargumente zurückgibt.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);  
   }  
}  

Beim Ausführen des Codes lädt Common Language Runtime das Modul in den Speicher und fragt die Metadaten für diese Klasse ab.When the code runs, the runtime loads the module into memory and consults the metadata for this class. Nach dem Laden analysiert Common Language Runtime ausführlich den MSIL (Microsoft Intermediate Language)-Stream der Methode, um ihn in schnelle systemeigene Anweisungen zu konvertieren.Once loaded, the runtime performs extensive analysis of the method's Microsoft intermediate language (MSIL) stream to convert it to fast native machine instructions. Common Language Runtime verwendet einen JIT (Just-In-Time)-Compiler, um bei Bedarf jeweils für eine Methode die MSIL-Anweisungen in systemeigenen Maschinencode zu konvertieren.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.

Das folgende Beispiel zeigt einen Teil der MSIL, die aus der Main-Funktion des vorherigen Codes erstellt wurde.The following example shows part of the MSIL produced from the previous code's Main function. Sie können die MSIL und die Metadaten aus jeder .NET-Anwendung mithilfe des MSIL Disassembler-Tools (Ildasm.exe) anzeigen.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 */  

Der JIT-Compiler liest die MSIL der ganzen Methode, analysiert sie ausführlich und generiert effiziente, systemeigene Anweisungen für diese Methode.The JIT compiler reads the MSIL for the whole method, analyzes it thoroughly, and generates efficient native instructions for the method. Bei IL_000d wird ein Metadatentoken für die Add-Methode (/* 06000003 */) angetroffen. Die Runtime verwendet dieses Token, um die dritte Zeile der MethodDef-Tabelle abzufragen.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.

Folgende Tabelle zeigt einen Teil der MethodDef-Tabelle, welche die Add-Methode beschreibt und auf die das Metadatentoken verweist.The following table shows part of the MethodDef table referenced by the metadata token that describes the Add method. Obwohl es in dieser Assembly auch andere Metadatentabellen gibt, die jeweils ihre eigenen, eindeutigen Werte besitzen, wird hier nur diese Tabelle erläutert.While other metadata tables exist in this assembly and have their own unique values, only this table is discussed.

ZeileRow RVA (Relative Virtuelle Adresse)Relative Virtual Address (RVA) ImplFlagsImplFlags FlagsFlags NameName

(Zeigt auf Zeichenfolgenheap.)(Points to string heap.)
Signatur (Zeigt auf BLOB-Heap.)Signature (Points to blob heap.)
11 0x000020500x00002050 ILIL

VerwaltetManaged
ÖffentlichPublic

ReuseSlotReuseSlot

SpecialNameSpecialName

RTSpecialNameRTSpecialName

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

VerwaltetManaged
ÖffentlichPublic

StatischStatic

ReuseSlotReuseSlot
MainMain ZeichenfolgeString
33 0x0000208c0x0000208c ILIL

VerwaltetManaged
ÖffentlichPublic

StatischStatic

ReuseSlotReuseSlot
HinzufügenAdd int, int, intint, int, int

Jede Spalte der Tabelle enthält wichtige Informationen über Ihren Code.Each column of the table contains important information about your code. Über die RVA-Spalte kann die Runtime die Startspeicheradresse der MSIL berechnen, die diese Methode definiert.The RVA column allows the runtime to calculate the starting memory address of the MSIL that defines this method. Die ImplFlags-Spalte und die Flags-Spalte enthalten Bitmasken, welche die Methode beschreiben (z.B., ob es sich um eine öffentliche oder eine private Methode handelt).The ImplFlags and Flags columns contain bitmasks that describe the method (for example, whether the method is public or private). Die Name-Spalte gibt den Namen der Methode aus dem String-Heap an.The Name column indexes the name of the method from the string heap. Die Spalte Signatur gibt die Definition der Signatur der Methode im BLOB-Heap an.The Signature column indexes the definition of the method's signature in the blob heap.

Die Runtime berechnet die gewünschte Offset-Adresse aus der RVA-Spalte in der dritten Zeile und gibt diese Adresse an den JIT-Compiler zurück, der anschließend zur neuen Adresse übergeht.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. Der JIT-Compiler fährt mit der Verarbeitung der MSIL an der neuen Adresse fort, bis er erneut auf ein Metadatentoken trifft und der Prozess wiederholt wird.The JIT compiler continues to process MSIL at the new address until it encounters another metadata token and the process is repeated.

Mithilfe von Metadaten stehen Common Language Runtime alle Informationen zur Verfügung, die benötigt werden, um den Code zu laden und in systemeigene Maschinenanweisungen zu verarbeiten.Using metadata, the runtime has access to all the information it needs to load your code and process it into native machine instructions. Auf diese Weise bilden Metadaten selbstbeschreibende Dateien und ermöglichen zusammen mit dem allgemeinen Typsystem sprachübergreifende Vererbung.In this manner, metadata enables self-describing files and, together with the common type system, cross-language inheritance.

TitelTitle BeschreibungDescription
AttributeAttributes Beschreibt, wie Attribute angewendet, benutzerdefinierte Attribute geschrieben und in Attributen gespeicherte Informationen abgerufen werden.Describes how to apply attributes, write custom attributes, and retrieve information that is stored in attributes.