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

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)

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 ejecuta actualmente o en mscorlib.dll/System.Private.CoreLib.dll, es suficiente para proporcionar el nombre completo del tipo 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 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, capture la excepción de clase base, IOException, en su lugar.

BadImageFormatException

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

O bien

Actualmente, está cargada la versión 2.0 u otra posterior de Common Language Runtime pero el ensamblado se compiló con una versión posterior.

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

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 construirá un nombre mangled cuando se consulte, de acuerdo con las siguientes convenciones.

Nota:

En .NET Framework versión 2.0, la arquitectura del procesador se agrega a 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 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 anteriores al separador ',' son relevantes, pero se omiten los espacios después del separador ','.

El nombre de un tipo genérico termina con un acento trasero (') 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 podría representarse de la siguiente manera:

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 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 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("MyType[]")`
Matriz unidimensional con un límite inferior desconocido	`Type.GetType("MyType[*]")`
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 de matrices unidimensionales	`Type.GetType("MyType[][]")`
Matriz bidimensional rectangular con límites inferiores desconocidos	`Type.GetType("MyType[,]")`
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)

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

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.

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

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, capture la excepción de clase base, IOException, en su lugar.

BadImageFormatException

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

o bien

Actualmente, está cargada la versión 2.0 u otra posterior de Common Language Runtime pero el ensamblado se compiló con una versión posterior.

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

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 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 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("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, 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.

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 o alguna de sus dependencias no son válidos.

O bien

Actualmente, está cargada la versión 2.0 u otra posterior de Common Language Runtime pero el ensamblado se compiló con una versión posterior.

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.

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 un TypeLoadException elemento incluso si throwOnError es 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 de tipo. 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:

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

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

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

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/System.Private.CoreLib.dll, en cuyo caso basta con aplicar el nombre de tipo calificado con 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 son 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 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 son 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 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 alguna de sus dependencias no son válidos.

o bien

El ensamblado se compiló con una versión de Common Language Runtime posterior a la versión que está cargada 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)

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>

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

Precaución No pase métodos de autores de llamadas desconocidos o que no son 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 alguna de sus dependencias no son válidos.

o bien

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

Comentarios

Se aplica a

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.

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

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

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

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 alguna de sus dependencias no son válidos.

O bien

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

Comentarios

Use esta sobrecarga de 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.
Cargue ensamblados mediante nombres de ensamblado parcial.
Devuelve subclases de System.Type que no se crean mediante Common Language Runtime (CLR).

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 no se crean mediante CLR; todos los tipos devueltos por otras sobrecargas del GetType método 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, ya que se debe resolver un nombre de tipo en el contexto de un ensamblado.

Nota:

Si no está familiarizado con el concepto de nombres de tipo calificado por ensamblados, consulte la AssemblyQualifiedName propiedad .

Si typeName no es un nombre completo para ensamblados, se omite la resolución de ensamblados. Los nombres de tipo sin calificar 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 ni 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 autores de llamadas desconocidos o que no son de confianza podría dar lugar a la elevación de privilegios para el 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 cuando typeResolver devuelve nully un FileNotFoundException cuando 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, una o varias de sus partes 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 nulltodos , 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 las 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 sencillos 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 las 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 sencillos 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 haya 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 llama de forma recursiva para resolver sus argumentos de tipo, etc.

La combinación de assemblyResolver y typeResolver que proporcione debe ser capaz de resolver todos los niveles de esta recursividad. Por ejemplo, supongamos que proporciona un assemblyResolver objeto 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 por ensamblado. Los nombres de las Dictionary<TKey,TValue> clases y String no están calificados para ensamblados. Debe typeResolver ser capaz de controlar un ensamblado o null, porque 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 calificados 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 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 mscorlib.dll/System.Private.CoreLib.dll ni el ensamblado que se está ejecutando actualmente, no se puede resolver YourType sin un nombre completo del ensamblado. 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)

Vuelva a Notas de uso.

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 completo de ensamblado. Para evitar los errores de análisis, debe escapar los caracteres especiales con una barra diagonal inversa antes de 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.

Nota:

Los nombres con estos caracteres especiales no se pueden crear en Visual Basic o C#, pero se pueden crear mediante Microsoft lenguaje intermedio (MSIL) o mediante la emisión de ensamblados dinámicos.

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

Carácter	Significado
`,` (coma)	Delimitador para nombres calificados para ensamblados.
`[]` (corchetes)	Como par de sufijos, indica un tipo de matriz; como par de delimitador, incluye listas de argumentos genéricos y nombres calificados para ensamblados.
`&` ("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 tipos anidados.
`\` (barra diagonal inversa)	Carácter de escape.

Propiedades como AssemblyQualifiedName devolver cadenas de 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.

Vuelva a Notas de uso.

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:

Contenido del nombre de tipo	Método de resolución de ensamblados	Método de resolución de tipos	Resultado
type, assembly	null	null	Equivalente a llamar a la sobrecarga del Type.GetType(String, Boolean, Boolean) método.
type, assembly	Proporcionado	null	`assemblyResolver` devuelve el ensamblado o devuelve `null` si no puede resolver el ensamblado. Si se resuelve el ensamblado, la Assembly.GetType(String, Boolean, Boolean) sobrecarga del método se usa para cargar el tipo desde el ensamblado; de lo contrario, no hay ningún intento de resolver el tipo.
type, assembly	null	Proporcionado	Equivalente a convertir el nombre del ensamblado en un AssemblyName objeto y llamar a la sobrecarga del Assembly.Load(AssemblyName) método para obtener el ensamblado. Si se resuelve el ensamblado, se pasa a ; de lo contrario, `typeResolver` no se llama a `typeResolver`y no se intenta resolver el tipo.
type, assembly	Proporcionado	Proporcionado	`assemblyResolver` devuelve el ensamblado o devuelve `null` si no puede resolver el ensamblado. Si se resuelve el ensamblado, se pasa a ; de lo contrario, `typeResolver` no se llama a `typeResolver`y no se intenta resolver el tipo.
type	null, proporcionado	null	Equivalente a llamar a la sobrecarga del Type.GetType(String, Boolean, Boolean) método. Dado que no se proporciona el nombre del ensamblado, solo se busca mscorlib.dll/System.Private.CoreLib.dll y el ensamblado que se está ejecutando actualmente. Si `assemblyResolver` se proporciona, se omite.
type	null, proporcionado	Proporcionado	`typeResolver` se llama a y `null` se pasa para el ensamblado. `typeResolver` puede proporcionar un tipo de cualquier ensamblado, incluidos los ensamblados que carga para el propósito. Si `assemblyResolver` se proporciona, se omite.
ensamblado	null, proporcionado	null, proporcionado	FileLoadException Se produce una excepción , porque el nombre del ensamblado se analiza como si fuera un nombre de tipo calificado por ensamblado. Esto da como resultado un nombre de ensamblado no válido.

Volver a: Notas de uso, Resolución de ensamblados, Resolución de tipos.

Se aplica a

Type.GetType Método

Definición

Sobrecargas

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

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

Parámetros

Devoluciones

Excepciones

Comentarios

Notas de uso

Resolución de ensamblados

Resolución de tipos

Resolución de tipos anidados

Resolución de tipos genéricos

Resolución de nombres de tipo con caracteres especiales

Resolución de nombres mixtos

Se aplica a

Recursos adicionales