Métodos System.Type.GetType

Use a GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) sobrecarga de método e suas sobrecargas associadas (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) e GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) para substituir a GetType implementação padrão do método por implementações mais flexíveis. Ao fornecer seus próprios métodos que resolvem nomes de tipo e os nomes dos assemblies que os contêm, você pode fazer o seguinte:

• Controle a partir de qual versão de um assembly um tipo é carregado.
• Indique outro local para procurar um nome de tipo que não inclua um nome de assembly.
• Carregue assemblagens usando nomes parciais de assemblagens.
• Retornar subclasses de System.Type que não são criadas pelo Common Language Runtime (CLR).

Por exemplo, na serialização tolerante a versões, este método permite que procure um assembly que melhor se ajuste usando um nome parcial. Outras sobrecargas do GetType método exigem um nome de tipo qualificado para assembly, que inclui o número da versão.

Implementações alternativas do sistema de tipos podem precisar retornar subclasses de System.Type que não são criadas pelo CLR; todos os tipos que são retornados por outras sobrecargas do método GetType são tipos de tempo de execução.

Notas de utilização

Essa sobrecarga de método e suas sobrecargas associadas analisam typeName para transformá-lo no nome de um tipo e no nome de um assembly, e em seguida, resolvem os nomes. A resolução do nome do assembly ocorre antes da resolução do nome do tipo, porque um nome de tipo deve ser resolvido no contexto de um assembly.

Se typeName não for um nome qualificado para assembly, a resolução do assembly será ignorada. Nomes de tipo não qualificados podem ser resolvidos no contexto de mscorlib.dll/System.Private.CoreLib.dll ou do assembly em execução no momento. Opcionalmente, pode fornecer um assembly no parâmetro typeResolver. Os efeitos de incluir ou omitir o nome do assembly para diferentes tipos de resolução de nome são apresentados em forma de tabela na seção Resolução de nome Misturado.

Notas gerais de uso:

• Não passe métodos para assemblyResolver ou typeResolver se eles vierem de chamadores desconhecidos ou não confiáveis. Use apenas os métodos fornecidos ou com os quais esteja familiarizado.

  Atenção

  O uso de métodos de chamadores desconhecidos ou não confiáveis pode resultar na elevação de privilégio para código mal-intencionado.

• Se omitir os parâmetros assemblyResolver e/ou typeResolver, o valor do parâmetro throwOnError será passado para os métodos que executam a resolução padrão.

• Se throwOnError for true, esse método lança um TypeLoadException quando typeResolver retorna null e um FileNotFoundException quando assemblyResolver retorna null.

• Este método não captura exceções lançadas por assemblyResolver e typeResolver. Você é responsável por quaisquer exceções lançadas pelos métodos do resolvedor.

Resolver assemblies

O assemblyResolver método recebe um AssemblyName objeto, que é produzido analisando o nome do assembly da cadeia de caracteres incluída no typeName. Se typeName não contiver um nome de assembly, assemblyResolver não é chamado e null é passado para typeResolver.

Se assemblyResolver não for fornecida, a sondagem de montagem padrão é usada para localizar a montagem. Se assemblyResolver for fornecido, o método GetType não faz sondagem padrão; nesse caso, deve garantir que o seu assemblyResolver pode lidar com todos os conjuntos que lhe passa.

O assemblyResolver método deve retornar null se o assembly não puder ser resolvido. Se assemblyResolver retorna null, typeResolver não é chamado e nenhum processamento adicional ocorre, adicionalmente, se throwOnError é true, um FileNotFoundException é lançado.

Se o AssemblyName que é passado para assemblyResolver é um nome parcial, uma ou mais de suas partes são null. Por exemplo, se não tiver versão, a Version propriedade é null. Se a Version propriedade, a CultureInfo propriedade e o GetPublicKeyToken método retornarem null, somente o nome simples do assembly foi fornecido. O assemblyResolver método pode usar ou ignorar todas as partes do nome do assembly.

Os efeitos de diferentes opções de resolução de assembly são exibidos como uma tabela na seção Resolução de nomes mistos, para nomes de tipo simples e qualificados para uma assembly.

Tipos de resolução

Se typeName não especificar um nome de assembly, typeResolver será sempre chamado. Se typeName especificar um nome de assembly, typeResolver será chamado somente quando o nome de assembly for resolvido com êxito. Se assemblyResolver ou a sondagem de montagem padrão retorna null, typeResolver não é chamada.

O typeResolver método recebe três argumentos:

• O conjunto a ser pesquisado ou null se typeName não contém um nome de conjunto.
• O nome simples do tipo. No caso de um tipo aninhado, este é o tipo contido mais externo. No caso de um tipo genérico, este é o nome simples do tipo genérico.
• Um valor booleano que é true se o caso de nomes de tipo deve ser ignorado.

A implementação determina a forma como esses argumentos são usados. O typeResolver método deve retornar null se não puder resolver o tipo. Se typeResolver retorna null e throwOnError é true, essa sobrecarga de GetType lança um TypeLoadException.

Os efeitos de diferentes opções de resolução de tipo são apresentados em forma de tabela na seção Resolução de nomes mistos, para nomes de tipo simples e qualificados por assembly.

Resolver tipos aninhados

Se typeName for um tipo aninhado, somente o nome do tipo mais externo será passado para typeResolver. Quando typeResolver retorna este tipo, o método GetNestedType é chamado recursivamente até que o tipo aninhado mais interno tenha sido resolvido.

Resolver tipos genéricos

O GetType é chamado recursivamente para resolver tipos genéricos: Primeiro para resolver o próprio tipo genérico e, em seguida, para resolver seus argumentos de tipo. Se um argumento de tipo é genérico, GetType é chamado recursivamente para resolver seus argumentos de tipo, e assim por diante.

A combinação de assemblyResolver e typeResolver que você fornece deve ser capaz de resolver todos os níveis dessa recursão. Por exemplo, suponha que você forneça um assemblyResolver que controle o carregamento do MyAssembly. Suponha que você queira resolver o tipo Dictionary<string, MyType> genérico (Dictionary(Of String, MyType) no Visual Basic). Você pode passar o seguinte nome de tipo genérico:

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

Observe que MyType é o único argumento de tipo qualificado de assembly. Os nomes das Dictionary<TKey,TValue> classes e String não são qualificados para montagem. O seu typeResolver deve ser capaz de lidar com uma montagem ou null, porque receberá null para Dictionary<TKey,TValue> e String. Ele pode lidar com esse caso chamando uma sobrecarga do método GetType que aceita uma cadeia de caracteres, porque ambos os nomes de tipo não qualificados estão em 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))

O assemblyResolver método não é chamado para o tipo de dicionário e o tipo de cadeia de caracteres, porque esses nomes de tipo não são qualificados para assembly.

Suponha agora que, em vez de System.String, o primeiro tipo de argumento genérico seja YourType, de YourAssembly:

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

Como esse assembly não é mscorlib.dll/System.Private.CoreLib.dll nem o assembly em execução no momento, você não pode resolver YourType sem um nome qualificado para assembly. Porque a sua assemblyResolve será chamada recursivamente, ela deve ser capaz de lidar com este caso. Em vez de retornar null para assemblies diferentes do MyAssembly, ele agora executa uma carga de assembly usando o objeto fornecido AssemblyName .

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)

Resolver nomes de tipo com caracteres especiais

Certos caracteres têm significados especiais em nomes qualificados para montagem. Se um nome de tipo simples contiver esses caracteres, os caracteres causarão erros de análise quando o nome simples fizer parte de um nome qualificado para assembly. Para evitar os erros de análise, você deve escapar dos caracteres especiais com uma barra invertida antes de poder passar o nome qualificado do assembly para o GetType método. Por exemplo, se um tipo for nomeado Strange]Type, o caractere de escape deve ser adicionado à frente do colchete da seguinte maneira: Strange\]Type.

A tabela a seguir mostra os caracteres especiais para nomes de tipo.

Propriedades como AssemblyQualifiedName retornam cadeias de caracteres com escape correto. Você deve passar corretamente cadeias de caracteres com escape para o GetType método. Por sua vez, o GetType método passa corretamente nomes com escape para typeResolver e para os métodos de resolução de tipo padrão. Se você precisar comparar um nome com um nome sem escape no typeResolver, deverá remover os caracteres de escape.

Resolução de nomes mistos

A tabela a seguir resume as interações entre assemblyResolver, typeResolver, e a resolução de nome padrão, para todas as combinações de nome de tipo e nome de assembly em typeName: