Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Angeben vollständig gekennzeichneter Typnamen

 

Gültige Eingaben für eine Reihe von Reflektionsoperationen erfordern die spezifische Angabe von Typnamen. Ein vollständig qualifizierter Typname besteht aus der Angabe eines Assemblynamens, der Festlegung eines Namespaces und einem Typnamen. Angaben von Typnamen werden von Methoden wie Type.GetType, Module.GetType, ModuleBuilder.GetType und Assembly.GetType verwendet.

Die Backus-Naur-Form (BNF) definiert die Syntax formaler Sprachen. Die folgende Tabelle gibt führt die lexikalischen BNF-Regeln auf, durch die das Erkennen einer gültigen Eingabe beschrieben wird. Terminale (nicht weiter reduzierbare Sprachelemente) werden in Großbuchstaben dargestellt. Nicht-Terminale (weiter reduzierbare Elemente) werden in gemischter Groß-/Kleinschreibung oder als Zeichenfolgen dargestellt, die in einfache Anführungszeichen eingeschlossen sind (die einfachen Anführungszeichen gehören nicht zur Syntax). Das Pipezeichen (|) kennzeichnet Regeln, die über untergeordnete Regeln verfügen.

BNF-Grammatik für vollständig qualifizierte Typnamen

TypeSpec                          :=   ReferenceTypeSpec

                                        |     SimpleTypeSpec

ReferenceTypeSpec: = SimpleTypeSpec '&'

SimpleTypeSpec                :=   PointerTypeSpec

                                        |     ArrayTypeSpec

                                        |     TypeName

PointerTypeSpec                :=   SimpleTypeSpec '*'

ArrayTypeSpec                  :=   SimpleTypeSpec '[ReflectionDimension]'

                                        |     SimpleTypeSpec '[ReflectionEmitDimension]'

ReflectionDimension           :=   '*'

                                        |     ReflectionDimension ',' ReflectionDimension

                                        |     NOTOKEN

ReflectionEmitDimension    :=   '*'

                                        |     Number '..' Zahl

                                        |     Number '...'

                                        |     ReflectionDimension ',' ReflectionDimension

                                        |     NOTOKEN

Number                            :=   [0-9]+

TypeName                         :=   NamespaceTypeName

                                        |     NamespaceTypeName ',' AssemblyNameSpec

NamespaceTypeName        :=   NestedTypeName

                                        |     NamespaceSpec '.' NestedTypeName

NestedTypeName               :=   IDENTIFIER

                                        |     NestedTypeName '+' IDENTIFIER

NamespaceSpec                 :=   IDENTIFIER

                                        |     NamespaceSpec '.' IDENTIFIER

AssemblyNameSpec           :=   IDENTIFIER

                                        |     IDENTIFIER ',' AssemblyProperties

AssemblyProperties            :=   AssemblyProperty

                                        |     AssemblyProperties ',' AssemblyProperty

AssemblyProperty              :=   AssemblyPropertyName '=' AssemblyPropertyValue

In einem Typennamen ist ein IDENTIFIER jeder von den Regeln einer Sprache als gültig erkannter Name.

Der umgekehrte Schrägstrich dient als Escapezeichen, um folgende Tokens zu trennen, wenn diese innerhalb eines IDENTIFIER verwendet werden.

Token

Bedeutung

\,

Assemblytrennzeichen.

\+

Trennzeichen für geschachtelte Typen.

\&

Referenztyp.

\*

Zeigertyp.

\[

Begrenzungszeichen eines Arrays.

\]

Begrenzungszeichen eines Arrays.

\.

Der umgekehrte Schrägstrich vor einem Punkt wird nur verwendet, wenn der Punkt innerhalb einer Arraybezeichnung auftritt. Punkte in NamespaceSpec erhalten keinen umgekehrten Schrägstrich.

\\

Umgekehrter Schrägstrich als Literal.

Beachten Sie, dass Leerräume in allen TypeSpec-Komponenten mit Ausnahme von AssemblyNameSpec relevant sind. Leerräume in AssemblyNameSpec sind nur vor dem Trennzeichen "," relevant, dahinter werden sie ignoriert.

Reflektionsklassen, z. B. Type.FullName, geben den zerlegten Namen zurück, sodass dieser in Aufrufen von GetType verwendet werden kann, wie in MyType.GetType(myType.FullName).

Ein Beispiel für einen vollständig qualifizierten Typnamen ist Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.

Wäre der Namespace Ozzy.Out+Back, müsste dem Pluszeichen ein umgekehrter Schrägstrich vorangestellt werden. Andernfalls würde es vom Parser als Schachtelungstrennzeichen interpretiert werden. Durch Reflektion wird diese Zeichenfolge zu Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Zur Festlegung eines Assemblynamens ist als Mindestangabe der wörtliche Name (IDENTIFIER) der Assembly erforderlich. Dem IDENTIFIER kann eine durch Trennzeichen getrennte Auflistung von Eigenschaft/Wert-Paaren angefügt werden, wie in der folgenden Tabelle beschrieben: Namen für IDENTIFIER sollten nach denselben Regeln wie Dateinamen vergeben werden. Bei einem IDENTIFIER wird zwischen Groß-/Kleinschreibung unterschieden.

Name der Eigenschaft

Beschreibung

Gültige Werte

Version

Versionsnummer der Assembly

Major.Minor.Build.Revision, (Major, Minor, Build und Revision sind ganze Zahlen von 0 bis einschließlich 65535).

PublicKey

Vollständiger öffentlicher Schlüssel

Zeichenfolgenwert eines vollständigen öffentlichen Schlüssels im Hexadezimalformat. Geben Sie einen NULL-Verweis (Nothing in Visual Basic) an, um eine Assembly explizit als privat zu kennzeichnen.

PublicKeyToken

Token eines öffentlichen Schlüssels (8-Byte-Hash des vollständigen öffentlichen Schlüssels)

Zeichenfolgenwert eines öffentlichen Schlüsseltokens im Hexadezimalformat. Geben Sie einen NULL-Verweis (Nothing in Visual Basic) an, um eine Assembly explizit als privat zu kennzeichnen.

Kultur

Kultur der Assembly

Kultur der Assembly im RFC-1766-Format bzw. "neutral" für sprachenunabhängige Assemblys (d. h. keine Satellitenassemblys).

Benutzerdefiniert

Benutzerdefiniertes Binary Large Object (BLOB). Derzeit wird dies nur von Assemblys verwendet, die mit dem Native Image Generator-Tool (NGEN) generiert wurden.

Benutzerdefinierte Zeichenfolge, die vom Native Image Generator-Tool (NGEN) verwendet wird, um den Assemblycache zu benachrichtigen, dass die Assembly ein systemeigenes Bild und somit im systemeigenen Cache zu installieren ist. Wird auch Zap-Zeichenfolge genannt.

Im folgenden Beispiel wird ein AssemblyName für eine einfach benannte Assembly mit Standardkultur angegeben.

com.microsoft.crypto, Culture="" 

Im folgenden Beispiel wird ein vollständiger Verweis auf eine Assembly mit starkem Namen und der Kultur "en" gegeben.

com.microsoft.crypto, Culture=en, PublicKeyToken=a5d015c7d5a0b012,
    Version=1.0.0.0 

In den folgenden Beispielen wird jeweils ein teilweise spezifizierter AssemblyName angegeben, dem entweder eine Assembly mit einfachem oder mit starkem Namen entspricht.

com.microsoft.crypto
com.microsoft.crypto, Culture=""
com.microsoft.crypto, Culture=en 

In den folgenden Beispielen wird jeweils ein teilweise spezifizierter AssemblyName angegeben, dem nur eine Assembly mit einfachem Namen entspricht.

com.microsoft.crypto, Culture="", PublicKeyToken=null 
com.microsoft.crypto, Culture=en, PublicKeyToken=null

In den folgenden Beispielen wird jeweils ein teilweise spezifizierter AssemblyName angegeben, dem nur eine Assembly mit starkem Namen entspricht.

com.microsoft.crypto, Culture="", PublicKeyToken=a5d015c7d5a0b012
com.microsoft.crypto, Culture=en, PublicKeyToken=a5d015c7d5a0b012,
    Version=1.0.0.0

SimpleTypeSpec* stellt einen nicht verwalteten Zeiger dar. Ein Beispiel: Um einen Zeiger auf den Typ MyType zu definieren, verwenden Sie Type.GetType("MyType*"). Um einen Zeiger auf diesen Zeiger (d. h. den Zeiger auf den Typ MyType) zu definieren, verwenden Sie Type.GetType("MyType**").

SimpleTypeSpec & stellt einen verwalteten Zeiger oder einen Verweis dar. Ein Beispiel: Um einen Verweis auf den Typ MyType zu definieren, verwenden Sie Type.GetType("MyType &"). Im Gegensatz zu Zeigern sind Verweise auf eine Ebene beschränkt.

Gemäß der BNF-Grammatik wird ReflectionEmitDimension nur auf unvollständige Typdefinitionen angewendet, die über ModuleBuilder.GetType abgerufen werden. Unvollständige Typdefinitionen sind TypeBuilder-Objekte, die mit Reflection.Emit erstellt wurden, für die TypeBuilder.CreateType aber nicht aufgerufen wurde. Mit ReflectionDimension kann jede Typdefinition abgerufen werden, die vervollständigt wurde, d. h. ein Typ, der geladen wurde.

Bei der Reflektion wird auf Arrays zugegriffen, indem der Rang des Arrays angegeben wird:

  • Type.GetType("MyArray[]") definiert ein eindimensionales Array mit der Untergrenze 0.

  • Type.GetType("MyArray[*]") definiert ein eindimensionales Array mit unbekannter Untergrenze.

  • Type.GetType("MyArray[][]") definiert das Array eines zweidimensionalen Arrays.

  • Type.GetType("MyArray[*,*]") definiert ein rechteckiges, zweidimensionales Array mit unbekannten Untergrenzen.

Beachten Sie, dass aus Sicht der Common Language Runtime MyArray[] != MyArray[*] gilt. Für mehrdimensionale Arrays sind beide Notationen äquivalent. Dies bedeutet, dass der Ausdruck Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") als true bewertet wird.

ModuleBuilder.GetType interpretiert MyArray[0..5] als eindimensionales Array der Länge 6 mit der Untergrenze 0 und MyArray[4…] als eindimensionales Array unbekannter Größe mit der Untergrenze 4.

Anzeigen: