Type.GetType Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Obtiene un objeto Type que representa el tipo especificado.

Sobrecargas

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)	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.
GetType()	Obtiene la estructura Type actual.
GetType(String)	Obtiene el objeto Type con el nombre especificado, mediante una búsqueda en la que se distingue entre mayúsculas y minúsculas.
GetType(String, Boolean)	Obtiene el objeto Type con el nombre especificado, que realiza una búsqueda donde se distingue entre mayúsculas y minúsculas y especifica si se va a producir o no una excepción si no se encuentra el tipo.
GetType(String, Boolean, Boolean)	Obtiene el Type con el nombre indicado, que especifica si se genera una excepción en caso de que no se encuentre el tipo y si se va a realizar una búsqueda donde se distingue entre mayúsculas y minúsculas.
GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)	Obtiene el tipo con el nombre especificado, que, de manera opcional, puede proporcionar métodos personalizados para resolver el ensamblado y el tipo.
GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)	Obtiene el tipo con el nombre indicado, que especifica 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.

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

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.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError, bool ignoreCase);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError, bool ignoreCase);

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

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool * bool -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean, ignoreCase As Boolean) As Type

Parámetros

typeName: 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 assemblyResolver parámetro o si se usa la resolución de tipos estándar, typeName debe ser un nombre calificado para ensamblados (vea AssemblyQualifiedName), a menos que el tipo esté en el ensamblado que se está ejecutando actualmente o en mscorlib.dll/System.Private.CoreLib.dll, en cuyo caso es suficiente proporcionar el nombre de tipo calificado por su espacio de nombres.

assemblyResolver: 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 autores de llamadas desconocidos o que no sean de confianza. Hacerlo podría tener como resultado la elevación de privilegios para el código malintencionado. Use solo los métodos que proporciona o con los que está familiarizado.

typeResolver: 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 autores de llamadas desconocidos o que no sean de confianza.

throwOnError: 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: 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.

Devoluciones

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.

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

TypeLoadException

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 insertada.

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 de tipo simple incluye un carácter especial sin escape).

O bien

throwOnError es true y typeName contiene 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 de 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 alguna 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 es un ensamblado válido para el tiempo de ejecución cargado actualmente.

Comentarios

Para más información sobre esta API, consulte Comentarios complementarios de la API para Type.GetType.

Se aplica a

GetType()

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Obtiene la estructura Type actual.

public:
 Type ^ GetType();

public:
 virtual Type ^ GetType();

public Type GetType ();

override this.GetType : unit -> Type

Public Function GetType () As Type

Devoluciones

Type

Objeto Type actual.

Implementaciones

GetType()

Excepciones

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

Consulte también

Se aplica a

GetType(String)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Obtiene el objeto Type con el nombre especificado, mediante una búsqueda en la que se distingue entre mayúsculas y minúsculas.

public:
 static Type ^ GetType(System::String ^ typeName);

public static Type GetType (string typeName);

public static Type? GetType (string typeName);

static member GetType : string -> Type

Public Shared Function GetType (typeName As String) As Type

Parámetros

typeName: String

Nombre calificado con el ensamblado del tipo que se va a obtener. Vea AssemblyQualifiedName. Si el tipo está en el ensamblado que se está ejecutando actualmente o en mscorlib.dll/System.Private.CoreLib.dll, es suficiente proporcionar el nombre de tipo calificado por su espacio de nombres.

Devoluciones

Type

Tipo con el nombre especificado, si se encuentra; de lo contrario null.

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

ArgumentException

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 de 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.

TypeLoadException

typeName representa un tipo no válido, por ejemplo, una matriz de TypedReference.

FileLoadException

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

Nota: En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, detecte la excepción de clase base, IOException, en su lugar.

BadImageFormatException

El ensamblado no es válido para el entorno de ejecución cargado actualmente.

Ejemplos

En el ejemplo siguiente se recupera el tipo de System.Int32 y se usa ese objeto de tipo para mostrar la FullName propiedad de System.Int32.

using namespace System;

int main()
{
   try {
      // Get the type of a specified class.
      Type^ myType1 = Type::GetType( "System.Int32" );
      Console::WriteLine( "The full name is {0}.\n", myType1->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type System.Int32",
                          e->GetType()->Name);
   }

   try {
      // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
      Type^ myType2 = Type::GetType( "NoneSuch", true );
      Console::WriteLine( "The full name is {0}.", myType2->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type NoneSuch",
                          e->GetType()->Name);
   }

}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

using System;

class Example
{
     public static void Main()
     {
         try {
             // Get the type of a specified class.
             Type myType1 = Type.GetType("System.Int32");
             Console.WriteLine("The full name is {0}.\n", myType1.FullName);
         }
         catch (TypeLoadException e)
         {
            Console.WriteLine("{0}: Unable to load type System.Int32", e.GetType().Name);
         }

         try {
             // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Type myType2 = Type.GetType("NoneSuch", true);
             Console.WriteLine("The full name is {0}.", myType2.FullName);
         }
         catch(TypeLoadException e) {
            Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name);
         }
     }
}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

open System

try
    // Get the type of a specified class.
    let myType1 = Type.GetType "System.Int32"
    printfn $"The full name is {myType1.FullName}.\n"
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type System.Int32"

try
    // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
    let myType2 = Type.GetType("NoneSuch", true)
    printfn $"The full name is {myType2.FullName}."
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type NoneSuch"
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

Class Example
     Public Shared Sub Main()
         Try
             ' Get the type of the specified class.
             Dim myType1 As Type = Type.GetType("System.Int32")
             Console.WriteLine("The full name is {0}.", myType1.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type System.Int32",
                               e.GetType().Name)
         End Try

         Console.WriteLine()

         Try
             ' Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Dim myType2 As Type = Type.GetType("NoneSuch", True)
             Console.WriteLine("The full name is {0}.", myType2.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name)
         End Try
     End Sub
End Class
' The example displays the following output:
'       The full name is System.Int32.
'
'       TypeLoadException: Unable to load type NoneSuch

Comentarios

Puede usar el GetType método para obtener un Type objeto para un tipo en otro ensamblado si conoce su nombre completo del ensamblado, que se puede obtener de AssemblyQualifiedName. GetType provoca la carga del ensamblado especificado en typeName. También puede cargar un ensamblado mediante el Assembly.Load método y, a continuación, usar el Assembly.GetType método o Assembly.GetTypes para obtener Type objetos. Si un tipo está en un ensamblado conocido para el programa en tiempo de compilación, es más eficaz usar typeof en C# o en el GetType operador de Visual Basic.

Nota

Si typeName no se encuentra, la llamada al GetType(String) método devuelve null. No produce una excepción. Para controlar si se produce una excepción, llame a una sobrecarga del GetType método que tiene un throwOnError parámetro .

GetType solo funciona en ensamblados cargados desde el disco. Si llama GetType a para buscar un tipo definido en un ensamblado dinámico definido mediante los System.Reflection.Emit servicios, podría obtener un comportamiento incoherente. El comportamiento depende de si el ensamblado dinámico es persistente, es decir, creado mediante los RunAndSave modos de acceso o Save de la System.Reflection.Emit.AssemblyBuilderAccess enumeración. Si el ensamblado dinámico es persistente y se ha escrito en el disco antes GetType de llamarlo, el cargador busca el ensamblado guardado en el disco, carga ese ensamblado y recupera el tipo de ese ensamblado. Si el ensamblado no se ha guardado en el disco cuando GetType se llama a , el método devuelve null. GetType no entiende los ensamblados dinámicos transitorios; por lo tanto, llamar GetType a para recuperar un tipo en un ensamblado dinámico transitorio devuelve null.

Para usarlo GetType en un módulo dinámico, suscríbase al evento y llame GetType a AppDomain.AssemblyResolve antes de guardarlo. De lo contrario, obtendrá dos copias del ensamblado en memoria.

En la tabla siguiente se muestra qué miembros de una clase base devuelven los Get métodos al reflejar en un tipo.

Tipo de miembro	Estático	No estático
Constructor	No	No
Campo	No	Sí. Un campo siempre está ocultado por nombre y firma.
evento	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.
Método	No	Sí. Un método (tanto virtual como no virtual) puede ocultarse por nombre u ocultar por nombre y firma.
Tipo anidado	No	No
Propiedad.	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.

Hide-by-name-and-signature tiene en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.
En el caso de la reflexión, las propiedades y los eventos son hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y un set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.
Los atributos personalizados no forman parte del sistema de tipos común.

Las matrices o los tipos COM no se buscan a menos que ya se hayan cargado en la tabla de clases disponibles.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre calificado para ensamblados que incluya una especificación de nombre de ensamblado. Vea AssemblyQualifiedName.

Si typeName incluye el espacio de nombres, pero no el nombre del ensamblado, este método busca solo el ensamblado del objeto que realiza la llamada y mscorlib.dll/System.Private.CoreLib.dll, en ese orden. Si typeName está completo con el nombre de ensamblado parcial o completo, este método busca en el ensamblado especificado. Si el ensamblado tiene un nombre seguro, se requiere un nombre de ensamblado completo.

La AssemblyQualifiedName propiedad devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre del ensamblado y los argumentos de tipo genérico. Todos los compiladores que admiten Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construye un nombre con un mangled cuando se consulta, de acuerdo con las siguientes convenciones.

Nota

La arquitectura del procesador forma parte de la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado. Por ejemplo, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la AssemblyQualifiedName propiedad, por motivos de compatibilidad. También puede cargar tipos creando un AssemblyName objeto y pasándolo a una sobrecarga adecuada del Load método. A continuación, puede usar el Assembly.GetType método para cargar tipos desde el ensamblado. Vea también AssemblyName.ProcessorArchitecture.

Delimitador	Significado
Barra diagonal inversa (\)	Carácter de escape.
Verso (')	Precede a uno o varios dígitos que representan el número de parámetros de tipo, ubicados al final del nombre de un tipo genérico.
Corchetes ([])	Incluya una lista de argumentos de tipo genérico para un tipo genérico construido; dentro de una lista de argumentos de tipo, incluya un tipo calificado para ensamblados.
Coma (,)	Precede al nombre del ensamblado.
Punto (.)	Denota identificadores de espacio de nombres.
Signo más (+)	Precede a una clase anidada.

Por ejemplo, el nombre completo de una clase podría tener este aspecto:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

Si el espacio de nombres fuera TopNamespace.Sub+Namespace, la cadena tendría que preceder al signo más (+) con un carácter de escape (\) para evitar que se interprete como un separador de anidamiento. La reflexión emite esta cadena de la siguiente manera:

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un "++" se convierte en "\+\+" y "\" se convierte en "\\".

Este nombre completo se puede conservar y usar más adelante para cargar .Type Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo calificado del ensamblado. GetType con el nombre de tipo solo buscará en Type el ensamblado del autor de la llamada y, a continuación, en el ensamblado Del sistema. GetType con el nombre de tipo calificado del ensamblado buscará en Type cualquier ensamblado.

Los nombres de tipo pueden incluir caracteres finales que denotan información adicional sobre el tipo, como si el tipo es un tipo de referencia, un tipo de puntero o un tipo de matriz. Para recuperar el nombre de tipo sin estos caracteres finales, use t.GetElementType().ToString(), donde t es el tipo .

Los espacios son relevantes en todos los componentes de nombre de tipo, excepto el nombre del ensamblado. En el nombre del ensamblado, los espacios antes del separador ',' son relevantes, pero los espacios después del separador ',' se omiten.

El nombre de un tipo genérico termina con un verso (') seguido de dígitos que representan el número de argumentos de tipo genérico. El propósito de esta administración de nombres es permitir que los compiladores admitan tipos genéricos con el mismo nombre, pero con números diferentes de parámetros de tipo, que se producen en el mismo ámbito. Por ejemplo, la reflexión devuelve los nombres Tuple`1 mangled y Tuple`2 de los métodos genéricos Tuple(Of T) y Tuple(Of T0, T1) en Visual Basic, o Tuple<T> y Tuple<T0, T1> en Visual C#.

Para los tipos genéricos, la lista de argumentos de tipo se incluye entre corchetes y los argumentos de tipo están separados por comas. Por ejemplo, un genérico Dictionary<TKey,TValue> tiene dos parámetros de tipo. Un Dictionary<TKey,TValue> de MyType con claves de tipo String puede representarse de la siguiente manera:

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

Para especificar un tipo calificado por ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado por ensamblado entre corchetes. De lo contrario, las comas que separan las partes del nombre completo del ensamblado se interpretan como argumentos de tipo adicionales delimitadores. Por ejemplo, un Dictionary<TKey,TValue> de MyType fromMyAssembly.dll, con claves de tipo String, puede especificarse de la siguiente manera:

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Nota

Un tipo calificado por ensamblado solo se puede incluir entre corchetes cuando aparece dentro de una lista de parámetros de tipo. Las reglas para buscar ensamblados para tipos calificados y no calificados en listas de parámetros de tipo son las mismas que las reglas para los tipos no genéricos calificados y no calificados.

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos. Por ejemplo, un que acepta Int32 valores NULL se representa mediante la cadena "System.Nullable'1[System.Int32]".

Nota

En C#, C++y Visual Basic también puede obtener tipos que aceptan valores NULL mediante operadores de tipo. Por ejemplo, en C#, en C++, Nullable<Boolean>::typeid devuelve el tipo typeof(Nullable<bool>) que acepta Boolean valores NULL y en GetType(Nullable(Of Boolean)) Visual Basic.

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.

Llegar	Usar
Un valor que acepta valores NULL Int32	Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a `MyType`	`Type.GetType("MyType*")`
Puntero no administrado a un puntero a `MyType`	`Type.GetType("MyType**")`
Puntero o referencia administrados a `MyType`	`Type.GetType("MyType&")`. Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.
Una clase primaria y una clase anidada	`Type.GetType("MyParentClass+MyNestedClass")`
Matriz unidimensional con un límite inferior de 0	`Type.GetType("MyType[]")`
Matriz unidimensional con un límite inferior desconocido	`Type.GetType("MyType[*]")`
Matriz n dimensional	Una coma (,) dentro de los corchetes un total de n-1 veces. Por ejemplo, `System.Object[,,]` representa una matriz tridimensional `Object` .
Matriz de matrices unidimensionales	`Type.GetType("MyType[][]")`
Matriz bidimensional rectangular con límites inferiores desconocidos	`Type.GetType("MyType[,]")`
Un tipo genérico con un argumento de tipo	Type.GetType("MyGenericType`1[MyType]")
Un tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Un tipo genérico con dos argumentos de tipo calificado para ensamblados	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado para ensamblados con un argumento de tipo calificado para ensamblados	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también

Se aplica a

GetType(String, Boolean)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Obtiene el objeto Type con el nombre especificado, que realiza una búsqueda donde se distingue entre mayúsculas y minúsculas y especifica si se va a producir o no una excepción si no se encuentra el tipo.

public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError);

public static Type GetType (string typeName, bool throwOnError);

public static Type? GetType (string typeName, bool throwOnError);

static member GetType : string * bool -> Type

Public Shared Function GetType (typeName As String, throwOnError As Boolean) As Type

Parámetros

typeName: String

throwOnError: Boolean

Devoluciones

Type

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

TypeLoadException

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 insertada.

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

throwOnError es true y typeName contiene 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 de 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 alguna de sus dependencias.

FileLoadException

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

Nota: En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, detecte la excepción de clase base, IOException, en su lugar.

BadImageFormatException

El ensamblado o una de sus dependencias no son válidos para el tiempo de ejecución cargado actualmente.

Ejemplos

En el ejemplo siguiente se recupera el tipo de System.Int32 y se usa ese objeto de tipo para mostrar la FullName propiedad de System.Int32. Si un objeto de tipo hace referencia a un ensamblado que no existe, en este ejemplo se produce una excepción.

using namespace System;

int main()
{
   try {
      // Get the type of a specified class.
      Type^ myType1 = Type::GetType( "System.Int32" );
      Console::WriteLine( "The full name is {0}.\n", myType1->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type System.Int32",
                          e->GetType()->Name);
   }

   try {
      // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
      Type^ myType2 = Type::GetType( "NoneSuch", true );
      Console::WriteLine( "The full name is {0}.", myType2->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type NoneSuch",
                          e->GetType()->Name);
   }

}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

using System;

class Example
{
     public static void Main()
     {
         try {
             // Get the type of a specified class.
             Type myType1 = Type.GetType("System.Int32");
             Console.WriteLine("The full name is {0}.\n", myType1.FullName);
         }
         catch (TypeLoadException e)
         {
            Console.WriteLine("{0}: Unable to load type System.Int32", e.GetType().Name);
         }

         try {
             // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Type myType2 = Type.GetType("NoneSuch", true);
             Console.WriteLine("The full name is {0}.", myType2.FullName);
         }
         catch(TypeLoadException e) {
            Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name);
         }
     }
}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

open System

try
    // Get the type of a specified class.
    let myType1 = Type.GetType "System.Int32"
    printfn $"The full name is {myType1.FullName}.\n"
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type System.Int32"

try
    // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
    let myType2 = Type.GetType("NoneSuch", true)
    printfn $"The full name is {myType2.FullName}."
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type NoneSuch"
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

Class Example
     Public Shared Sub Main()
         Try
             ' Get the type of the specified class.
             Dim myType1 As Type = Type.GetType("System.Int32")
             Console.WriteLine("The full name is {0}.", myType1.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type System.Int32",
                               e.GetType().Name)
         End Try

         Console.WriteLine()

         Try
             ' Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Dim myType2 As Type = Type.GetType("NoneSuch", True)
             Console.WriteLine("The full name is {0}.", myType2.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name)
         End Try
     End Sub
End Class
' The example displays the following output:
'       The full name is System.Int32.
'
'       TypeLoadException: Unable to load type NoneSuch

Comentarios

GetType solo funciona en ensamblados cargados desde el disco. Si llama GetType a para buscar un tipo definido en un ensamblado dinámico definido mediante los System.Reflection.Emit servicios, podría obtener un comportamiento incoherente. El comportamiento depende de si el ensamblado dinámico es persistente, es decir, creado mediante los RunAndSave modos de acceso o Save de la System.Reflection.Emit.AssemblyBuilderAccess enumeración. Si el ensamblado dinámico es persistente y se ha escrito en el disco antes GetType de llamarlo, el cargador busca el ensamblado guardado en el disco, carga ese ensamblado y recupera el tipo de ese ensamblado. Si el ensamblado no se ha guardado en el disco cuando GetType se llama a , el método devuelve null. GetType no entiende los ensamblados dinámicos transitorios; por lo tanto, llamar GetType a para recuperar un tipo en un ensamblado dinámico transitorio devuelve null.

Para usarlo GetType en un módulo dinámico, suscríbase al evento y llame GetType a AppDomain.AssemblyResolve antes de guardarlo. De lo contrario, obtendrá dos copias del ensamblado en memoria.

El throwOnError parámetro especifica lo que sucede cuando no se encuentra el tipo y también suprime ciertas otras condiciones de excepción, como se describe en la sección Excepciones. Algunas excepciones se inician independientemente del valor de throwOnError. Por ejemplo, si se encuentra el tipo pero no se puede cargar, se produce una TypeLoadException excepción aunque throwOnError sea false.

En la tabla siguiente se muestra qué miembros de una clase base devuelven los Get métodos al reflejar en un tipo.

Tipo de miembro	Estático	No estático
Constructor	No	No
Campo	No	Sí. Un campo siempre está ocultado por nombre y firma.
evento	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.
Método	No	Sí. Un método (tanto virtual como no virtual) puede ocultarse por nombre u ocultar por nombre y firma.
Tipo anidado	No	No
Propiedad.	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.

Hide-by-name-and-signature tiene en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.
En el caso de la reflexión, las propiedades y los eventos son hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y un set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.
Los atributos personalizados no forman parte del sistema de tipos común.

Las matrices o los tipos COM no se buscan a menos que ya se hayan cargado en la tabla de clases disponibles.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre calificado para ensamblados que incluya una especificación de nombre de ensamblado. Vea AssemblyQualifiedName.

La AssemblyQualifiedName propiedad devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre del ensamblado y los argumentos genéricos. Todos los compiladores que admiten Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construirá un nombre mangled cuando se consulte, de acuerdo con las siguientes convenciones.

Nota

La arquitectura del procesador forma parte de la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado. Por ejemplo, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la AssemblyQualifiedName propiedad , por motivos de compatibilidad. También puede cargar tipos creando un AssemblyName objeto y pasándolo a una sobrecarga adecuada del Load método. A continuación, puede usar el Assembly.GetType método para cargar tipos desde el ensamblado. Vea también AssemblyName.ProcessorArchitecture.

Delimitador	Significado
Barra diagonal inversa (\)	Carácter de escape.
Verso (')	Precede a uno o varios dígitos que representan el número de parámetros de tipo, ubicados al final del nombre de un tipo genérico.
Corchetes ([])	Incluya una lista de argumentos de tipo genérico para un tipo genérico construido; dentro de una lista de argumentos de tipo, incluya un tipo calificado con ensamblado.
Coma (,)	Precede al nombre del ensamblado.
Punto (.)	Denota identificadores de espacio de nombres.
Signo más (+)	Precede a una clase anidada.

Por ejemplo, el nombre completo de una clase podría tener este aspecto:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

Si el espacio de nombres fuera TopNamespace.Sub+Namespace, la cadena tendría que preceder al signo más (+) con un carácter de escape (\) para evitar que se interprete como separador de anidamiento. La reflexión emite esta cadena de la siguiente manera:

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un "++" se convierte en "\+\+" y "\" se convierte en "\\".

Este nombre completo se puede conservar y, posteriormente, se puede usar para cargar .Type Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo completo del ensamblado. GetType con el nombre de tipo solo buscará en Type el ensamblado del autor de la llamada y, a continuación, en el ensamblado Del sistema. GetType con el nombre de tipo completo del ensamblado buscará Type en cualquier ensamblado.

Los espacios son relevantes en todos los componentes de nombre de tipo, excepto el nombre del ensamblado. En el nombre del ensamblado, los espacios anteriores al separador ',' son relevantes, pero se omiten los espacios después del separador ','.

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

Para especificar un tipo calificado con ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado con ensamblado entre corchetes. De lo contrario, las comas que separan las partes del nombre completo del ensamblado se interpretan como argumentos de tipo adicionales delimitadores. Por ejemplo, un Dictionary<TKey,TValue> de MyType de MyAssembly.dll, con claves de tipo String, se puede especificar de la siguiente manera:

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Nota

Un tipo calificado con ensamblado solo se puede incluir entre corchetes cuando aparece dentro de una lista de parámetros de tipo. Las reglas para buscar ensamblados para tipos calificados y no calificados en listas de parámetros de tipo son las mismas que las reglas para tipos no genéricos calificados y no completos.

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos. Por ejemplo, un que acepta Int32 valores NULL se representa mediante la cadena "System.Nullable'1[System.Int32]".

Nota

En C#, C++y Visual Basic también puede obtener tipos que aceptan valores NULL mediante operadores de tipo. Por ejemplo, en C#, en C++, Nullable<Boolean>::typeid devuelve el tipo que acepta Boolean valores typeof(Nullable<bool>) NULL y en GetType(Nullable(Of Boolean)) Visual Basic.

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.

Llegar	Usar
Que acepta valores NULL Int32	Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a `MyType`	`Type.GetType("MyType*")`
Puntero no administrado a un puntero a `MyType`	`Type.GetType("MyType**")`
Puntero administrado o referencia a `MyType`	`Type.GetType("MyType&")`. Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.
Una clase primaria y una clase anidada	`Type.GetType("MyParentClass+MyNestedClass")`
Matriz unidimensional con un límite inferior de 0	`Type.GetType("MyArray[]")`
Matriz unidimensional con un límite inferior desconocido	`Type.GetType("MyArray[*]")`
Matriz de n dimensiones	Una coma (,) dentro de los corchetes un total de n-1 veces. Por ejemplo, `System.Object[,,]` representa una matriz tridimensional `Object` .
Matriz bidimensional de una matriz	`Type.GetType("MyArray[][]")`
Matriz bidimensional rectangular con límites inferiores desconocidos	`Type.GetType("MyArray[,]")`
Tipo genérico con un argumento de tipo	Type.GetType("MyGenericType`1[MyType]")
Tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Tipo genérico con dos argumentos de tipo calificado por ensamblados	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado por ensamblados con un argumento de tipo calificado para ensamblados	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también

Se aplica a

GetType(String, Boolean, Boolean)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Obtiene el Type con el nombre indicado, que especifica si se genera una excepción en caso de que no se encuentre el tipo y si se va a realizar una búsqueda donde se distingue entre mayúsculas y minúsculas.

public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError, bool ignoreCase);

public static Type GetType (string typeName, bool throwOnError, bool ignoreCase);

public static Type? GetType (string typeName, bool throwOnError, bool ignoreCase);

static member GetType : string * bool * bool -> Type

Public Shared Function GetType (typeName As String, throwOnError As Boolean, ignoreCase As Boolean) As Type

Parámetros

typeName: String

throwOnError: Boolean

ignoreCase: 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.

Devoluciones

Type

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

TypeLoadException

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 insertada.

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

throwOnError es true y typeName contiene 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 de 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 alguna de sus dependencias.

FileLoadException

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

BadImageFormatException

El ensamblado no es válido para el entorno de ejecución cargado actualmente.

Comentarios

Puede usar el GetType método para obtener un Type objeto para un tipo en otro ensamblado si conoce su nombre completo del ensamblado, que se puede obtener de AssemblyQualifiedName. GetType hace que la carga del ensamblado especificado en typeName. También puede cargar un ensamblado mediante el Assembly.Load método y, a continuación, usar el Assembly.GetType método o Assembly.GetTypes para obtener Type objetos. Si un tipo está en un ensamblado conocido para el programa en tiempo de compilación, es más eficaz usarlo typeof en C# o en el GetType operador de Visual Basic.

Para usarlo GetType en un módulo dinámico, suscríbase al evento y llame GetType a AppDomain.AssemblyResolve antes de guardarlo. De lo contrario, obtendrá dos copias del ensamblado en memoria.

El throwOnError parámetro especifica lo que sucede cuando no se encuentra el tipo y también suprime ciertas otras condiciones de excepción, como se describe en la sección Excepciones. Algunas excepciones se producen independientemente del valor de throwOnError. Por ejemplo, si se encuentra el tipo pero no se puede cargar, se produce una TypeLoadException excepción aunque throwOnError sea false.

En la tabla siguiente se muestra qué miembros de una clase base devuelven los Get métodos al reflejar en un tipo.

Tipo de miembro	Estático	No estático
Constructor	No	No
Campo	No	Sí. Un campo siempre se oculta por nombre y firma.
evento	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.
Método	No	Sí. Un método (tanto virtual como no virtual) puede ser hide-by-name u hide-by-name-and-signature.
Tipo anidado	No	No
Propiedad.	No es aplicable	La regla del sistema de tipos común es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Consulte la nota 2 a continuación.

Hide-by-name-and-signature tiene en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.
Para la reflexión, las propiedades y los eventos son hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y un set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá tener acceso al establecedor en la clase base.
Los atributos personalizados no forman parte del sistema de tipos común.

Las matrices o los tipos COM no se buscan a menos que ya se hayan cargado en la tabla de clases disponibles.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre completo para ensamblados que incluya una especificación de nombre de ensamblado. Vea AssemblyQualifiedName.

La AssemblyQualifiedName propiedad devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre del ensamblado y los argumentos de tipo. Todos los compiladores que admiten Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construirá un nombre mangled cuando se consulte, de acuerdo con las siguientes convenciones.

Nota

La arquitectura del procesador forma parte de la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado. Por ejemplo, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la AssemblyQualifiedName propiedad , por motivos de compatibilidad. También puede cargar tipos creando un AssemblyName objeto y pasándolo a una sobrecarga adecuada del Load método. A continuación, puede usar el Assembly.GetType método para cargar tipos desde el ensamblado. Vea también AssemblyName.ProcessorArchitecture.

Delimitador	Significado
Barra diagonal inversa (\)	Carácter de escape.
Verso (')	Precede a uno o varios dígitos que representan el número de parámetros de tipo, ubicados al final del nombre de un tipo genérico.
Corchetes ([])	Incluya una lista de argumentos de tipo genérico para un tipo genérico construido; dentro de una lista de argumentos de tipo, incluya un tipo calificado con ensamblado.
Coma (,)	Precede al nombre del ensamblado.
Punto (.)	Denota identificadores de espacio de nombres.
Signo más (+)	Precede a una clase anidada.

Por ejemplo, el nombre completo de una clase podría tener este aspecto:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un "++" se convierte en "\+\+" y "\" se convierte en "\\".

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

Para especificar un tipo calificado por ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado por ensamblado entre corchetes. De lo contrario, las comas que separan las partes del nombre completo del ensamblado se interpretan como argumentos de tipo adicionales delimitadores. Por ejemplo, un Dictionary<TKey,TValue> de MyType de MyAssembly.dll, con claves de tipo String, puede especificarse de la siguiente manera:

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Nota

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos. Por ejemplo, un que acepta Int32 valores NULL se representa mediante la cadena "System.Nullable'1[System.Int32]".

Nota

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.

Llegar	Usar
Un valor que acepta valores NULL Int32	Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a `MyType`	`Type.GetType("MyType*")`
Puntero no administrado a un puntero a `MyType`	`Type.GetType("MyType**")`
Puntero o referencia administrados a `MyType`	`Type.GetType("MyType&")`. Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.
Una clase primaria y una clase anidada	`Type.GetType("MyParentClass+MyNestedClass")`
Matriz unidimensional con un límite inferior de 0	`Type.GetType("MyArray[]")`
Matriz unidimensional con un límite inferior desconocido	`Type.GetType("MyArray[*]")`
Matriz n dimensional	Una coma (,) dentro de los corchetes un total de n-1 veces. Por ejemplo, `System.Object[,,]` representa una matriz tridimensional `Object` .
Matriz bidimensional de una matriz	`Type.GetType("MyArray[][]")`
Matriz bidimensional rectangular con límites inferiores desconocidos	`Type.GetType("MyArray[,]")`
Un tipo genérico con un argumento de tipo	Type.GetType("MyGenericType`1[MyType]")
Un tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Un tipo genérico con dos argumentos de tipo calificado para ensamblados	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado para ensamblados con un argumento de tipo calificado para ensamblados	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipo	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también

Se aplica a

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Obtiene el tipo con el nombre especificado, que, de manera opcional, puede proporcionar métodos personalizados para resolver el ensamblado y el tipo.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver);

public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver);

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type)) As Type

Parámetros

typeName: String

assemblyResolver: Func<AssemblyName,Assembly>

typeResolver: 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 typeResolver 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 false a ese parámetro.

Precaución: No pase métodos de autores de llamadas desconocidos o que no sean de confianza.

Devoluciones

Type

Tipo con el nombre especificado, o null si no se encuentra el tipo.

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

ArgumentException

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

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 de 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.

TypeLoadException

typeName representa un tipo no válido, por ejemplo, una matriz de TypedReference.

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 para el tiempo de ejecución cargado actualmente.

Comentarios

Los escenarios de uso de este método y los detalles sobre los assemblyResolver parámetros y typeResolver se pueden encontrar en la sobrecarga del GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) método.

Nota

Si typeName no se encuentra, la llamada al GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) método devuelve null. No produce una excepción. Para controlar si se produce una excepción, llame a una sobrecarga del GetType método que tiene un throwOnError parámetro .

Llamar a esta sobrecarga de método es la misma que llamar a la sobrecarga del GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) método y especificar false para los throwOnError parámetros y ignoreCase .

Se aplica a

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Source:: Type.CoreCLR.cs

Obtiene el tipo con el nombre indicado, que especifica 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.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError);

public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver, bool throwOnError);

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean) As Type

Parámetros

typeName: String

assemblyResolver: Func<AssemblyName,Assembly>

typeResolver: Func<Assembly,String,Boolean,Type>

Precaución: No pase métodos de autores de llamadas desconocidos o que no sean de confianza.

throwOnError: Boolean

Devoluciones

Type

Excepciones

ArgumentNullException

typeName es null.

TargetInvocationException

Se invoca un inicializador de clase y genera una excepción.

TypeLoadException

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 insertada.

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 de tipo simple incluye un carácter especial sin escape).

O bien

throwOnError es true y typeName contiene 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 de 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 alguna de sus dependencias.

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.

FileLoadException

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

BadImageFormatException

El ensamblado o una de sus dependencias no son válidos para el tiempo de ejecución cargado actualmente.

Comentarios

Se aplica a

Compartir vía

Type.GetType Método

Definición

Sobrecargas

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

GetType()

Devoluciones

Implementaciones

Excepciones

Consulte también

Se aplica a

GetType(String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

GetType(String, Boolean)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

GetType(String, Boolean, Boolean)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

Recursos adicionales