Métodos System.Type.GetType

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

Use la sobrecarga del GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) método y sus sobrecargas asociadas (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) y GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) para reemplazar la implementación predeterminada del GetType método por implementaciones más flexibles. Al proporcionar sus propios métodos que resuelven los nombres de tipo y los nombres de los ensamblados que los contienen, puede hacer lo siguiente:

• Controlar desde qué versión de un ensamblado se carga un tipo.
• Proporcione otro lugar para buscar un nombre de tipo que no incluya un nombre de ensamblado.
• Cargar ensamblados mediante nombres de ensamblado parcial.
• Devuelve subclases de System.Type que common Language Runtime (CLR) no crea.

Por ejemplo, en la serialización tolerante a versiones, este método permite buscar un ensamblado de "mejor ajuste" mediante un nombre parcial. Otras sobrecargas del GetType método requieren un nombre de tipo calificado para ensamblados, que incluye el número de versión.

Es posible que las implementaciones alternativas del sistema de tipos necesiten devolver subclases de System.Type que clR no crea; todos los tipos devueltos por otras sobrecargas del GetType método son tipos en tiempo de ejecución.

Notas de uso

Esta sobrecarga del método y sus sobrecargas asociadas analizan typeName en el nombre de un tipo y el nombre de un ensamblado y, a continuación, resuelven los nombres. La resolución del nombre del ensamblado se produce antes de la resolución del nombre de tipo, ya que un nombre de tipo debe resolverse en el contexto de un ensamblado.

Si typeName no es un nombre completo para ensamblados, se omite la resolución de ensamblados. Los nombres de tipo no calificados se pueden resolver en el contexto de mscorlib.dll/System.Private.CoreLib.dll o el ensamblado que se está ejecutando actualmente, o puede proporcionar opcionalmente un ensamblado en el typeResolver parámetro . Los efectos de incluir o omitir el nombre del ensamblado para diferentes tipos de resolución de nombres se muestran como una tabla en la sección Resolución de nombres mixtos.

Notas de uso general:

• No pase métodos a assemblyResolver o typeResolver si proceden de autores de llamadas desconocidos o que no son de confianza. Use solo los métodos que proporciona o con los que está familiarizado.

  Precaución

  El uso de métodos de llamadores desconocidos o que no son de confianza podría dar lugar a la elevación de privilegios para código malintencionado.

• Si omite los assemblyResolver parámetros o typeResolver , el valor del throwOnError parámetro se pasa a los métodos que realizan la resolución predeterminada.

• Si throwOnError es true, este método produce un TypeLoadException valor when typeResolver devuelve nully un FileNotFoundException valor when assemblyResolver devuelve null.

• Este método no detecta excepciones producidas por assemblyResolver y typeResolver. Usted es responsable de las excepciones producidas por los métodos de resolución.

Resolución de ensamblados

El assemblyResolver método recibe un AssemblyName objeto , que se genera mediante el análisis del nombre del ensamblado de cadena que se incluye en typeName. Si typeName no contiene un nombre de ensamblado, assemblyResolver no se llama a y null se pasa a typeResolver.

Si assemblyResolver no se proporciona, el sondeo de ensamblado estándar se usa para localizar el ensamblado. Si assemblyResolver se proporciona, el GetType método no realiza sondeos estándar; en ese caso, debe asegurarse de que assemblyResolver puede controlar todos los ensamblados que se le pasan.

El assemblyResolver método debe devolver null si no se puede resolver el ensamblado. Si assemblyResolver devuelve null, typeResolver no se llama a y no se produce ningún procesamiento adicional; además, si throwOnError es true, se produce una FileNotFoundException excepción .

Si el AssemblyName que se pasa a assemblyResolver es un nombre parcial, uno o varios de sus elementos son null. Por ejemplo, si no tiene ninguna versión, la Version propiedad es null. Si la Version propiedad , la CultureInfo propiedad y el GetPublicKeyToken método devuelven null, solo se proporcionó el nombre simple del ensamblado. El assemblyResolver método puede usar o omitir todas las partes del nombre del ensamblado.

Los efectos de diferentes opciones de resolución de ensamblados se muestran como una tabla en la sección Resolución de nombres mixtos, para nombres de tipo simples y calificados para ensamblados.

Resolución de tipos

Si typeName no especifica un nombre de ensamblado, typeResolver siempre se llama a . Si typeName especifica un nombre de ensamblado, typeResolver solo se llama cuando el nombre del ensamblado se resuelve correctamente. Si assemblyResolver o el sondeo de ensamblado estándar devuelve null, typeResolver no se llama a .

El typeResolver método recibe tres argumentos:

• Ensamblado que se va a buscar o null si typeName no contiene un nombre de ensamblado.
• Nombre simple del tipo. En el caso de un tipo anidado, este es el tipo contenedor más externo. En el caso de un tipo genérico, este es el nombre simple del tipo genérico.
• Valor booleano que es true si se omitirán las mayúsculas y minúsculas de los nombres de tipo.

La implementación determina la forma en que se usan estos argumentos. El typeResolver método debe devolver null si no puede resolver el tipo. Si typeResolver devuelve null y throwOnError es true, esta sobrecarga de GetType produce una TypeLoadExceptionexcepción .

Los efectos de diferentes opciones de resolución de tipos se muestran como una tabla en la sección Resolución de nombres mixtos para nombres de tipo simples y calificados para ensamblados.

Resolución de tipos anidados

Si typeName es un tipo anidado, solo se pasa el nombre del tipo contenedor más externo a typeResolver. Cuando typeResolver devuelve este tipo, se GetNestedType llama al método de forma recursiva hasta que se ha resuelto el tipo anidado más interno.

Resolución de tipos genéricos

GetType Se llama de forma recursiva para resolver tipos genéricos: primero para resolver el propio tipo genérico y, a continuación, para resolver sus argumentos de tipo. Si un argumento de tipo es genérico, GetType se denomina recursivamente para resolver sus argumentos de tipo, etc.

La combinación de assemblyResolver y typeResolver que proporciona debe ser capaz de resolver todos los niveles de esta recursividad. Por ejemplo, supongamos que proporciona un assemblyResolver que controla la carga de MyAssembly. Supongamos que desea resolver el tipo Dictionary<string, MyType> genérico (Dictionary(Of String, MyType) en Visual Basic). Puede pasar el siguiente nombre de tipo genérico:

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

Observe que MyType es el único argumento de tipo calificado para ensamblados. Los nombres de las Dictionary<TKey,TValue> clases y String no están calificados para ensamblados. typeResolver Debe ser capaz de controlar un ensamblado o null, ya que recibirá null para Dictionary<TKey,TValue> y String. Puede controlar ese caso llamando a una sobrecarga del GetType método que toma una cadena, ya que ambos nombres de tipo no calificado están en 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))

No assemblyResolver se llama al método para el tipo de diccionario y el tipo de cadena, porque esos nombres de tipo no están calificados para ensamblados.

Ahora supongamos que, en lugar de , el primer tipo de System.Stringargumento genérico es YourType, de YourAssembly:

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

Dado que este ensamblado no es mscorlib.dll/System.Private.CoreLib.dll ni el ensamblado que se está ejecutando actualmente, no se puede resolver YourType sin un nombre completo para ensamblados. assemblyResolve Dado que se llamará de forma recursiva, debe ser capaz de controlar este caso. En lugar de devolver null para ensamblados distintos MyAssemblyde , ahora realiza una carga de ensamblado mediante el objeto proporcionado 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)

Resolución de nombres de tipo con caracteres especiales

Algunos caracteres tienen significados especiales en nombres calificados para ensamblados. Si un nombre de tipo simple contiene estos caracteres, los caracteres provocan errores de análisis cuando el nombre simple forma parte de un nombre calificado por ensamblados. Para evitar los errores de análisis, debe escapar los caracteres especiales con una barra diagonal inversa para poder pasar el nombre completo del ensamblado al GetType método . Por ejemplo, si un tipo se denomina Strange]Type, el carácter de escape debe agregarse delante del corchete como se indica a continuación: Strange\]Type.

En la tabla siguiente se muestran los caracteres especiales para los nombres de tipo.

Propiedades como AssemblyQualifiedName devolver cadenas con escape correctamente. Debe pasar correctamente cadenas de escape al GetType método . A su vez, el GetType método pasa los nombres con escape correctos a typeResolver los métodos de resolución de tipos predeterminados y a los métodos de resolución de tipos predeterminados. Si necesita comparar un nombre con un nombre sin escape en typeResolver, debe quitar los caracteres de escape.

Resolución de nombres mixtos

En la tabla siguiente se resumen las interacciones entre assemblyResolver, typeResolvery la resolución de nombres predeterminada, para todas las combinaciones de nombre de tipo y nombre de ensamblado en typeName: