¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
GetType (Método) (String, Func(AssemblyName, Assembly), Func(Assembly, String, Boolean, Type), Boolean, Boolean)
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Type.GetType (Método) (String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>, Boolean, Boolean)

.NET Framework 4.6 and 4.5

Obtiene el tipo con el nombre indicado, que especifica si se va a realizar una búsqueda sin distinguir mayúsculas de minúsculas y si se va a iniciar una excepción en caso de que el tipo no se encuentre y que, de manera opcional, puede proporcionar métodos personalizados para resolver el ensamblado y el tipo.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public static Type GetType(
	string typeName,
	Func<AssemblyName, Assembly> assemblyResolver,
	Func<Assembly, string, bool, Type> typeResolver,
	bool throwOnError,
	bool ignoreCase
)

Parámetros

typeName
Tipo: System.String
Nombre del tipo que se va a obtener. Si se proporciona el parámetro typeResolver, el nombre del tipo puede ser cualquier cadena que typeResolver pueda resolver. Si se proporciona el parámetro assemblyResolver o se usa la resolución de tipos estándar, typeName debe ser un nombre calificado con el ensamblado (vea AssemblyQualifiedName), a menos que el tipo esté en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, en cuyo caso basta con aplicar el nombre de tipo calificado con su espacio de nombres.
assemblyResolver
Tipo: System.Func<AssemblyName, Assembly>
Método que busca y devuelve el ensamblado especificado en typeName. El nombre del ensamblado se pasa a assemblyResolver como un objeto AssemblyName. Si typeName no contiene el nombre de un ensamblado, no se llama a assemblyResolver. Si no se proporciona assemblyResolver, se realiza la resolución de ensamblados estándar.
Precaución   No pase métodos de llamadores desconocidos o que no sean de confianza. Hacerlo podría tener como resultado la elevación de privilegios para el código malintencionado. Use sólo los métodos que proporciona o con los que está familiarizado.
typeResolver
Tipo: System.Func<Assembly, String, Boolean, Type>
Método que busca y devuelve el tipo especificado por typeName del ensamblado devuelto por assemblyResolver o mediante la resolución de ensamblados estándar. Si no se proporciona ningún ensamblado, el método podrá proporcionar uno. El método también toma un parámetro que especifica si se va a realizar una búsqueda sin distinguir mayúsculas de minúsculas; se pasa el valor de ignoreCase a ese parámetro.
Precaución   No pase métodos de llamadores desconocidos o que no sean de confianza.
throwOnError
Tipo: System.Boolean
Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null. Si se especifica false se suprimen otras condiciones de excepción, pero no todas. Vea la sección Excepciones.
ignoreCase
Tipo: System.Boolean
true para realizar una búsqueda de typeName que no distinga entre mayúsculas y minúsculas; false para realizar una búsqueda de typeName que distinga entre mayúsculas y minúsculas.

Valor devuelto

Tipo: System.Type
Tipo con el nombre especificado. Si el tipo no se encuentra, el parámetro throwOnError especifica si se devuelve null o se produce una excepción. En algunos casos, se produce una excepción con independencia del valor de throwOnError. Vea la sección Excepciones.

ExcepciónCondición
ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca a un inicializador de clase y se produce una excepción.

TypeLoadException

El valor de throwOnError es true y no se encuentra el tipo.

O bien

throwOnError es true y typeName contiene caracteres no válidos, como una pestaña incrustada.

O bien

throwOnError es true y typeName es una cadena vacía.

O bien

throwOnError es true y typeName representa un tipo de matriz con un tamaño no válido.

O bien

typeName representa una matriz de TypedReference.

ArgumentException

Se produce un error cuando typeName se analiza en un nombre de tipo y un nombre de ensamblado (por ejemplo, cuando el nombre del tipo simple incluye un carácter especial sin escape).

O bien

throwOnError es true y typeName contiene la sintaxis no válida (por ejemplo, "MyType [, *,]").

O bien

typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.

O bien

typeName representa un tipo genérico que tiene un número incorrecto como uno de sus argumentos de tipo.

O bien

typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.

FileNotFoundException

throwOnError es true y no se encontró el ensamblado o una de sus dependencias.

FileLoadException

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.

O bien

typeName contiene un nombre de ensamblado no válido.

O bien

typeName es un nombre de ensamblado válido sin un nombre de tipo.

BadImageFormatException

El ensamblado o una de sus dependencias no son válidos.

O bien

El ensamblado se compiló con una versión de Common Language Runtime posterior a la que está cargada actualmente.

Use esta sobrecarga del 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 predeterminado del método GetType con implementaciones más flexibles. Proporcionando sus propios métodos que resuelven los nombres de tipo y los nombres de los ensamblados que los contienen, puede hacer el siguiente:

  • Controla de qué versión de un ensamblado se carga un tipo.

  • Proporcione otra ubicación para buscar un nombre de tipo que no incluye un nombre de ensamblado.

  • Cargue ensamblados mediante los nombres del ensamblado parciales.

  • Devolución de subclases de System.Type que no se han creado con Common Language Runtime (CLR).

Por ejemplo, en serialización tolerante a versiones este método le permite buscar un ensamblado "perfecto" usando un nombre parcial. Otras sobrecargas del método GetType requieren un nombre de tipo calificado con el nombre de ensamblado, que incluye el número de versión.

Las implementaciones alternativas del sistema de tipos pueden necesitar devolver subclases de System.Type que no están creadas por el CLR; todos los tipos que son devueltos por otras sobrecargas del método GetType son tipos en tiempo de ejecución.

Notas de uso

Esta sobrecarga de 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, porque un nombre de tipo se debe resolver en el contexto de un ensamblado.

NotaNota

Si no está familiarizado con el concepto de nombres de tipo calificados con el nombre de ensamblado, vea la propiedad AssemblyQualifiedName.

Si typeName no es un nombre calificado con el ensamblado, se omite la resolución de ensamblados. Los nombres de tipo incompletos se pueden resolver en el contexto de Mscorlib.dll o el ensamblado que se está ejecutando actualmente, o se puede proporcionar opcionalmente un ensamblado en el parámetro typeResolver. Los efectos de incluir u omitir el nombre de ensamblado en tipos diferentes de resolución de nombres se muestran como una tabla en la sección Resolución de nombre mixto.

Notas de uso generales:

  • No pase métodos a assemblyResolver o typeResolver si proceden de llamadores desconocidos o que no sean de confianza. Use sólo los métodos que proporciona o con los que está familiarizado.

    Nota de precauciónPrecaución

    El uso de métodos de llamadores desconocido o que no son de confianza podría producir la elevación de privilegio para código malintencionado.

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

  • Si throwOnError es true, este método produce una excepción TypeLoadException cuando typeResolver devuelve null, y una excepción FileNotFoundException cuando assemblyResolver devuelve null.

  • Este método no detecta excepciones producidas por assemblyResolver y typeResolver. Es responsable de cualquier excepción que se produzca con los métodos de resolución.

Ee332784.collapse_all(es-es,VS.110).gifResolver ensamblados

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

Si no se proporciona assemblyResolver, se usan las reglas estándar de búsqueda de ensamblados para encontrar el ensamblado. Si se proporciona assemblyResolver, el método GetType no realiza la búsqueda estándar; en ese caso debe asegurarse de que assemblyResolver puede administrar todos los ensamblados que le pasa.

El método assemblyResolver debería devolver null si no se puede resolver el ensamblado. Si assemblyResolver devuelve null, no se llama a typeResolver y no se realizan más procesamientos; además, si throwOnError es true, se produce FileNotFoundException.

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

Los efectos de opciones de resolución de ensamblado diferentes se muestran como una tabla en la sección Resolución de nombre mixto, para nombres de tipo calificados con el nombre de ensamblado y simples.

Ee332784.collapse_all(es-es,VS.110).gifResolver tipos

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

El método typeResolver recibe tres argumentos.

  • El ensamblado para la búsqueda o null, si typeName no contiene un nombre del ensamblado.

  • Nombre simple del tipo. En el caso de tipos declarados, es el tipo contenedor más externo. En el caso de un tipo genérico, es el nombre simple del tipo genérico.

  • Un valor booleano que es true si se va a omitir el caso de nombre de tipo.

La implementación determina la manera que se usan estos argumentos. El método typeResolver debería devolver null si no puede resolver el tipo. Si typeResolver devuelve null y throwOnError es true, esta sobrecarga de GetType produce una excepción TypeLoadException.

Los efectos de opciones de resolución de tipo diferentes se muestran como una tabla en la sección Resolución de nombre mixto, para nombres de tipo calificados con el nombre de ensamblado y simples.

Ee332784.collapse_all(es-es,VS.110).gifResolver tipos anidados

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

Ee332784.collapse_all(es-es,VS.110).gifResolver tipos genéricos

Se llama a GetType de forma recursiva para resolver tipos genéricos: primero se resuelve el propio tipo genérico y después se resuelven sus argumentos de tipo. Si un argumento de tipo es genérico, se llama a GetType de forma recursiva 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, suponga que proporciona un assemblyResolver que controla la carga de MyAssembly. Suponga que desea resolver el tipo genérico Dictionary<string, MyType> (Dictionary(Of String, MyType) en Visual Basic). Podría pasar el nombre de tipo genérico siguiente:

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

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


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

Ahora suponga que en lugar de System.String, el primer tipo de argumento 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 ni Mscorlib.dll ni el ensamblado que se está ejecutando actualmente, no puede resolver YourType sin un nombre calificado con el ensamblado. Dado que assemblyResolve se llamará de forma recursiva, debe ser capaz de administrar este caso. En lugar de devolver null para los ensamblados distintos de MyAssembly, ahora realiza una carga del ensamblado mediante el objeto AssemblyName proporcionado.


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


Volver a Notas de uso.

Ee332784.collapse_all(es-es,VS.110).gifResolver nombres de tipo con caracteres especiales

Ciertos caracteres tienen significados especiales en nombres calificados con el ensamblado. Si un nombre del tipo simple contiene estos caracteres, los caracteres producen errores de análisis cuando el nombre sencillo forma parte de un nombre calificado con el ensamblado. Para evitar errores de análisis, debe indicar los caracteres especiales con una barra diagonal inversa antes de poder pasar el nombre calificado con el ensamblado al método GetType. Por ejemplo, si un tipo se denomina Strange]Type, el carácter de escape se debe agregar delante del corchete como sigue: Strange\]Type.

NotaNota

Los nombres con tales caracteres especiales no se pueden crear en Visual Basic o C#, pero se pueden crear usando el lenguaje intermedio de Microsoft (MSIL) o emitiendo los ensamblados dinámicos.

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

Carácter

Significado

, (coma)

Delimitador para los nombres calificados con el ensamblado.

[] (corchetes)

Como par de sufijo, indica un tipo de matriz; como par de delimitador, agrega listas de argumentos genéricas y nombres calificados con el ensamblado.

Símbolo de Y comercial (&)

Como sufijo, indica que un tipo es un tipo de referencia.

* (asterisco)

Como sufijo, indica que un tipo es un tipo de puntero.

+ (más)

Delimitador para los tipos anidados.

\ (barra diagonal inversa)

Carácter de escape.

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

Volver a Notas de uso.

Resolución de nombres mixta

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

Contenido de nombre de tipo

Método de resolución de ensamblado

Método de resolución de tipo

Resultado

tipo, ensamblado

null

null

Esto equivale a llamar a la sobrecarga del método Type.GetType(String, Boolean, Boolean).

tipo, ensamblado

proveedor

null

assemblyResolver devuelve el ensamblado o devuelve null si no puede resolver el ensamblado. Si se resuelve el ensamblado, se usa la sobrecarga del método Assembly.GetType(String, Boolean, Boolean) para cargar el tipo del ensamblado; de lo contrario, no se realizan más intentos para resolver el tipo.

tipo, ensamblado

null

proveedor

Equivalente a convertir el nombre del ensamblado en un objeto AssemblyName y llamar a la sobrecarga del método Assembly.Load(AssemblyName) para obtener el ensamblado. Si se resuelve el ensamblado, se pasa a typeResolver; de lo contrario, typeResolver no se llama y no se realizan más intentos para resolver el tipo.

tipo, ensamblado

proveedor

proveedor

assemblyResolver devuelve el ensamblado o devuelve null si no puede resolver el ensamblado. Si se resuelve el ensamblado, se pasa a typeResolver; de lo contrario, typeResolver no se llama y no se realizan más intentos para resolver el tipo.

type

NULL, proporcionado

null

Esto equivale a llamar a la sobrecarga del método Type.GetType(String, Boolean, Boolean). Dado que no se proporciona el nombre del ensamblado, solo se busca en Mscorlib.dll y en el ensamblado que se está ejecutando actualmente. Si se proporciona assemblyResolver, se omite.

type

NULL, proporcionado

proveedor

Se llama a typeResolver y null se pasa para el ensamblado. typeResolver pueden proporcionar un tipo de cualquier ensamblado, incluidos los ensamblados que carga para el propósito. Si se proporciona assemblyResolver, se omite.

ensamblado

NULL, proporcionado

NULL, proporcionado

Se produce FileLoadException, porque el nombre del ensamblado se analiza como si fuera un nombre de tipo calificado con el nombre de ensamblado. Este resultado es un nombre de ensamblado no válido.

Volver a: Notas de uso, Resolver ensamblado, Resolver tipos.

.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Compatible con: 4

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft