System.Type.GetType-metoder

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) Använd metodens överlagring och tillhörande överlagringar (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) och GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) för att ersätta standardimplementeringen GetType av metoden med mer flexibla implementeringar. Genom att ange egna metoder som löser typnamn och namnen på de sammansättningar som innehåller dem kan du göra följande:

• Kontrollera vilken version av en sammansättning som en typ läses in från.
• Ange en annan plats för att söka efter ett typnamn som inte innehåller ett sammansättningsnamn.
• Läs in sammansättningar med hjälp av partiella sammansättningsnamn.
• Returnera underklasser av System.Type som inte har skapats av Common Language Runtime (CLR).

I versionstolerant serialisering kan du till exempel söka efter en "best fit"-sammansättning med hjälp av ett partiellt namn. Andra överlagringar av GetType metoden kräver ett sammansättningskvalificerat typnamn, som innehåller versionsnumret.

Alternativa implementeringar av typsystemet kan behöva returnera underklasser av System.Type som inte har skapats av CLR. Alla typer som returneras av andra överlagringar av metoden GetType är runtime-typer.

Användningsanteckningar

Den här metoden och dess associerade överbelastningar parsar typeName till namnet på en typ och namnet på en samling, och löser därefter namnen. Lösning av assemblynamnet sker innan lösningen av typnamnet, eftersom ett typnamn måste lösas inom kontexten av en assembly.

Om typeName inte är ett sammansättningskvalificerat namn, utlämnas lösningen av sammansättningen. Okvalificerade typnamn kan lösas i samband med mscorlib.dll/System.Private.CoreLib.dll eller den löpande sammansättningen, eller så kan du ange en sammansättning i parametern typeResolver . Effekterna av att inkludera eller utelämna sammansättningsnamnet för olika typer av namnmatchning visas som en tabell i avsnittet Mixad namnmatchning .

Allmänna användningsanteckningar:

• Skicka inte metoder till assemblyResolver eller typeResolver om de kommer från okända eller obetrodda uppringare. Använd endast metoder som du anger eller som du är bekant med.

  Försiktighet

  Om du använder metoder från okända eller ej betrodda anropare kan det leda till utökade privilegier för skadlig kod.

• Om du utelämnar parametrarna assemblyResolver och/eller typeResolver skickas värdet för parametern throwOnError till de metoder som utför standardmatchningen.

• Om throwOnError är truegenererar den här metoden en TypeLoadException när typeResolver returnerar null, och en FileNotFoundException när assemblyResolver returnerar null.

• Den här metoden fångar inte undantag som genereras av assemblyResolver och typeResolver. Du ansvarar för alla undantag som genereras av matchningsmetoderna.

Lös sammansättningar

Metoden assemblyResolver tar emot ett AssemblyName objekt som skapas genom att parsa strängsammansättningens namn som ingår i typeName. Om typeName inte innehåller ett sammansättningsnamn assemblyResolver anropas inte och null skickas till typeResolver.

Om assemblyResolver inte anges används standardsammansättningssökning för att hitta sammansättningen. Om assemblyResolver anges utför GetType-metoden inte standardsökning. Därför måste du säkerställa att ditt assemblyResolver kan hantera alla assembly-filer som du skickar till den.

assemblyResolver-metoden bör returnera null om assemblyn inte kan lösas. Om assemblyResolver returnerar null, typeResolver anropas inte, och ingen ytterligare bearbetning sker; dessutom, om throwOnError är true, kastas en FileNotFoundException.

Om det AssemblyName som skickas till assemblyResolver är ett partiellt namn är nullen eller flera av dess delar . Om den till exempel inte har någon version är Version egenskapen null. Om egenskapen Version, egenskapen CultureInfo och metoden GetPublicKeyToken alla returnerar null, returneras endast det enkla namnet på sammansättningen. Metoden assemblyResolver kan använda eller ignorera alla delar av sammansättningsnamnet.

Effekterna av olika alternativ för sammansättningslösning visas som en tabell i avsnittet Blandad namnlösning, för enkla och sammansättningskvalificerade typnamn.

Lösa typer

Om typeName inte anger ett sammansättningsnamn typeResolver anropas alltid. Om typeName anger ett sammansättningsnamn typeResolver anropas endast när sammansättningsnamnet har lösts. Om assemblyResolver eller standard avsökning av sammansättning returnerar null, anropas typeResolver inte.

Metoden typeResolver tar emot tre argument:

• Sammansättningen som ska sökas eller null om typeName inte innehåller ett namn för en sammansättning.
• Det enkla namnet på typen. När det gäller en kapslad typ är detta den yttersta innehållstypen. När det gäller en allmän typ är detta det enkla namnet på den generiska typen.
• Ett booleskt värde som är true om fallet med typnamn ska ignoreras.

Implementeringen avgör hur dessa argument används. Metoden typeResolver bör returnera null om den inte kan lösa typen. Om typeResolver returnerar null och throwOnError är true, genererar GetType en TypeLoadException.

Effekterna av olika alternativ för typlösning visas som en tabell i avsnittet Blandad namnlösning för enkla och sammansättningskvalificerade typnamn.

Lösa upp kapslade typer

Om typeName är en kapslad typ skickas endast namnet på den yttersta innehållande typen till typeResolver. När typeResolver returnerar den här typen GetNestedType anropas metoden rekursivt tills den innersta kapslade typen har lösts.

Lösa allmänna typer

GetType Kallas rekursivt för att lösa generiska typer: Först för att lösa själva den generiska typen och sedan för att lösa dess typargument. Om ett typargument är generiskt GetType anropas rekursivt för att lösa dess typargument och så vidare.

Kombinationen av assemblyResolver och typeResolver som du anger måste kunna matcha alla nivåer av den här rekursionen. Anta till exempel att du anger en assemblyResolver som styr inläsningen av MyAssembly. Anta att du vill lösa den allmänna typen Dictionary<string, MyType> (Dictionary(Of String, MyType) i Visual Basic). Du kan skicka följande generiska typnamn:

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

Observera att MyType är det enda argumentet för en sammansättningskvalificerad typ. Namnen på klasserna Dictionary<TKey,TValue> och String är inte sammansättningskvalificerade. Du typeResolver måste kunna hantera antingen en sammansättning eller null, eftersom den kommer att ta emot null för Dictionary<TKey,TValue> och String. Den kan hantera det fallet genom att anropa en överlagring av metoden GetType som tar en sträng, eftersom båda de okvalificerade typnamnen finns i mscorlib.dll/System.Private.CoreLib.dll:

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))

Metoden assemblyResolver anropas inte för ordlistetypen och strängtypen eftersom dessa typnamn inte är sammansättningskvalificerade.

Anta nu att i stället för System.Stringär YourTypeden första generiska argumenttypen , från YourAssembly:

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

Eftersom den här sammansättningen varken är mscorlib.dll/System.Private.CoreLib.dll eller den löpande sammansättningen kan du inte lösa YourType det utan ett sammansättningskvalificerat namn. Eftersom ditt assemblyResolve kommer att anropas rekursivt måste det kunna hantera det här fallet. I stället för att null returnera för andra sammansättningar än MyAssemblyutför den nu en sammansättningsbelastning med hjälp av det angivna AssemblyName objektet.

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)

Lösa typnamn med specialtecken

Vissa tecken har särskilda betydelser i sammansättningskvalificerade namn. Om ett enkelt typnamn innehåller dessa tecken orsakar tecknen parsningsfel när det enkla namnet ingår i ett sammansättningskvalificerat namn. För att undvika parsningsfel måste du undvika specialtecken med ett omvänt snedstreck innan du kan skicka det sammansättningskvalificerade namnet till GetType metoden. Om en typ till exempel heter Strange]Typemåste escape-tecknet läggas till före hakparentesen på följande sätt: Strange\]Type.

I följande tabell visas specialtecken för typnamn.

Egenskaper som AssemblyQualifiedName att returnera korrekt undantagna strängar. Du måste skicka korrekt undantagna strängar till GetType metoden. Metoden skickar i sin tur GetType korrekt undantagna namn till typeResolver och till standardtypmatchningsmetoderna. Om du behöver jämföra ett namn med ett namn utan escape-tecken i typeResolver, måste du ta bort escape-tecken.

Lösning för blandat namn

I följande tabell sammanfattas interaktionerna mellan assemblyResolver, typeResolveroch standardnamnmatchningen för alla kombinationer av typnamn och sammansättningsnamn i typeName: