Freigeben über

System.Type.GetType-Methoden

  • Artikel

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Verwenden Sie die GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) Methodenüberladung und die damit verbundenen Überladungen (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) und GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) um die Standardimplementierung der GetType Methode durch flexiblere Implementierungen zu ersetzen. Indem Sie eigene Methoden bereitstellen, mit denen Typnamen und die Namen der Assemblys aufgelöst werden, die sie enthalten, können Sie die folgenden Aktionen ausführen:

  • Steuern Sie, aus welcher Version einer Assembly ein Typ geladen wird.
  • Geben Sie einen anderen Ort an, um nach einem Typnamen zu suchen, der keinen Assemblynamen enthält.
  • Laden Von Assemblys mit partiellen Assemblynamen.
  • Gibt Unterklassen zurück, die System.Type nicht von der Common Language Runtime (CLR) erstellt werden.

In der versionstoleranten Serialisierung können Sie z. B. mithilfe eines Teilnamens nach einer "am besten geeigneten" Assembly suchen. Andere Überladungen der GetType Methode erfordern einen assemblyqualifizierten Typnamen, der die Versionsnummer enthält.

Alternative Implementierungen des Typsystems müssen möglicherweise Unterklassen zurückgeben, die System.Type nicht vom CLR erstellt werden. Alle Typen, die von anderen Überladungen der GetType Methode zurückgegeben werden, sind Laufzeittypen.

Hinweise zur Verwendung

Diese Methodenüberladung und die zugehörigen Überladungen analysieren typeName den Namen eines Typs und den Namen einer Assembly, und lösen Sie dann die Namen auf. Die Auflösung des Assemblynamens erfolgt vor der Auflösung des Typnamens, da ein Typname im Kontext einer Assembly aufgelöst werden muss.

Hinweis

Wenn Sie mit dem Konzept von assemblyqualifizierten Typnamen nicht vertraut sind, lesen Sie die AssemblyQualifiedName Eigenschaft.

Wenn typeName es sich nicht um einen assemblyqualifizierten Namen handelt, wird die Assemblyauflösung übersprungen. Nicht qualifizierte Typnamen können im Kontext von mscorlib.dll/System.Private.CoreLib.dll oder der derzeit ausgeführten Assembly aufgelöst werden, oder Sie können optional eine Assembly im typeResolver Parameter bereitstellen. Die Auswirkungen des Einschließens oder Weglassens des Assemblynamens für verschiedene Arten der Namensauflösung werden als Tabelle im Abschnitt "Gemischte Namensauflösung " angezeigt.

Allgemeine Nutzungshinweise:

  • Übergeben Sie keine Methoden an assemblyResolver oder typeResolver wenn sie von unbekannten oder nicht vertrauenswürdigen Aufrufen stammen. Verwenden Sie nur Methoden, die Sie bereitstellen oder mit denen Sie vertraut sind.

    Achtung

    Die Verwendung von Methoden von unbekannten oder nicht vertrauenswürdigen Aufrufen kann zu einer Erhöhung der Rechte für bösartigen Code führen.

  • Wenn Sie die assemblyResolver Und/oder typeResolver Parameter weglassen, wird der Wert des throwOnError Parameters an die Methoden übergeben, die die Standardauflösung ausführen.

  • Wenn throwOnError dies der Fall ist true, löst diese Methode ein TypeLoadException , wenn typeResolver zurückgegeben nullwird, und ein FileNotFoundException , wenn assemblyResolver zurückgegeben nullwird.

  • Mit dieser Methode werden keine Ausnahmen erfasst, die von assemblyResolver und typeResolver. Sie sind für alle Ausnahmen verantwortlich, die von den Resolver-Methoden ausgelöst werden.

Auflösen von Assemblys

Die assemblyResolver Methode empfängt ein AssemblyName Objekt, das durch analysieren des Zeichenfolgenassemblynamens erzeugt wird, der in typeNameenthalten ist. Wenn typeName kein Assemblyname enthalten ist, assemblyResolver wird er nicht aufgerufen und null an typeResolver.

Wenn assemblyResolver nicht angegeben, wird die Standardassembly-Probing verwendet, um die Assembly zu finden. Wenn assemblyResolver die Methode bereitgestellt wird, führt die GetType Methode keine Standardmäßige Überprüfung durch. In diesem Fall müssen Sie sicherstellen, dass alle assemblyResolver Assemblys verarbeitet werden können, die Sie an sie übergeben.

Die assemblyResolver Methode sollte zurückgegeben null werden, wenn die Assembly nicht aufgelöst werden kann. Wenn assemblyResolver zurückgegeben nullwird , typeResolver wird nicht aufgerufen, und es erfolgt keine weitere Verarbeitung, wenn throwOnError dies der Fall ist true, wird eine FileNotFoundException ausgelöst.

Wenn das AssemblyName übergeben assemblyResolver wird, ist ein Teilname, eine oder mehrere teile sind null. Wenn sie z. B. keine Version aufweist, lautet nulldie Version Eigenschaft . Wenn die Version Eigenschaft, die CultureInfo Eigenschaft und die GetPublicKeyToken Methode alle zurückgegeben nullwerden, wurde nur der einfache Name der Assembly angegeben. Die assemblyResolver Methode kann alle Teile des Assemblynamens verwenden oder ignorieren.

Die Effekte verschiedener Assemblyauflösungsoptionen werden als Tabelle im Abschnitt "Gemischte Namensauflösung " für einfache und assemblyqualifizierte Typennamen angezeigt.

Auflösen von Typen

Wenn typeName kein Assemblyname angegeben wird, typeResolver wird immer aufgerufen. Wenn typeName ein Assemblyname angegeben wird, wird nur aufgerufen, typeResolver wenn der Assemblyname erfolgreich aufgelöst wird. Wenn assemblyResolver oder Die Standardassembly-Probing zurückgegeben nullwird, typeResolver wird nicht aufgerufen.

Die typeResolver Methode empfängt drei Argumente:

  • Die zu durchsuchende Assembly oder null wenn typeName sie keinen Assemblynamen enthält.
  • Der einfache Name des Typs. Bei einem geschachtelten Typ ist dies der äußerste enthaltende Typ. Im Fall eines generischen Typs ist dies der einfache Name des generischen Typs.
  • Ein boolescher Wert, der angibt, true ob die Groß-/Kleinschreibung von Typnamen ignoriert werden soll.

Die Implementierung bestimmt, wie diese Argumente verwendet werden. Die typeResolver Methode sollte zurückgegeben werden null , wenn der Typ nicht aufgelöst werden kann. Wenn typeResolver diese null Überladung zurückgegeben wird und throwOnError ist true, löst diese Überladung ein GetTypeTypeLoadException.

Die Effekte verschiedener Typenauflösungsoptionen werden als Tabelle im Abschnitt "Gemischte Namensauflösung " für einfache und assemblyqualifizierte Typennamen angezeigt.

Auflösen geschachtelter Typen

Wenn typeName es sich um einen geschachtelten Typ handelt, wird nur der Name des äußersten typs übergeben.typeResolver Wenn typeResolver dieser Typ zurückgegeben wird, wird die GetNestedType Methode rekursiv aufgerufen, bis der innerste geschachtelte Typ aufgelöst wurde.

Auflösen generischer Typen

Dies GetType wird rekursiv aufgerufen, um generische Typen aufzulösen: Zuerst zum Auflösen des generischen Typs selbst und dann zum Auflösen der Typargumente. Wenn ein Typargument generisch ist, wird rekursiv aufgerufen, GetType um die Typargumente aufzulösen usw.

Die Kombination von assemblyResolver und typeResolver der bereitstellung muss in der Lage sein, alle Ebenen dieser Rekursion aufzulösen. Angenommen, Sie geben eine assemblyResolver , die das Laden von MyAssembly. Angenommen, Sie möchten den generischen Typ Dictionary<string, MyType> auflösen (Dictionary(Of String, MyType) in Visual Basic). Möglicherweise übergeben Sie den folgenden generischen Typnamen:

"System.Collections.Generic.Dictionary`2[System.String,[MyNamespace.MyType, MyAssembly]]"

Beachten Sie, dass es sich MyType um das einzige assemblyqualifizierte Typargument handelt. Die Namen und Dictionary<TKey,TValue>String Klassen sind nicht assemblyfähig. Sie typeResolver müssen in der Lage sein, entweder eine Assembly oder null, da sie empfangen null wird und Dictionary<TKey,TValue>String. Es kann diesen Fall behandeln, indem eine Überladung der Methode aufgerufen wird, die GetType eine Zeichenfolge akzeptiert, da sich beide nicht qualifizierten Typnamen in mscorlib.dll/System.Private.CoreLib.dll befinden:

Type t = Type.GetType(test,
                      (aName) => aName.Name == "MyAssembly" ?
                          Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") : null,
                      (assem, name, ignore) => assem == null ?
                          Type.GetType(name, false, ignore) :
                              assem.GetType(name, false, ignore)
                     );

let t =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else null),
        fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr))

Die assemblyResolver Methode wird nicht für den Wörterbuchtyp und den Zeichenfolgentyp aufgerufen, da diese Typnamen nicht assemblyfähig sind.

Angenommen, anstelle des System.Stringersten generischen Argumenttyps lautet YourType:YourAssembly

"System.Collections.Generic.Dictionary`2[[YourNamespace.YourType, YourAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], [MyNamespace.MyType, MyAssembly]]"

Da diese Assembly weder mscorlib.dll/System.Private.CoreLib.dll noch die derzeit ausgeführte Assembly ist, können Sie ohne assemblyqualifizierten Namen nicht auflösen YourType . Da Ihr assemblyResolve Vorgang rekursiv aufgerufen wird, muss er in der Lage sein, diesen Fall zu behandeln. null Statt für andere Assemblys als MyAssembly,, es führt jetzt eine Assemblylast mithilfe des angegebenen AssemblyName Objekts aus.

Type t2 = Type.GetType(test,
                       (aName) => aName.Name == "MyAssembly" ?
                           Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") :
                           Assembly.Load(aName),
                       (assem, name, ignore) => assem == null ?
                           Type.GetType(name, false, ignore) :
                               assem.GetType(name, false, ignore), true
                      );

let t2 =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else Assembly.Load aName),
        (fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr)), true)

Auflösen von Typnamen mit Sonderzeichen

Bestimmte Zeichen haben besondere Bedeutungen in assemblyqualifizierten Namen. Wenn ein einfacher Typname diese Zeichen enthält, verursachen die Zeichen Analysefehler, wenn der einfache Name Teil eines assemblyqualifizierten Namens ist. Um die Analysefehler zu vermeiden, müssen Sie die Sonderzeichen mit einem umgekehrten Schrägstrich escapen, bevor Sie den assemblyqualifizierten Namen an die GetType Methode übergeben können. Wenn beispielsweise ein Typ benannt Strange]Typeist, muss das Escapezeichen vor der eckigen Klammer wie folgt hinzugefügt werden: Strange\]Type

Hinweis

Namen mit solchen Sonderzeichen können in Visual Basic oder C# nicht erstellt werden, können aber mithilfe allgemeiner Zwischensprache (CIL) oder durch Senden dynamischer Assemblys erstellt werden.

In der folgenden Tabelle sind die Sonderzeichen für Typnamen aufgeführt.

Zeichen Bedeutung
, (Komma) Trennzeichen für assemblyqualifizierte Namen.
[] (eckige Klammern) Gibt als Suffixpaar einen Arraytyp an; als Trennzeichenpaar schließt generische Argumentlisten und assemblyqualifizierte Namen ein.
& (kaufmännisches Und-Zeichen) Gibt als Suffix an, dass ein Typ ein Verweistyp ist.
* (Sternchen) Gibt als Suffix an, dass ein Typ ein Zeigertyp ist.
+ (plus) Trennzeichen für geschachtelte Typen.
\ (umgekehrter Schrägstrich) Escapezeichen.

Eigenschaften wie AssemblyQualifiedName das Zurückgeben korrekter Escapezeichenfolgen. Sie müssen an die GetType Methode ordnungsgemäß escapede Zeichenfolgen übergeben. Die Methode übergibt wiederum GetType ordnungsgemäß Escapenamen an typeResolver und an die Standardmethoden für die Typauflösung. Wenn Sie einen Namen mit einem nicht gescapeten Namen typeResolververgleichen müssen, müssen Sie die Escapezeichen entfernen.

Auflösung gemischter Namen

In der folgenden Tabelle werden die Interaktionen zwischen assemblyResolver, , typeResolverund der Standardnamenauflösung für alle Kombinationen von Typname und Assemblyname in typeName:

Inhalt des Typnamens Assembly-Resolver-Methode Type Resolver-Methode Ergebnis
Typ, Assembly NULL NULL Entspricht dem Aufrufen der Type.GetType(String, Boolean, Boolean) Methodenüberladung.
Typ, Assembly bereitgestellter NULL assemblyResolver gibt die Assembly zurück oder gibt zurück null , wenn sie die Assembly nicht auflösen kann. Wenn die Assembly aufgelöst wird, wird die Assembly.GetType(String, Boolean, Boolean) Methodenüberladung verwendet, um den Typ aus der Assembly zu laden. Andernfalls wird kein Versuch unternommen, den Typ aufzulösen.
Typ, Assembly NULL bereitgestellter Entspricht dem Konvertieren des Assemblynamens in ein AssemblyName Objekt und aufrufen der Assembly.Load(AssemblyName) Methodenüberladung zum Abrufen der Assembly. Wenn die Assembly aufgelöst wird, wird sie an ; typeResolverandernfalls wird sie nicht aufgerufen, und es wird kein weiterer Versuch unternommen, typeResolver den Typ aufzulösen.
Typ, Assembly bereitgestellter bereitgestellter assemblyResolver gibt die Assembly zurück oder gibt zurück null , wenn sie die Assembly nicht auflösen kann. Wenn die Assembly aufgelöst wird, wird sie an ; typeResolverandernfalls wird sie nicht aufgerufen, und es wird kein weiterer Versuch unternommen, typeResolver den Typ aufzulösen.
Typ null, bereitgestellt NULL Entspricht dem Aufrufen der Type.GetType(String, Boolean, Boolean) Methodenüberladung. Da der Assemblyname nicht angegeben wird, werden nur mscorlib.dll/System.Private.CoreLib.dll und die derzeit ausgeführte Assembly durchsucht. Wenn assemblyResolver angegeben, wird sie ignoriert.
Typ null, bereitgestellt bereitgestellter typeResolver wird aufgerufen und null für die Assembly übergeben. typeResolver kann einen Typ aus jeder Assembly bereitstellen, einschließlich Assemblys, die es für den Zweck lädt. Wenn assemblyResolver angegeben, wird sie ignoriert.
assembly null, bereitgestellt null, bereitgestellt Ein FileLoadException Fehler wird ausgelöst, da der Assemblyname analysiert wird, als ob es sich um einen assemblyqualifizierten Typnamen handelt. Dies führt zu einem ungültigen Assemblynamen.