Type.GetType Método

Definición

Obtiene un objeto Type que representa el tipo especificado.Gets a Type object that represents the specified type.

Sobrecargas

GetType()

Obtiene la estructura Type actual.Gets the current Type.

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.Gets the Type with the specified name, performing a case-sensitive search.

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.Gets the Type with the specified name, performing a case-sensitive search and specifying whether to throw an exception if the type is not found.

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.Gets the Type with the specified name, specifying whether to throw an exception if the type is not found and whether to perform a case-sensitive search.

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.Gets the type with the specified name, optionally providing custom methods to resolve the assembly and the type.

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.Gets the type with the specified name, specifying whether to throw an exception if the type is not found, and optionally providing custom methods to resolve the assembly and the type.

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.Gets the type with the specified name, specifying whether to perform a case-sensitive search and whether to throw an exception if the type is not found, and optionally providing custom methods to resolve the assembly and the type.

GetType()

Obtiene la estructura Type actual.Gets the current Type.

public:
 virtual Type ^ GetType();
public Type GetType ();
override this.GetType : unit -> Type
Public Function GetType () As Type

Devoluciones

Objeto Type actual.The current Type.

Implementaciones

Excepciones

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

Consulte también:

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.Gets the Type with the specified name, performing a case-sensitive search.

public:
 static Type ^ GetType(System::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.The assembly-qualified name of the type to get. Vea AssemblyQualifiedName.See AssemblyQualifiedName. Si el tipo está en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, es suficiente para proporcionar el nombre completo del tipo por su espacio de nombres.If the type is in the currently executing assembly or in Mscorlib.dll, it is sufficient to supply the type name qualified by its namespace.

Devoluciones

Tipo con el nombre especificado, si se encuentra; de lo contrario null.The type with the specified name, if found; otherwise, null.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

o bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

o bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, capture en su lugar la excepción de clase base, IOException.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, IOException, instead.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

O bien-or-

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.Version 2.0 or later of the common language runtime is currently loaded, and the assembly was compiled with a later version.

Ejemplos

En el ejemplo siguiente se recupera el tipo de System.Int32 y se utiliza ese objeto de tipo para mostrar la propiedad FullName de System.Int32.The following example retrieves the type of System.Int32 and uses that type object to display the FullName property of 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
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 método GetType para obtener un objeto Type para un tipo de otro ensamblado si conoce su nombre calificado con el ensamblado, que se puede obtener de AssemblyQualifiedName.You can use the GetType method to obtain a Type object for a type in another assembly if you know its assembly-qualified name, which can be obtained from AssemblyQualifiedName. GetType provoca la carga del ensamblado especificado en typeName.GetType causes loading of the assembly specified in typeName. También puede cargar un ensamblado mediante el método Assembly.Load y, a continuación, usar el método Assembly.GetType o Assembly.GetTypes para obtener objetos Type.You can also load an assembly using the Assembly.Load method, and then use the Assembly.GetType or Assembly.GetTypes method to get Type objects. 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 operador GetType de Visual Basic.If a type is in an assembly known to your program at compile time, it is more efficient to use typeof in C# or the GetType operator in Visual Basic.

Nota

Si no se encuentra typeName, la llamada al método GetType(String) devuelve null.If typeName cannot be found, the call to the GetType(String) method returns null. No produce una excepción.It does not throw an exception. Para controlar si se produce una excepción, llame a una sobrecarga del método GetType que tenga un parámetro throwOnError.To control whether an exception is thrown, call an overload of the GetType method that has a throwOnError parameter.

GetType solo funciona en ensamblados cargados desde el disco.GetType only works on assemblies loaded from disk. Si llama a GetType para buscar un tipo definido en un ensamblado dinámico definido mediante los servicios System.Reflection.Emit, podría obtener un comportamiento incoherente.If you call GetType to look up a type defined in a dynamic assembly defined using the System.Reflection.Emit services, you might get inconsistent behavior. El comportamiento depende de si el ensamblado dinámico es persistente, es decir, se crea mediante los modos de acceso RunAndSave o Save de la enumeración System.Reflection.Emit.AssemblyBuilderAccess.The behavior depends on whether the dynamic assembly is persistent, that is, created using the RunAndSave or Save access modes of the System.Reflection.Emit.AssemblyBuilderAccess enumeration. Si el ensamblado dinámico es persistente y se ha escrito en el disco antes de que se llame a GetType, el cargador busca el ensamblado guardado en el disco, lo carga y recupera el tipo de ese ensamblado.If the dynamic assembly is persistent and has been written to disk before GetType is called, the loader finds the saved assembly on disk, loads that assembly, and retrieves the type from that assembly. Si el ensamblado no se ha guardado en el disco cuando se llama a GetType, el método devuelve null.If the assembly has not been saved to disk when GetType is called, the method returns null. GetType no entiende los ensamblados dinámicos transitorios; por lo tanto, llamar a GetType para recuperar un tipo de un ensamblado dinámico transitorio devuelve null.GetType does not understand transient dynamic assemblies; therefore, calling GetType to retrieve a type in a transient dynamic assembly returns null.

Para usar GetType en un módulo dinámico, suscríbase al evento de AppDomain.AssemblyResolve y llame a GetType antes de guardar.To use GetType on a dynamic module, subscribe to the AppDomain.AssemblyResolve event and call GetType before saving. De lo contrario, obtendrá dos copias del ensamblado en la memoria.Otherwise, you will get two copies of the assembly in memory.

En la tabla siguiente se muestra qué miembros de una clase base son devueltos por los métodos Get al reflejar en un tipo.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo de miembroMember Type EstáticoStatic No estáticaNon-Static
ConstructorConstructor NoNo NoNo
CampoField NoNo Sí.Yes. Un campo siempre se oculta por nombre y firma.A field is always hide-by-name-and-signature.
eventoEvent No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
MétodoMethod NoNo Sí.Yes. Un método (tanto virtual como no virtual) se puede ocultar por nombre u ocultar por nombre y por firma.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo anidadoNested Type NoNo NoNo
Propiedad.Property No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
  1. Ocultar por nombre y firma tiene en cuenta todas las partes de la firma, incluidos los modificadores personalizados, los tipos de valor devuelto, los tipos de parámetros, los Sentinel y las convenciones de llamada no administradas.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Esta es una comparación binaria.This is a binary comparison.

  2. En la reflexión, las propiedades y los eventos son Hide-by-Name y Signature.For reflection, properties and events are hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de la clase derivada oculta la propiedad de clase base y no podrá tener acceso al establecedor en la clase base.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Los atributos personalizados no forman parte del sistema de tipos comunes.Custom attributes are not part of the common type system.

No se buscan matrices ni tipos COM a menos que ya se hayan cargado en la tabla de clases disponibles.Arrays or COM types are not searched for unless they have already been loaded into the table of available classes.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre calificado con el ensamblado que incluya una especificación de nombre de ensamblado.typeName can be the type name qualified by its namespace or an assembly-qualified name that includes an assembly name specification. Vea AssemblyQualifiedName.See AssemblyQualifiedName.

Si typeName incluye el espacio de nombres pero no el nombre del ensamblado, este método solo busca en el ensamblado del objeto que realiza la llamada y mscorlib. dll, en ese orden.If typeName includes the namespace but not the assembly name, this method searches only the calling object's assembly and Mscorlib.dll, in that order. Si typeName está completo con el nombre de ensamblado parcial o completo, este método busca en el ensamblado especificado.If typeName is fully qualified with the partial or complete assembly name, this method searches in the specified assembly. Si el ensamblado tiene un nombre seguro, se requiere un nombre de ensamblado completo.If the assembly has a strong name, a complete assembly name is required.

La propiedad AssemblyQualifiedName devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre de ensamblado y los argumentos de tipo genérico.The AssemblyQualifiedName property returns a fully qualified type name including nested types, the assembly name, and generic type arguments. Todos los compiladores que admiten la Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construirá un nombre alterado cuando se realice la consulta, de acuerdo con las convenciones siguientes.All compilers that support the common language runtime will emit the simple name of a nested class, and reflection constructs a mangled name when queried, in accordance with the following conventions.

Nota

En la versión .NET Framework 2,0, se agrega la arquitectura de procesador a la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado.In the .NET Framework version 2.0, processor architecture is added to assembly identity, and can be specified as part of assembly name strings. Por ejemplo, "ProcessorArchitecture = MSIL".For example, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la propiedad AssemblyQualifiedName, por motivos de compatibilidad.However, it is not included in the string returned by the AssemblyQualifiedName property, for compatibility reasons. También puede cargar tipos si crea un objeto AssemblyName y lo pasa a una sobrecarga adecuada del método Load.You can also load types by creating an AssemblyName object and passing it to an appropriate overload of the Load method. A continuación, puede utilizar el método Assembly.GetType para cargar los tipos del ensamblado.You can then use the Assembly.GetType method to load types from the assembly. Vea también AssemblyName.ProcessorArchitecture.See also AssemblyName.ProcessorArchitecture.

DelimiterDelimiter SignificadoMeaning
Barra diagonal inversa (\)Backslash (\) Carácter de escape.Escape character.
Acento grave (')Backtick (`) Precede a uno o más dígitos que representan el número de parámetros de tipo, que se encuentra al final del nombre de un tipo genérico.Precedes one or more digits representing the number of type parameters, located at the end of the name of a generic type.
Corchetes ([])Brackets ([]) 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 el ensamblado.Enclose a generic type argument list, for a constructed generic type; within a type argument list, enclose an assembly-qualified type.
Coma (,)Comma (,) Precede al nombre del ensamblado.Precedes the Assembly name.
Punto (.)Period (.) Denota los identificadores de espacio de nombres.Denotes namespace identifiers.
Signo más (+)Plus sign (+) Precede a una clase anidada.Precedes a nested class.

Por ejemplo, el nombre completo de una clase podría tener el siguiente aspecto:For example, the fully qualified name for a class might look like this:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  

Si el espacio de nombres fuera del espacio de nombres. sub + namespace, la cadena tendría que preceder el signo más (+) con un carácter de escape (\) para evitar que se interprete como un separador de anidamiento.If the namespace were TopNamespace.Sub+Namespace, then the string would have to precede the plus sign (+) with an escape character (\) to prevent it from being interpreted as a nesting separator. La reflexión emite esta cadena de la siguiente manera:Reflection emits this string as follows:

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

Un "+ +" se convierte en "\+\+" y un "\" se convierte en "\\".A "++" becomes "\+\+", and a "\" becomes "\\".

Este nombre completo puede persistir y usarse más adelante para cargar el Type.This qualified name can be persisted and later used to load the Type. Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo calificado con el ensamblado.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetType con el nombre de tipo solo buscará el Type en el ensamblado del llamador y, a continuación, en el ensamblado del sistema.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetType con el nombre de tipo calificado con el ensamblado buscará el Type en cualquier ensamblado.GetType with the assembly qualified type name will look for the Type in any assembly.

Los nombres de tipo pueden incluir caracteres finales que denotan información adicional sobre el tipo, como, por ejemplo, si el tipo es un tipo de referencia, un tipo de puntero o un tipo de matriz.Type names may include trailing characters that denote additional information about the type, such as whether the type is a reference type, a pointer type or an array type. Para recuperar el nombre de tipo sin estos caracteres finales, utilice t.GetElementType().ToString(), donde t es el tipo.To retrieve the type name without these trailing characters, use t.GetElementType().ToString(), where t is the type.

Los espacios son relevantes en todos los componentes de nombre de tipo excepto en el nombre de ensamblado.Spaces are relevant in all type name components except the assembly name. En el nombre del ensamblado, los espacios antes del separador "," son relevantes, pero los espacios después del separador "," se omiten.In the assembly name, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

El nombre de un tipo genérico finaliza con un acento grave (`) seguido de dígitos que representan el número de argumentos de tipo genérico.The name of a generic type ends with a backtick (`) followed by digits representing the number of generic type arguments. El propósito de este cambio de nombre es permitir que los compiladores admitan tipos genéricos con el mismo nombre pero con diferentes números de parámetros de tipo, que se producen en el mismo ámbito.The purpose of this name mangling is to allow compilers to support generic types with the same name but with different numbers of type parameters, occurring in the same scope. Por ejemplo, la reflexión devuelve los nombres alterados Tuple1andtupla2 de los métodos genéricos Tuple(Of T) y Tuple(Of T0, T1) en Visual Basic, o Tuple<T> y\<T0, T1> de C#tupla en visual.For example, reflection returns the mangled names Tuple1andTuple2 from the generic methods Tuple(Of T) and Tuple(Of T0, T1) in Visual Basic, or Tuple<T> and Tuple\<T0, T1> in Visual C#.

En el caso de los tipos genéricos, la lista de argumentos de tipo se incluye entre corchetes y los argumentos de tipo se separan mediante comas.For generic types, the type argument list is enclosed in brackets, and the type arguments are separated by commas. Por ejemplo, un Dictionary<TKey,TValue> genérico tiene dos parámetros de tipo.For example, a generic Dictionary<TKey,TValue> has two type parameters. Un Dictionary<TKey,TValue> de MyType con claves de tipo String podría representarse de la siguiente manera:A Dictionary<TKey,TValue> of MyType with keys of type String might be represented as follows:

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

Para especificar un tipo calificado con el ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado con el ensamblado entre corchetes.To specify an assembly-qualified type within a type argument list, enclose the assembly-qualified type within brackets. De lo contrario, las comas que separan las partes del nombre calificado con el ensamblado se interpretan como delimitando los argumentos de tipo adicionales.Otherwise, the commas that separate the parts of the assembly-qualified name are interpreted as delimiting additional type arguments. Por ejemplo, un Dictionary<TKey,TValue> de MyType fromMyAssembly. dll, con claves de tipo String, podría especificarse de la siguiente manera:For example, a Dictionary<TKey,TValue> of MyType fromMyAssembly.dll, with keys of type String, might be specified as follows:

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

Nota

Un tipo calificado con el ensamblado solo se puede incluir entre corchetes cuando aparece dentro de una lista de parámetros de tipo.An assembly-qualified type can be enclosed in brackets only when it appears within a type parameter list. Las reglas para buscar en los ensamblados los tipos calificados e incompletos en las listas de parámetros de tipo son las mismas que las reglas de los tipos no genéricos completos y sin calificar.The rules for searching assemblies for qualified and unqualified types in type parameter lists are the same as the rules for qualified and unqualified nongeneric types.

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos.Nullable types are a special case of generic types. Por ejemplo, un Int32 que acepta valores NULL se representa mediante la cadena "System. Nullable ' 1 [System. Int32]".For example, a nullable Int32 is represented by the string "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.In C#, C++, and Visual Basic you can also get nullable types using type operators. Por ejemplo, el tipo de Boolean que acepta valores NULL se devuelve C#por typeof(Nullable<bool>) en, C++Nullable<Boolean>::typeid en y GetType(Nullable(Of Boolean)) en Visual Basic.For example, the nullable Boolean type is returned by typeof(Nullable<bool>) in C#, by Nullable<Boolean>::typeid in C++, and by GetType(Nullable(Of Boolean)) in Visual Basic.

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.The following table shows the syntax you use with GetType for various types.

Para obtenerTo Get UsarUse
Un Int32 que acepta valores NULLA nullable Int32 Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a MyTypeAn unmanaged pointer to MyType Type.GetType("MyType*")
Puntero no administrado a un puntero a MyTypeAn unmanaged pointer to a pointer to MyType Type.GetType("MyType**")
Puntero administrado o referencia a MyTypeA managed pointer or reference to MyType Type.GetType("MyType&").Type.GetType("MyType&"). Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.Note that unlike pointers, references are limited to one level.
Una clase primaria y una clase anidadaA parent class and a nested class Type.GetType("MyParentClass+MyNestedClass")
Matriz unidimensional con un límite inferior de 0A one-dimensional array with a lower bound of 0 Type.GetType("MyType[]")
Matriz unidimensional con un límite inferior desconocido.A one-dimensional array with an unknown lower bound Type.GetType("MyType[*]")
Una matriz de n dimensionesAn n-dimensional array Una coma (,) dentro de los corchetes un total de n-1 veces.A comma (,) inside the brackets a total of n-1 times. Por ejemplo, System.Object[,,] representa una matriz de Object tridimensional.For example, System.Object[,,] represents a three-dimensional Object array.
Matriz de Matrices unidimensionalesAn array of one-dimensional arrays Type.GetType("MyType[][]")
Matriz bidimensional rectangular con límites inferiores desconocidosA rectangular two-dimensional array with unknown lower bounds Type.GetType("MyType[,]")
Un tipo genérico con un argumento de tipoA generic type with one type argument Type.GetType("MyGenericType`1[MyType]")
Tipo genérico con dos argumentos de tipoA generic type with two type arguments Type.GetType("MyGenericType`2[MyType,AnotherType]")
Un tipo genérico con dos argumentos de tipo calificado con el ensambladoA generic type with two assembly-qualified type arguments Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado con el ensamblado con un argumento de tipo calificado con el ensambladoAn assembly-qualified generic type with an assembly-qualified type argument Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipoA generic type whose type argument is a generic type with two type arguments Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también:

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.Gets the Type with the specified name, performing a case-sensitive search and specifying whether to throw an exception if the type is not found.

public:
 static Type ^ GetType(System::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

Nombre calificado con el ensamblado del tipo que se va a obtener.The assembly-qualified name of the type to get. Vea AssemblyQualifiedName.See AssemblyQualifiedName. Si el tipo está en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, es suficiente para proporcionar el nombre completo del tipo por su espacio de nombres.If the type is in the currently executing assembly or in Mscorlib.dll, it is sufficient to supply the type name qualified by its namespace.

throwOnError
Boolean

Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null.true to throw an exception if the type cannot be found; false to return null. Si se especifica false se suprimen otras condiciones de excepción, pero no todas.Specifying false also suppresses some other exception conditions, but not all of them. Vea la sección Excepciones.See the Exceptions section.

Devoluciones

Tipo con el nombre especificado.The type with the specified name. Si el tipo no se encuentra, el parámetro throwOnError especifica si se devuelve null o se produce una excepción.If the type is not found, the throwOnError parameter specifies whether null is returned or an exception is thrown. En algunos casos, se produce una excepción con independencia del valor de throwOnError.In some cases, an exception is thrown regardless of the value of throwOnError. Vea la sección Excepciones.See the Exceptions section.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

throwOnError es true y no se encuentra el tipo.throwOnError is true and the type is not found.

O bien-or- throwOnError es true y typeName contiene caracteres no válidos, como una pestaña insertada.throwOnError is true and typeName contains invalid characters, such as an embedded tab. o bien-or- throwOnError es true y typeName es una cadena vacía.throwOnError is true and typeName is an empty string.

o bien-or- throwOnError es true y typeName representa un tipo de matriz con un tamaño no válido.throwOnError is true and typeName represents an array type with an invalid size.

o bien-or- typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

throwOnError es true y typeName contiene sintaxis no válida.throwOnError is true and typeName contains invalid syntax. Por ejemplo: "MyType[,*,]".For example, "MyType[,*,]".

O bien-or- typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

o bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

o bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

throwOnError es true y no se encontró el ensamblado o alguna de sus dependencias.throwOnError is true and the assembly or one of its dependencies was not found.

En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, capture en su lugar la excepción de clase base, IOException.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, IOException, instead.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

O bien-or-

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.Version 2.0 or later of the common language runtime is currently loaded, and the assembly was compiled with a later version.

Ejemplos

En el ejemplo siguiente se recupera el tipo de System.Int32 y se utiliza ese objeto de tipo para mostrar la propiedad FullName de System.Int32.The following example retrieves the type of System.Int32 and uses that type object to display the FullName property of System.Int32. Si un objeto de tipo hace referencia a un ensamblado que no existe, este ejemplo produce una excepción.If a type object refers to an assembly that does not exist, this example throws an exception.

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
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 método GetType para obtener un objeto Type para un tipo de otro ensamblado si conoce su nombre calificado con el ensamblado, que se puede obtener de AssemblyQualifiedName.You can use the GetType method to obtain a Type object for a type in another assembly if you know its assembly-qualified name, which can be obtained from AssemblyQualifiedName. GetType provoca la carga del ensamblado especificado en typeName.GetType causes loading of the assembly specified in typeName. También puede cargar un ensamblado mediante el método Assembly.Load y, a continuación, usar el método Assembly.GetType o Assembly.GetTypes para obtener objetos Type.You can also load an assembly using the Assembly.Load method, and then use the Assembly.GetType or Assembly.GetTypes method to get Type objects. 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 operador GetType de Visual Basic.If a type is in an assembly known to your program at compile time, it is more efficient to use typeof in C# or the GetType operator in Visual Basic.

GetType solo funciona en ensamblados cargados desde el disco.GetType only works on assemblies loaded from disk. Si llama a GetType para buscar un tipo definido en un ensamblado dinámico definido mediante los servicios System.Reflection.Emit, podría obtener un comportamiento incoherente.If you call GetType to look up a type defined in a dynamic assembly defined using the System.Reflection.Emit services, you might get inconsistent behavior. El comportamiento depende de si el ensamblado dinámico es persistente, es decir, se crea mediante los modos de acceso RunAndSave o Save de la enumeración System.Reflection.Emit.AssemblyBuilderAccess.The behavior depends on whether the dynamic assembly is persistent, that is, created using the RunAndSave or Save access modes of the System.Reflection.Emit.AssemblyBuilderAccess enumeration. Si el ensamblado dinámico es persistente y se ha escrito en el disco antes de que se llame a GetType, el cargador busca el ensamblado guardado en el disco, lo carga y recupera el tipo de ese ensamblado.If the dynamic assembly is persistent and has been written to disk before GetType is called, the loader finds the saved assembly on disk, loads that assembly, and retrieves the type from that assembly. Si el ensamblado no se ha guardado en el disco cuando se llama a GetType, el método devuelve null.If the assembly has not been saved to disk when GetType is called, the method returns null. GetType no entiende los ensamblados dinámicos transitorios; por lo tanto, llamar a GetType para recuperar un tipo de un ensamblado dinámico transitorio devuelve null.GetType does not understand transient dynamic assemblies; therefore, calling GetType to retrieve a type in a transient dynamic assembly returns null.

Para usar GetType en un módulo dinámico, suscríbase al evento de AppDomain.AssemblyResolve y llame a GetType antes de guardar.To use GetType on a dynamic module, subscribe to the AppDomain.AssemblyResolve event and call GetType before saving. De lo contrario, obtendrá dos copias del ensamblado en la memoria.Otherwise, you will get two copies of the assembly in memory.

El parámetro throwOnError especifica lo que ocurre cuando no se encuentra el tipo y también suprime algunas otras condiciones de excepción, tal y como se describe en la sección excepciones.The throwOnError parameter specifies what happens when the type is not found, and also suppresses certain other exception conditions, as described in the Exceptions section. Algunas excepciones se producen independientemente del valor de throwOnError.Some exceptions are thrown regardless of the value of throwOnError. Por ejemplo, si se encuentra el tipo pero no se puede cargar, se produce una TypeLoadException incluso si se false``throwOnError.For example, if the type is found but cannot be loaded, a TypeLoadException is thrown even if throwOnError is false.

En la tabla siguiente se muestra qué miembros de una clase base son devueltos por los métodos Get al reflejar en un tipo.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo de miembroMember Type EstáticoStatic No estáticaNon-Static
ConstructorConstructor NoNo NoNo
CampoField NoNo Sí.Yes. Un campo siempre se oculta por nombre y firma.A field is always hide-by-name-and-signature.
eventoEvent No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
MétodoMethod NoNo Sí.Yes. Un método (tanto virtual como no virtual) se puede ocultar por nombre u ocultar por nombre y por firma.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo anidadoNested Type NoNo NoNo
Propiedad.Property No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
  1. Ocultar por nombre y firma tiene en cuenta todas las partes de la firma, incluidos los modificadores personalizados, los tipos de valor devuelto, los tipos de parámetros, los Sentinel y las convenciones de llamada no administradas.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Esta es una comparación binaria.This is a binary comparison.

  2. En la reflexión, las propiedades y los eventos son Hide-by-Name y Signature.For reflection, properties and events are hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de la clase derivada oculta la propiedad de clase base y no podrá tener acceso al establecedor en la clase base.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Los atributos personalizados no forman parte del sistema de tipos comunes.Custom attributes are not part of the common type system.

No se buscan matrices ni tipos COM a menos que ya se hayan cargado en la tabla de clases disponibles.Arrays or COM types are not searched for unless they have already been loaded into the table of available classes.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre calificado con el ensamblado que incluya una especificación de nombre de ensamblado.typeName can be the type name qualified by its namespace or an assembly-qualified name that includes an assembly name specification. Vea AssemblyQualifiedName.See AssemblyQualifiedName.

Si typeName incluye el espacio de nombres pero no el nombre del ensamblado, este método solo busca en el ensamblado del objeto que realiza la llamada y mscorlib. dll, en ese orden.If typeName includes the namespace but not the assembly name, this method searches only the calling object's assembly and Mscorlib.dll, in that order. Si typeName está completo con el nombre de ensamblado parcial o completo, este método busca en el ensamblado especificado.If typeName is fully qualified with the partial or complete assembly name, this method searches in the specified assembly. Si el ensamblado tiene un nombre seguro, se requiere un nombre de ensamblado completo.If the assembly has a strong name, a complete assembly name is required.

La propiedad AssemblyQualifiedName devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre de ensamblado y los argumentos genéricos.The AssemblyQualifiedName property returns a fully qualified type name including nested types, the assembly name, and generic arguments. Todos los compiladores que admiten la Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construirá un nombre alterado cuando se realice la consulta, de acuerdo con las convenciones siguientes.All compilers that support the common language runtime will emit the simple name of a nested class, and reflection constructs a mangled name when queried, in accordance with the following conventions.

Nota

En la versión .NET Framework 2,0, se agrega la arquitectura de procesador a la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado.In the .NET Framework version 2.0, processor architecture is added to assembly identity, and can be specified as part of assembly name strings. Por ejemplo, "ProcessorArchitecture = MSIL".For example, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la propiedad AssemblyQualifiedName, por motivos de compatibilidad.However, it is not included in the string returned by the AssemblyQualifiedName property, for compatibility reasons. También puede cargar tipos si crea un objeto AssemblyName y lo pasa a una sobrecarga adecuada del método Load.You can also load types by creating an AssemblyName object and passing it to an appropriate overload of the Load method. A continuación, puede utilizar el método Assembly.GetType para cargar los tipos del ensamblado.You can then use the Assembly.GetType method to load types from the assembly. Vea también AssemblyName.ProcessorArchitecture.See also AssemblyName.ProcessorArchitecture.

DelimiterDelimiter SignificadoMeaning
Barra diagonal inversa (\)Backslash (\) Carácter de escape.Escape character.
Acento grave (')Backtick (`) Precede a uno o más dígitos que representan el número de parámetros de tipo, que se encuentra al final del nombre de un tipo genérico.Precedes one or more digits representing the number of type parameters, located at the end of the name of a generic type.
Corchetes ([])Brackets ([]) 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 el ensamblado.Enclose a generic type argument list, for a constructed generic type; within a type argument list, enclose an assembly-qualified type.
Coma (,)Comma (,) Precede al nombre del ensamblado.Precedes the Assembly name.
Punto (.)Period (.) Denota los identificadores de espacio de nombres.Denotes namespace identifiers.
Signo más (+)Plus sign (+) Precede a una clase anidada.Precedes a nested class.

Por ejemplo, el nombre completo de una clase podría tener el siguiente aspecto:For example, the fully qualified name for a class might look like this:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  

Si el espacio de nombres fuera del espacio de nombres. sub + namespace, la cadena tendría que preceder el signo más (+) con un carácter de escape (\) para evitar que se interprete como un separador de anidamiento.If the namespace were TopNamespace.Sub+Namespace, then the string would have to precede the plus sign (+) with an escape character (\) to prevent it from being interpreted as a nesting separator. La reflexión emite esta cadena de la siguiente manera:Reflection emits this string as follows:

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

Un "+ +" se convierte en "\+\+" y un "\" se convierte en "\\".A "++" becomes "\+\+", and a "\" becomes "\\".

Este nombre completo puede persistir y usarse más adelante para cargar el Type.This qualified name can be persisted and later used to load the Type. Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo calificado con el ensamblado.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetType con el nombre de tipo solo buscará el Type en el ensamblado del llamador y, a continuación, en el ensamblado del sistema.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetType con el nombre de tipo calificado con el ensamblado buscará el Type en cualquier ensamblado.GetType with the assembly qualified type name will look for the Type in any assembly.

Los nombres de tipo pueden incluir caracteres finales que denotan información adicional sobre el tipo, como, por ejemplo, si el tipo es un tipo de referencia, un tipo de puntero o un tipo de matriz.Type names may include trailing characters that denote additional information about the type, such as whether the type is a reference type, a pointer type or an array type. Para recuperar el nombre de tipo sin estos caracteres finales, utilice t.GetElementType().ToString(), donde t es el tipo.To retrieve the type name without these trailing characters, use t.GetElementType().ToString(), where t is the type.

Los espacios son relevantes en todos los componentes de nombre de tipo excepto en el nombre de ensamblado.Spaces are relevant in all type name components except the assembly name. En el nombre del ensamblado, los espacios antes del separador "," son relevantes, pero los espacios después del separador "," se omiten.In the assembly name, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

El nombre de un tipo genérico finaliza con un acento grave (`) seguido de dígitos que representan el número de argumentos de tipo genérico.The name of a generic type ends with a backtick (`) followed by digits representing the number of generic type arguments. El propósito de este cambio de nombre es permitir que los compiladores admitan tipos genéricos con el mismo nombre pero con diferentes números de parámetros de tipo, que se producen en el mismo ámbito.The purpose of this name mangling is to allow compilers to support generic types with the same name but with different numbers of type parameters, occurring in the same scope. Por ejemplo, la reflexión devuelve los nombres alterados Tuple1andtupla2 de los métodos genéricos Tuple(Of T) y Tuple(Of T0, T1) en Visual Basic, o Tuple<T> y\<T0, T1> de C#tupla en visual.For example, reflection returns the mangled names Tuple1andTuple2 from the generic methods Tuple(Of T) and Tuple(Of T0, T1) in Visual Basic, or Tuple<T> and Tuple\<T0, T1> in Visual C#.

En el caso de los tipos genéricos, la lista de argumentos de tipo se incluye entre corchetes y los argumentos de tipo se separan mediante comas.For generic types, the type argument list is enclosed in brackets, and the type arguments are separated by commas. Por ejemplo, un Dictionary<TKey,TValue> genérico tiene dos parámetros de tipo.For example, a generic Dictionary<TKey,TValue> has two type parameters. Un Dictionary<TKey,TValue> de MyType con claves de tipo String podría representarse de la siguiente manera:A Dictionary<TKey,TValue> of MyType with keys of type String might be represented as follows:

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

Para especificar un tipo calificado con el ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado con el ensamblado entre corchetes.To specify an assembly-qualified type within a type argument list, enclose the assembly-qualified type within brackets. De lo contrario, las comas que separan las partes del nombre calificado con el ensamblado se interpretan como delimitando los argumentos de tipo adicionales.Otherwise, the commas that separate the parts of the assembly-qualified name are interpreted as delimiting additional type arguments. Por ejemplo, un Dictionary<TKey,TValue> de MyType de myAssembly. dll, con claves de tipo String, podría especificarse de la siguiente manera:For example, a Dictionary<TKey,TValue> of MyType from MyAssembly.dll, with keys of type String, might be specified as follows:

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

Nota

Un tipo calificado con el ensamblado solo se puede incluir entre corchetes cuando aparece dentro de una lista de parámetros de tipo.An assembly-qualified type can be enclosed in brackets only when it appears within a type parameter list. Las reglas para buscar en los ensamblados los tipos calificados e incompletos en las listas de parámetros de tipo son las mismas que las reglas de los tipos no genéricos completos y sin calificar.The rules for searching assemblies for qualified and unqualified types in type parameter lists are the same as the rules for qualified and unqualified nongeneric types.

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos.Nullable types are a special case of generic types. Por ejemplo, un Int32 que acepta valores NULL se representa mediante la cadena "System. Nullable ' 1 [System. Int32]".For example, a nullable Int32 is represented by the string "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.In C#, C++, and Visual Basic you can also get nullable types using type operators. Por ejemplo, el tipo de Boolean que acepta valores NULL se devuelve C#por typeof(Nullable<bool>) en, C++Nullable<Boolean>::typeid en y GetType(Nullable(Of Boolean)) en Visual Basic.For example, the nullable Boolean type is returned by typeof(Nullable<bool>) in C#, by Nullable<Boolean>::typeid in C++, and by GetType(Nullable(Of Boolean)) in Visual Basic.

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.The following table shows the syntax you use with GetType for various types.

Para obtenerTo Get UsarUse
Un Int32 que acepta valores NULLA nullable Int32 Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a MyTypeAn unmanaged pointer to MyType Type.GetType("MyType*")
Puntero no administrado a un puntero a MyTypeAn unmanaged pointer to a pointer to MyType Type.GetType("MyType**")
Puntero administrado o referencia a MyTypeA managed pointer or reference to MyType Type.GetType("MyType&").Type.GetType("MyType&"). Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.Note that unlike pointers, references are limited to one level.
Una clase primaria y una clase anidadaA parent class and a nested class Type.GetType("MyParentClass+MyNestedClass")
Matriz unidimensional con un límite inferior de 0A one-dimensional array with a lower bound of 0 Type.GetType("MyArray[]")
Matriz unidimensional con un límite inferior desconocido.A one-dimensional array with an unknown lower bound Type.GetType("MyArray[*]")
Una matriz de n dimensionesAn n-dimensional array Una coma (,) dentro de los corchetes un total de n-1 veces.A comma (,) inside the brackets a total of n-1 times. Por ejemplo, System.Object[,,] representa una matriz de Object tridimensional.For example, System.Object[,,] represents a three-dimensional Object array.
Matriz de una matriz bidimensionalA two-dimensional array's array Type.GetType("MyArray[][]")
Matriz bidimensional rectangular con límites inferiores desconocidosA rectangular two-dimensional array with unknown lower bounds Type.GetType("MyArray[,]")
Un tipo genérico con un argumento de tipoA generic type with one type argument Type.GetType("MyGenericType`1[MyType]")
Tipo genérico con dos argumentos de tipoA generic type with two type arguments Type.GetType("MyGenericType`2[MyType,AnotherType]")
Un tipo genérico con dos argumentos de tipo calificado con el ensambladoA generic type with two assembly-qualified type arguments Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado con el ensamblado con un argumento de tipo calificado con el ensambladoAn assembly-qualified generic type with an assembly-qualified type argument Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipoA generic type whose type argument is a generic type with two type arguments Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también:

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.Gets the Type with the specified name, specifying whether to throw an exception if the type is not found and whether to perform a case-sensitive search.

public:
 static Type ^ GetType(System::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

Nombre calificado con el ensamblado del tipo que se va a obtener.The assembly-qualified name of the type to get. Vea AssemblyQualifiedName.See AssemblyQualifiedName. Si el tipo está en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, es suficiente para proporcionar el nombre completo del tipo por su espacio de nombres.If the type is in the currently executing assembly or in Mscorlib.dll, it is sufficient to supply the type name qualified by its namespace.

throwOnError
Boolean

Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null.true to throw an exception if the type cannot be found; false to return null. Si se especifica false se suprimen otras condiciones de excepción, pero no todas.Specifying false also suppresses some other exception conditions, but not all of them. Vea la sección Excepciones.See the Exceptions section.

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.true to perform a case-insensitive search for typeName, false to perform a case-sensitive search for typeName.

Devoluciones

Tipo con el nombre especificado.The type with the specified name. Si el tipo no se encuentra, el parámetro throwOnError especifica si se devuelve null o se produce una excepción.If the type is not found, the throwOnError parameter specifies whether null is returned or an exception is thrown. En algunos casos, se produce una excepción con independencia del valor de throwOnError.In some cases, an exception is thrown regardless of the value of throwOnError. Vea la sección Excepciones.See the Exceptions section.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

throwOnError es true y no se encuentra el tipo.throwOnError is true and the type is not found.

o bien-or- throwOnError es true y typeName contiene caracteres no válidos, como una pestaña insertada.throwOnError is true and typeName contains invalid characters, such as an embedded tab. o bien-or- throwOnError es true y typeName es una cadena vacía.throwOnError is true and typeName is an empty string.

o bien-or- throwOnError es true y typeName representa un tipo de matriz con un tamaño no válido.throwOnError is true and typeName represents an array type with an invalid size.

o bien-or- typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

throwOnError es true y typeName contiene sintaxis no válida.throwOnError is true and typeName contains invalid syntax. Por ejemplo: "MyType[,*,]".For example, "MyType[,*,]".

o bien-or- typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

O bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

o bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

throwOnError es true y no se encontró el ensamblado o alguna de sus dependencias.throwOnError is true and the assembly or one of its dependencies was not found.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

o bien-or-

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.Version 2.0 or later of the common language runtime is currently loaded, and the assembly was compiled with a later version.

Comentarios

Puede usar el método GetType para obtener un objeto Type para un tipo de otro ensamblado si conoce su nombre calificado con el ensamblado, que se puede obtener de AssemblyQualifiedName.You can use the GetType method to obtain a Type object for a type in another assembly if you know its assembly-qualified name, which can be obtained from AssemblyQualifiedName. GetType provoca la carga del ensamblado especificado en typeName.GetType causes loading of the assembly specified in typeName. También puede cargar un ensamblado mediante el método Assembly.Load y, a continuación, usar el método Assembly.GetType o Assembly.GetTypes para obtener objetos Type.You can also load an assembly using the Assembly.Load method, and then use the Assembly.GetType or Assembly.GetTypes method to get Type objects. 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 operador GetType de Visual Basic.If a type is in an assembly known to your program at compile time, it is more efficient to use typeof in C# or the GetType operator in Visual Basic.

GetType solo funciona en ensamblados cargados desde el disco.GetType only works on assemblies loaded from disk. Si llama a GetType para buscar un tipo definido en un ensamblado dinámico definido mediante los servicios System.Reflection.Emit, podría obtener un comportamiento incoherente.If you call GetType to look up a type defined in a dynamic assembly defined using the System.Reflection.Emit services, you might get inconsistent behavior. El comportamiento depende de si el ensamblado dinámico es persistente, es decir, se crea mediante los modos de acceso RunAndSave o Save de la enumeración System.Reflection.Emit.AssemblyBuilderAccess.The behavior depends on whether the dynamic assembly is persistent, that is, created using the RunAndSave or Save access modes of the System.Reflection.Emit.AssemblyBuilderAccess enumeration. Si el ensamblado dinámico es persistente y se ha escrito en el disco antes de que se llame a GetType, el cargador busca el ensamblado guardado en el disco, lo carga y recupera el tipo de ese ensamblado.If the dynamic assembly is persistent and has been written to disk before GetType is called, the loader finds the saved assembly on disk, loads that assembly, and retrieves the type from that assembly. Si el ensamblado no se ha guardado en el disco cuando se llama a GetType, el método devuelve null.If the assembly has not been saved to disk when GetType is called, the method returns null. GetType no entiende los ensamblados dinámicos transitorios; por lo tanto, llamar a GetType para recuperar un tipo de un ensamblado dinámico transitorio devuelve null.GetType does not understand transient dynamic assemblies; therefore, calling GetType to retrieve a type in a transient dynamic assembly returns null.

Para usar GetType en un módulo dinámico, suscríbase al evento de AppDomain.AssemblyResolve y llame a GetType antes de guardar.To use GetType on a dynamic module, subscribe to the AppDomain.AssemblyResolve event and call GetType before saving. De lo contrario, obtendrá dos copias del ensamblado en la memoria.Otherwise, you will get two copies of the assembly in memory.

El parámetro throwOnError especifica lo que ocurre cuando no se encuentra el tipo y también suprime algunas otras condiciones de excepción, tal y como se describe en la sección excepciones.The throwOnError parameter specifies what happens when the type is not found, and also suppresses certain other exception conditions, as described in the Exceptions section. Algunas excepciones se producen independientemente del valor de throwOnError.Some exceptions are thrown regardless of the value of throwOnError. Por ejemplo, si se encuentra el tipo pero no se puede cargar, se produce una TypeLoadException incluso si se false``throwOnError.For example, if the type is found but cannot be loaded, a TypeLoadException is thrown even if throwOnError is false.

En la tabla siguiente se muestra qué miembros de una clase base son devueltos por los métodos Get al reflejar en un tipo.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo de miembroMember Type EstáticoStatic No estáticaNon-Static
ConstructorConstructor NoNo NoNo
CampoField NoNo Sí.Yes. Un campo siempre se oculta por nombre y firma.A field is always hide-by-name-and-signature.
eventoEvent No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
MétodoMethod NoNo Sí.Yes. Un método (tanto virtual como no virtual) se puede ocultar por nombre u ocultar por nombre y por firma.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo anidadoNested Type NoNo NoNo
Propiedad.Property No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
  1. Ocultar por nombre y firma tiene en cuenta todas las partes de la firma, incluidos los modificadores personalizados, los tipos de valor devuelto, los tipos de parámetros, los Sentinel y las convenciones de llamada no administradas.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Esta es una comparación binaria.This is a binary comparison.

  2. En la reflexión, las propiedades y los eventos son Hide-by-Name y Signature.For reflection, properties and events are hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de la clase derivada oculta la propiedad de clase base y no podrá tener acceso al establecedor en la clase base.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Los atributos personalizados no forman parte del sistema de tipos comunes.Custom attributes are not part of the common type system.

No se buscan matrices ni tipos COM a menos que ya se hayan cargado en la tabla de clases disponibles.Arrays or COM types are not searched for unless they have already been loaded into the table of available classes.

typeName puede ser el nombre de tipo calificado por su espacio de nombres o un nombre calificado con el ensamblado que incluya una especificación de nombre de ensamblado.typeName can be the type name qualified by its namespace or an assembly-qualified name that includes an assembly name specification. Vea AssemblyQualifiedName.See AssemblyQualifiedName.

Si typeName incluye el espacio de nombres pero no el nombre del ensamblado, este método solo busca en el ensamblado del objeto que realiza la llamada y mscorlib. dll, en ese orden.If typeName includes the namespace but not the assembly name, this method searches only the calling object's assembly and Mscorlib.dll, in that order. Si typeName está completo con el nombre de ensamblado parcial o completo, este método busca en el ensamblado especificado.If typeName is fully qualified with the partial or complete assembly name, this method searches in the specified assembly. Si el ensamblado tiene un nombre seguro, se requiere un nombre de ensamblado completo.If the assembly has a strong name, a complete assembly name is required.

La propiedad AssemblyQualifiedName devuelve un nombre de tipo completo, incluidos los tipos anidados, el nombre de ensamblado y los argumentos de tipo.The AssemblyQualifiedName property returns a fully qualified type name including nested types, the assembly name, and type arguments. Todos los compiladores que admiten la Common Language Runtime emitirán el nombre simple de una clase anidada y la reflexión construirá un nombre alterado cuando se realice la consulta, de acuerdo con las convenciones siguientes.All compilers that support the common language runtime will emit the simple name of a nested class, and reflection constructs a mangled name when queried, in accordance with the following conventions.

Nota

En la versión .NET Framework 2,0, se agrega la arquitectura de procesador a la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado.In the .NET Framework version 2.0, processor architecture is added to assembly identity, and can be specified as part of assembly name strings. Por ejemplo, "ProcessorArchitecture = MSIL".For example, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por la propiedad AssemblyQualifiedName, por motivos de compatibilidad.However, it is not included in the string returned by the AssemblyQualifiedName property, for compatibility reasons. También puede cargar tipos si crea un objeto AssemblyName y lo pasa a una sobrecarga adecuada del método Load.You can also load types by creating an AssemblyName object and passing it to an appropriate overload of the Load method. A continuación, puede utilizar el método Assembly.GetType para cargar los tipos del ensamblado.You can then use the Assembly.GetType method to load types from the assembly. Vea también AssemblyName.ProcessorArchitecture.See also AssemblyName.ProcessorArchitecture.

DelimiterDelimiter SignificadoMeaning
Barra diagonal inversa (\)Backslash (\) Carácter de escape.Escape character.
Acento grave (')Backtick (`) Precede a uno o más dígitos que representan el número de parámetros de tipo, que se encuentra al final del nombre de un tipo genérico.Precedes one or more digits representing the number of type parameters, located at the end of the name of a generic type.
Corchetes ([])Brackets ([]) 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 el ensamblado.Enclose a generic type argument list, for a constructed generic type; within a type argument list, enclose an assembly-qualified type.
Coma (,)Comma (,) Precede al nombre del ensamblado.Precedes the Assembly name.
Punto (.)Period (.) Denota los identificadores de espacio de nombres.Denotes namespace identifiers.
Signo más (+)Plus sign (+) Precede a una clase anidada.Precedes a nested class.

Por ejemplo, el nombre completo de una clase podría tener el siguiente aspecto:For example, the fully qualified name for a class might look like this:

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  

Si el espacio de nombres fuera del espacio de nombres. sub + namespace, la cadena tendría que preceder el signo más (+) con un carácter de escape (\) para evitar que se interprete como un separador de anidamiento.If the namespace were TopNamespace.Sub+Namespace, then the string would have to precede the plus sign (+) with an escape character (\) to prevent it from being interpreted as a nesting separator. La reflexión emite esta cadena de la siguiente manera:Reflection emits this string as follows:

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

Un "+ +" se convierte en "\+\+" y un "\" se convierte en "\\".A "++" becomes "\+\+", and a "\" becomes "\\".

Este nombre completo puede persistir y usarse más adelante para cargar el Type.This qualified name can be persisted and later used to load the Type. Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo calificado con el ensamblado.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetType con el nombre de tipo solo buscará el Type en el ensamblado del llamador y, a continuación, en el ensamblado del sistema.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetType con el nombre de tipo calificado con el ensamblado buscará el Type en cualquier ensamblado.GetType with the assembly qualified type name will look for the Type in any assembly.

Los nombres de tipo pueden incluir caracteres finales que denotan información adicional sobre el tipo, como, por ejemplo, si el tipo es un tipo de referencia, un tipo de puntero o un tipo de matriz.Type names may include trailing characters that denote additional information about the type, such as whether the type is a reference type, a pointer type or an array type. Para recuperar el nombre de tipo sin estos caracteres finales, utilice t.GetElementType().ToString(), donde t es el tipo.To retrieve the type name without these trailing characters, use t.GetElementType().ToString(), where t is the type.

Los espacios son relevantes en todos los componentes de nombre de tipo excepto en el nombre de ensamblado.Spaces are relevant in all type name components except the assembly name. En el nombre del ensamblado, los espacios antes del separador "," son relevantes, pero los espacios después del separador "," se omiten.In the assembly name, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

El nombre de un tipo genérico finaliza con un acento grave (`) seguido de dígitos que representan el número de argumentos de tipo genérico.The name of a generic type ends with a backtick (`) followed by digits representing the number of generic type arguments. El propósito de este cambio de nombre es permitir que los compiladores admitan tipos genéricos con el mismo nombre pero con diferentes números de parámetros de tipo, que se producen en el mismo ámbito.The purpose of this name mangling is to allow compilers to support generic types with the same name but with different numbers of type parameters, occurring in the same scope. Por ejemplo, la reflexión devuelve los nombres alterados Tuple1andtupla2 de los métodos genéricos Tuple(Of T) y Tuple(Of T0, T1) en Visual Basic, o Tuple<T> y\<T0, T1> de C#tupla en visual.For example, reflection returns the mangled names Tuple1andTuple2 from the generic methods Tuple(Of T) and Tuple(Of T0, T1) in Visual Basic, or Tuple<T> and Tuple\<T0, T1> in Visual C#.

En el caso de los tipos genéricos, la lista de argumentos de tipo se incluye entre corchetes y los argumentos de tipo se separan mediante comas.For generic types, the type argument list is enclosed in brackets, and the type arguments are separated by commas. Por ejemplo, un Dictionary<TKey,TValue> genérico tiene dos parámetros de tipo.For example, a generic Dictionary<TKey,TValue> has two type parameters. Un Dictionary<TKey,TValue> de MyType con claves de tipo String podría representarse de la siguiente manera:A Dictionary<TKey,TValue> of MyType with keys of type String might be represented as follows:

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

Para especificar un tipo calificado con el ensamblado dentro de una lista de argumentos de tipo, incluya el tipo calificado con el ensamblado entre corchetes.To specify an assembly-qualified type within a type argument list, enclose the assembly-qualified type within brackets. De lo contrario, las comas que separan las partes del nombre calificado con el ensamblado se interpretan como delimitando los argumentos de tipo adicionales.Otherwise, the commas that separate the parts of the assembly-qualified name are interpreted as delimiting additional type arguments. Por ejemplo, un Dictionary<TKey,TValue> de MyType de myAssembly. dll, con claves de tipo String, podría especificarse de la siguiente manera:For example, a Dictionary<TKey,TValue> of MyType from MyAssembly.dll, with keys of type String, might be specified as follows:

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

Nota

Un tipo calificado con el ensamblado solo se puede incluir entre corchetes cuando aparece dentro de una lista de parámetros de tipo.An assembly-qualified type can be enclosed in brackets only when it appears within a type parameter list. Las reglas para buscar en los ensamblados los tipos calificados e incompletos en las listas de parámetros de tipo son las mismas que las reglas de los tipos no genéricos completos y sin calificar.The rules for searching assemblies for qualified and unqualified types in type parameter lists are the same as the rules for qualified and unqualified nongeneric types.

Los tipos que aceptan valores NULL son un caso especial de tipos genéricos.Nullable types are a special case of generic types. Por ejemplo, un Int32 que acepta valores NULL se representa mediante la cadena "System. Nullable ' 1 [System. Int32]".For example, a nullable Int32 is represented by the string "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.In C#, C++, and Visual Basic you can also get nullable types using type operators. Por ejemplo, el tipo de Boolean que acepta valores NULL se devuelve C#por typeof(Nullable<bool>) en, C++Nullable<Boolean>::typeid en y GetType(Nullable(Of Boolean)) en Visual Basic.For example, the nullable Boolean type is returned by typeof(Nullable<bool>) in C#, by Nullable<Boolean>::typeid in C++, and by GetType(Nullable(Of Boolean)) in Visual Basic.

En la tabla siguiente se muestra la sintaxis que se usa con GetType para varios tipos.The following table shows the syntax you use with GetType for various types.

Para obtenerTo Get UsarUse
Un Int32 que acepta valores NULLA nullable Int32 Type.GetType("System.Nullable`1[System.Int32]")
Puntero no administrado a MyTypeAn unmanaged pointer to MyType Type.GetType("MyType*")
Puntero no administrado a un puntero a MyTypeAn unmanaged pointer to a pointer to MyType Type.GetType("MyType**")
Puntero administrado o referencia a MyTypeA managed pointer or reference to MyType Type.GetType("MyType&").Type.GetType("MyType&"). Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.Note that unlike pointers, references are limited to one level.
Una clase primaria y una clase anidadaA parent class and a nested class Type.GetType("MyParentClass+MyNestedClass")
Matriz unidimensional con un límite inferior de 0A one-dimensional array with a lower bound of 0 Type.GetType("MyArray[]")
Matriz unidimensional con un límite inferior desconocido.A one-dimensional array with an unknown lower bound Type.GetType("MyArray[*]")
Una matriz de n dimensionesAn n-dimensional array Una coma (,) dentro de los corchetes un total de n-1 veces.A comma (,) inside the brackets a total of n-1 times. Por ejemplo, System.Object[,,] representa una matriz de Object tridimensional.For example, System.Object[,,] represents a three-dimensional Object array.
Matriz de una matriz bidimensionalA two-dimensional array's array Type.GetType("MyArray[][]")
Matriz bidimensional rectangular con límites inferiores desconocidosA rectangular two-dimensional array with unknown lower bounds Type.GetType("MyArray[,]")
Un tipo genérico con un argumento de tipoA generic type with one type argument Type.GetType("MyGenericType`1[MyType]")
Tipo genérico con dos argumentos de tipoA generic type with two type arguments Type.GetType("MyGenericType`2[MyType,AnotherType]")
Un tipo genérico con dos argumentos de tipo calificado con el ensambladoA generic type with two assembly-qualified type arguments Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Un tipo genérico calificado con el ensamblado con un argumento de tipo calificado con el ensambladoAn assembly-qualified generic type with an assembly-qualified type argument Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Tipo genérico cuyo argumento de tipo es un tipo genérico con dos argumentos de tipoA generic type whose type argument is a generic type with two type arguments Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Consulte también:

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.Gets the type with the specified name, optionally providing custom methods to resolve the assembly and the type.

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);
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.The name of the type to get. Si se proporciona el parámetro typeResolver, el nombre del tipo puede ser cualquier cadena que typeResolver pueda resolver.If the typeResolver parameter is provided, the type name can be any string that typeResolver is capable of resolving. Si se proporciona el parámetro assemblyResolver o se usa la resolución de tipos estándar, typeName debe ser un nombre calificado con el ensamblado (vea AssemblyQualifiedName), a menos que el tipo esté en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, en cuyo caso basta con aplicar el nombre de tipo calificado con su espacio de nombres.If the assemblyResolver parameter is provided or if standard type resolution is used, typeName must be an assembly-qualified name (see AssemblyQualifiedName), unless the type is in the currently executing assembly or in Mscorlib.dll, in which case it is sufficient to supply the type name qualified by its namespace.

assemblyResolver
Func<AssemblyName,Assembly>

Método que busca y devuelve el ensamblado especificado en typeName.A method that locates and returns the assembly that is specified in typeName. El nombre del ensamblado se pasa a assemblyResolver como un objeto AssemblyName.The assembly name is passed to assemblyResolver as an AssemblyName object. Si typeName no contiene el nombre de un ensamblado, no se llama a assemblyResolver.If typeName does not contain the name of an assembly, assemblyResolver is not called. Si no se proporciona assemblyResolver, se realiza la resolución de ensamblados estándar.If assemblyResolver is not supplied, standard assembly resolution is performed.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers. Hacerlo podría tener como resultado la elevación de privilegios para el código malintencionado.Doing so could result in elevation of privilege for malicious code. Use solo los métodos que proporciona o con los que está familiarizado.Use only methods that you provide or that you are familiar with.

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.A method that locates and returns the type that is specified by typeName from the assembly that is returned by assemblyResolver or by standard assembly resolution. Si no se proporciona ningún ensamblado, el método typeResolver podrá proporcionar uno.If no assembly is provided, the typeResolver method can provide one. 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.The method also takes a parameter that specifies whether to perform a case-insensitive search; false is passed to that parameter.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers.

Devoluciones

Tipo con el nombre especificado, o null si no se encuentra el tipo.The type with the specified name, or null if the type is not found.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

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).An error occurs when typeName is parsed into a type name and an assembly name (for example, when the simple type name includes an unescaped special character).

o bien-or- typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

O bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

o bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

o bien-or- typeName contiene un nombre de ensamblado no válido.typeName contains an invalid assembly name.

o bien-or- typeName es un nombre de ensamblado válido sin un nombre de tipo.typeName is a valid assembly name without a type name.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

o bien-or-

El ensamblado se compiló con una versión de Common Language Runtime posterior a la versión que está cargada actualmente.The assembly was compiled with a later version of the common language runtime than the version that is currently loaded.

Comentarios

En la sobrecarga del método GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) se pueden encontrar escenarios de uso para este método y detalles sobre los parámetros assemblyResolver y typeResolver.Usage scenarios for this method and details about the assemblyResolver and typeResolver parameters can be found in the GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) method overload.

Nota

Si no se encuentra typeName, la llamada al método GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) devuelve null.If typeName cannot be found, the call to the GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) method returns null. No produce una excepción.It does not throw an exception. Para controlar si se produce una excepción, llame a una sobrecarga del método GetType que tenga un parámetro throwOnError.To control whether an exception is thrown, call an overload of the GetType method that has a throwOnError parameter.

Llamar a esta sobrecarga de método es igual que llamar a la sobrecarga del método GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) y especificar false para los parámetros throwOnError y ignoreCase.Calling this method overload is the same as calling the GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) method overload and specifying false for the throwOnError and ignoreCase parameters.

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.Gets the type with the specified name, specifying whether to throw an exception if the type is not found, and optionally providing custom methods to resolve the assembly and the type.

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

Nombre del tipo que se va a obtener.The name of the type to get. Si se proporciona el parámetro typeResolver, el nombre del tipo puede ser cualquier cadena que typeResolver pueda resolver.If the typeResolver parameter is provided, the type name can be any string that typeResolver is capable of resolving. Si se proporciona el parámetro assemblyResolver o se usa la resolución de tipos estándar, typeName debe ser un nombre calificado con el ensamblado (vea AssemblyQualifiedName), a menos que el tipo esté en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, en cuyo caso basta con aplicar el nombre de tipo calificado con su espacio de nombres.If the assemblyResolver parameter is provided or if standard type resolution is used, typeName must be an assembly-qualified name (see AssemblyQualifiedName), unless the type is in the currently executing assembly or in Mscorlib.dll, in which case it is sufficient to supply the type name qualified by its namespace.

assemblyResolver
Func<AssemblyName,Assembly>

Método que busca y devuelve el ensamblado especificado en typeName.A method that locates and returns the assembly that is specified in typeName. El nombre del ensamblado se pasa a assemblyResolver como un objeto AssemblyName.The assembly name is passed to assemblyResolver as an AssemblyName object. Si typeName no contiene el nombre de un ensamblado, no se llama a assemblyResolver.If typeName does not contain the name of an assembly, assemblyResolver is not called. Si no se proporciona assemblyResolver, se realiza la resolución de ensamblados estándar.If assemblyResolver is not supplied, standard assembly resolution is performed.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers. Hacerlo podría tener como resultado la elevación de privilegios para el código malintencionado.Doing so could result in elevation of privilege for malicious code. Use solo los métodos que proporciona o con los que está familiarizado.Use only methods that you provide or that you are familiar with.

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.A method that locates and returns the type that is specified by typeName from the assembly that is returned by assemblyResolver or by standard assembly resolution. Si no se proporciona ningún ensamblado, el método podrá proporcionar uno.If no assembly is provided, the method can provide one. 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.The method also takes a parameter that specifies whether to perform a case-insensitive search; false is passed to that parameter.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers.

throwOnError
Boolean

Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null.true to throw an exception if the type cannot be found; false to return null. Si se especifica false se suprimen otras condiciones de excepción, pero no todas.Specifying false also suppresses some other exception conditions, but not all of them. Vea la sección Excepciones.See the Exceptions section.

Devoluciones

Tipo con el nombre especificado.The type with the specified name. Si el tipo no se encuentra, el parámetro throwOnError especifica si se devuelve null o se produce una excepción.If the type is not found, the throwOnError parameter specifies whether null is returned or an exception is thrown. En algunos casos, se produce una excepción con independencia del valor de throwOnError.In some cases, an exception is thrown regardless of the value of throwOnError. Vea la sección Excepciones.See the Exceptions section.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

throwOnError es true y no se encuentra el tipo.throwOnError is true and the type is not found.

o bien-or- throwOnError es true y typeName contiene caracteres no válidos, como una pestaña insertada.throwOnError is true and typeName contains invalid characters, such as an embedded tab. o bien-or- throwOnError es true y typeName es una cadena vacía.throwOnError is true and typeName is an empty string.

o bien-or- throwOnError es true y typeName representa un tipo de matriz con un tamaño no válido.throwOnError is true and typeName represents an array type with an invalid size.

O bien-or- typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

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).An error occurs when typeName is parsed into a type name and an assembly name (for example, when the simple type name includes an unescaped special character).

O bien-or- throwOnError es true y typeName contiene sintaxis no válida (por ejemplo, "MyType[,*,]").throwOnError is true and typeName contains invalid syntax (for example, "MyType[,*,]").

O bien-or- typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

o bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

O bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

throwOnError es true y no se encontró el ensamblado o alguna de sus dependencias.throwOnError is true and the assembly or one of its dependencies was not found.

o bien-or- typeName contiene un nombre de ensamblado no válido.typeName contains an invalid assembly name.

O bien-or- typeName es un nombre de ensamblado válido sin un nombre de tipo.typeName is a valid assembly name without a type name.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

o bien-or-

El ensamblado se compiló con una versión de Common Language Runtime posterior a la versión que está cargada actualmente.The assembly was compiled with a later version of the common language runtime than the version that is currently loaded.

Comentarios

En la sobrecarga del método GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) se pueden encontrar escenarios de uso para este método y detalles sobre los parámetros assemblyResolver y typeResolver.Usage scenarios for this method and details about the assemblyResolver and typeResolver parameters can be found in the GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) method overload.

Llamar a esta sobrecarga de método es igual que llamar a la sobrecarga del método GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) y especificar false para el parámetro ignoreCase.Calling this method overload is the same as calling the GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) method overload and specifying false for the ignoreCase parameter.

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.Gets the type with the specified name, specifying whether to perform a case-sensitive search and whether to throw an exception if the type is not found, and optionally providing custom methods to resolve the assembly and the type.

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);
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.The name of the type to get. Si se proporciona el parámetro typeResolver, el nombre del tipo puede ser cualquier cadena que typeResolver pueda resolver.If the typeResolver parameter is provided, the type name can be any string that typeResolver is capable of resolving. Si se proporciona el parámetro assemblyResolver o se usa la resolución de tipos estándar, typeName debe ser un nombre calificado con el ensamblado (vea AssemblyQualifiedName), a menos que el tipo esté en el ensamblado que se ejecuta actualmente o en Mscorlib.dll, en cuyo caso basta con aplicar el nombre de tipo calificado con su espacio de nombres.If the assemblyResolver parameter is provided or if standard type resolution is used, typeName must be an assembly-qualified name (see AssemblyQualifiedName), unless the type is in the currently executing assembly or in Mscorlib.dll, in which case it is sufficient to supply the type name qualified by its namespace.

assemblyResolver
Func<AssemblyName,Assembly>

Método que busca y devuelve el ensamblado especificado en typeName.A method that locates and returns the assembly that is specified in typeName. El nombre del ensamblado se pasa a assemblyResolver como un objeto AssemblyName.The assembly name is passed to assemblyResolver as an AssemblyName object. Si typeName no contiene el nombre de un ensamblado, no se llama a assemblyResolver.If typeName does not contain the name of an assembly, assemblyResolver is not called. Si no se proporciona assemblyResolver, se realiza la resolución de ensamblados estándar.If assemblyResolver is not supplied, standard assembly resolution is performed.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers. Hacerlo podría tener como resultado la elevación de privilegios para el código malintencionado.Doing so could result in elevation of privilege for malicious code. Use solo los métodos que proporciona o con los que está familiarizado.Use only methods that you provide or that you are familiar with.

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.A method that locates and returns the type that is specified by typeName from the assembly that is returned by assemblyResolver or by standard assembly resolution. Si no se proporciona ningún ensamblado, el método podrá proporcionar uno.If no assembly is provided, the method can provide one. 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.The method also takes a parameter that specifies whether to perform a case-insensitive search; the value of ignoreCase is passed to that parameter.

Precaución No pase métodos de llamadores desconocidos o que no sean de confianza.Caution Do not pass methods from unknown or untrusted callers.

throwOnError
Boolean

Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null.true to throw an exception if the type cannot be found; false to return null. Si se especifica false se suprimen otras condiciones de excepción, pero no todas.Specifying false also suppresses some other exception conditions, but not all of them. Vea la sección Excepciones.See the Exceptions section.

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.true to perform a case-insensitive search for typeName, false to perform a case-sensitive search for typeName.

Devoluciones

Tipo con el nombre especificado.The type with the specified name. Si el tipo no se encuentra, el parámetro throwOnError especifica si se devuelve null o se produce una excepción.If the type is not found, the throwOnError parameter specifies whether null is returned or an exception is thrown. En algunos casos, se produce una excepción con independencia del valor de throwOnError.In some cases, an exception is thrown regardless of the value of throwOnError. Vea la sección Excepciones.See the Exceptions section.

Excepciones

typeName es null.typeName is null.

Se invoca un inicializador de clase y genera una excepción.A class initializer is invoked and throws an exception.

throwOnError es true y no se encuentra el tipo.throwOnError is true and the type is not found.

O bien-or- throwOnError es true y typeName contiene caracteres no válidos, como una pestaña insertada.throwOnError is true and typeName contains invalid characters, such as an embedded tab. o bien-or- throwOnError es true y typeName es una cadena vacía.throwOnError is true and typeName is an empty string.

o bien-or- throwOnError es true y typeName representa un tipo de matriz con un tamaño no válido.throwOnError is true and typeName represents an array type with an invalid size.

o bien-or- typeName representa una matriz de TypedReference.typeName represents an array of TypedReference.

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).An error occurs when typeName is parsed into a type name and an assembly name (for example, when the simple type name includes an unescaped special character).

O bien-or- throwOnError es true y typeName contiene sintaxis no válida (por ejemplo, "MyType[,*,]").throwOnError is true and typeName contains invalid syntax (for example, "MyType[,*,]").

o bien-or- typeName representa un tipo genérico que tiene un tipo de puntero, un tipo ByRef o Void como uno de sus argumentos de tipo.typeName represents a generic type that has a pointer type, a ByRef type, or Void as one of its type arguments.

o bien-or- typeName representa un tipo genérico que tiene un número incorrecto de argumentos de tipo.typeName represents a generic type that has an incorrect number of type arguments.

o bien-or- typeName representa un tipo genérico y uno de sus argumentos de tipo no satisface las restricciones del parámetro de tipo correspondiente.typeName represents a generic type, and one of its type arguments does not satisfy the constraints for the corresponding type parameter.

throwOnError es true y no se encontró el ensamblado o alguna de sus dependencias.throwOnError is true and the assembly or one of its dependencies was not found.

Se encontró el ensamblado o una de sus dependencias, pero no se pudo cargar.The assembly or one of its dependencies was found, but could not be loaded.

o bien-or- typeName contiene un nombre de ensamblado no válido.typeName contains an invalid assembly name.

o bien-or- typeName es un nombre de ensamblado válido sin un nombre de tipo.typeName is a valid assembly name without a type name.

El ensamblado o alguna de sus dependencias no son válidos.The assembly or one of its dependencies is not valid.

o bien-or-

El ensamblado se compiló con una versión de Common Language Runtime posterior a la versión que está cargada actualmente.The assembly was compiled with a later version of the common language runtime than the version that is currently loaded.

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 método GetType por implementaciones más flexibles.Use this method overload and its associated overloads (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) and GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) to replace the default implementation of the GetType method with more flexible implementations. 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:By providing your own methods that resolve type names and the names of the assemblies that contain them, you can do the following:

  • Controla en qué versión de un ensamblado se carga un tipo.Control which version of an assembly a type is loaded from.

  • Proporcione otro lugar para buscar un nombre de tipo que no incluya un nombre de ensamblado.Provide another place to look for a type name that does not include an assembly name.

  • Cargar ensamblados mediante nombres de ensamblado parciales.Load assemblies using partial assembly names.

  • Devuelve subclases de System.Type no creadas por el Common Language Runtime (CLR).Return subclasses of System.Type that are not created by the common language runtime (CLR).

Por ejemplo, en la serialización tolerante a versiones, este método permite buscar el ensamblado "mejor ajuste" mediante un nombre parcial.For example, in version-tolerant serialization this method enables you to search for a "best fit" assembly by using a partial name. Otras sobrecargas del método GetType requieren un nombre de tipo calificado con el ensamblado, que incluye el número de versión.Other overloads of the GetType method require an assembly-qualified type name, which includes the version number.

Es posible que las implementaciones alternativas del sistema de tipo devuelvan subclases de System.Type no creadas por CLR; todos los tipos devueltos por otras sobrecargas del método GetType son tipos de tiempo de ejecución.Alternate implementations of the type system may need to return subclasses of System.Type that are not created by the CLR; all types that are returned by other overloads of the GetType method are runtime types.

Notas de usoUsage Notes

Esta sobrecarga del método y sus sobrecargas asociadas analizan typeName en el nombre de un tipo y el nombre de un ensamblado y, a continuación, resuelven los nombres.This method overload and its associated overloads parse typeName into the name of a type and the name of an assembly, and then resolve the names. La resolución del nombre de ensamblado se produce antes de la resolución del nombre de tipo, ya que un nombre de tipo debe resolverse en el contexto de un ensamblado.Resolution of the assembly name occurs before resolution of the type name, because a type name must be resolved in the context of an assembly.

Nota

Si no está familiarizado con el concepto de nombres de tipo calificados con el ensamblado, vea la propiedad AssemblyQualifiedName.If you are unfamiliar with the concept of assembly-qualified type names, see the AssemblyQualifiedName property.

Si typeName no es un nombre calificado con el ensamblado, se omite la resolución del ensamblado.If typeName is not an assembly-qualified name, assembly resolution is skipped. Los nombres de tipo no calificados se pueden resolver en el contexto de mscorlib. dll o el ensamblado que se está ejecutando actualmente, o bien, si lo desea, puede proporcionar un ensamblado en el parámetro typeResolver.Unqualified type names can be resolved in the context of Mscorlib.dll or the currently executing assembly, or you can optionally provide an assembly in the typeResolver parameter. Los efectos de incluir u omitir el nombre de ensamblado para distintos tipos de resolución de nombres se muestran como una tabla en la sección resolución de nombres mixta .The effects of including or omitting the assembly name for different kinds of name resolution are displayed as a table in the Mixed Name Resolution section.

Notas generales de uso:General usage notes:

  • No pase métodos a assemblyResolver o typeResolver si proceden de llamadores desconocidos o que no son de confianza.Do not pass methods to assemblyResolver or typeResolver if they come from unknown or untrusted callers. Use solo los métodos que proporciona o con los que está familiarizado.Use only methods that you provide or that you are familiar with.

    Precaución

    El uso de métodos de llamadores desconocidos o que no son de confianza podría dar lugar a la elevación de privilegios para el código malintencionado.Using methods from unknown or untrusted callers could result in elevation of privilege for malicious code.

  • Si omite los parámetros assemblyResolver y/o typeResolver, el valor del parámetro throwOnError se pasa a los métodos que realizan la resolución predeterminada.If you omit the assemblyResolver and/or typeResolver parameters, the value of the throwOnError parameter is passed to the methods that perform the default resolution.

  • Si throwOnError es true, este método produce una TypeLoadException cuando typeResolver devuelve nully un FileNotFoundException cuando assemblyResolver devuelve null.If throwOnError is true, this method throws a TypeLoadException when typeResolver returns null, and a FileNotFoundException when assemblyResolver returns null.

  • Este método no detecta las excepciones producidas por assemblyResolver y typeResolver.This method does not catch exceptions thrown by assemblyResolver and typeResolver. Usted es responsable de las excepciones producidas por los métodos de resolución.You are responsible for any exceptions that are thrown by the resolver methods.

Resolver ensambladosResolving Assemblies

El método assemblyResolver recibe un objeto AssemblyName, que se genera mediante el análisis del nombre del ensamblado de cadena que se incluye en typeName.The assemblyResolver method receives an AssemblyName object, which is produced by parsing the string assembly name that is included in typeName. Si typeName no contiene un nombre de ensamblado, no se llama assemblyResolver y null se pasa a typeResolver.If typeName does not contain an assembly name, assemblyResolver is not called and null is passed to typeResolver.

Si no se proporciona assemblyResolver, se usa el sondeo de ensamblados estándar para buscar el ensamblado.If assemblyResolver is not supplied, standard assembly probing is used to locate the assembly. Si se proporciona assemblyResolver, el método de GetType no realiza sondeos estándar; en ese caso, debe asegurarse de que el assemblyResolver puede controlar todos los ensamblados que le pasen.If assemblyResolver is provided, the GetType method does not do standard probing; in that case you must ensure that your assemblyResolver can handle all the assemblies you pass to it.

El método assemblyResolver debe devolver null si el ensamblado no se puede resolver.The assemblyResolver method should return null if the assembly cannot be resolved. Si assemblyResolver devuelve null, no se llama typeResolver y no se produce ningún procesamiento adicional. Además, si se true``throwOnError, se produce una FileNotFoundException.If assemblyResolver returns null, typeResolver is not called and no further processing occurs; additionally, if throwOnError is true, a FileNotFoundException is thrown.

Si el AssemblyName que se pasa a assemblyResolver es un nombre parcial, se nulluna o varias de sus partes.If the AssemblyName that is passed to assemblyResolver is a partial name, one or more of its parts are null. Por ejemplo, si no tiene ninguna versión, la propiedad Version es null.For example, if it has no version, the Version property is null. Si la propiedad Version, la propiedad CultureInfo y el método GetPublicKeyToken devuelven null, solo se proporciona el nombre simple del ensamblado.If the Version property, the CultureInfo property, and the GetPublicKeyToken method all return null, then only the simple name of the assembly was supplied. El método assemblyResolver puede usar o ignorar todas las partes del nombre del ensamblado.The assemblyResolver method can use or ignore all parts of the assembly name.

Los efectos de las distintas opciones de resolución de ensamblados se muestran como una tabla en la sección resolución de nombres mixta , para los nombres de tipo simples y calificados con el ensamblado.The effects of different assembly resolution options are displayed as a table in the Mixed Name Resolution section, for simple and assembly-qualified type names.

Resolver tiposResolving Types

Si typeName no especifica un nombre de ensamblado, siempre se llama a typeResolver.If typeName does not specify an assembly name, typeResolver is always called. Si typeName especifica un nombre de ensamblado, solo se llama a typeResolver cuando el nombre del ensamblado se resuelve correctamente.If typeName specifies an assembly name, typeResolver is called only when the assembly name is successfully resolved. Si assemblyResolver o el sondeo de ensamblados estándar devuelve null, no se llama typeResolver.If assemblyResolver or standard assembly probing returns null, typeResolver is not called.

El método typeResolver recibe tres argumentos:The typeResolver method receives three arguments:

  • Ensamblado en el que se va a buscar o null si typeName no contiene un nombre de ensamblado.The assembly to search or null if typeName does not contain an assembly name.

  • Nombre simple del tipo.The simple name of the type. En el caso de un tipo anidado, este es el tipo contenedor externo.In the case of a nested type, this is the outermost containing type. En el caso de un tipo genérico, es el nombre simple del tipo genérico.In the case of a generic type, this is the simple name of the generic type.

  • Valor booleano que es true si se va a omitir el caso de los nombres de tipo.A Boolean value that is true if the case of type names is to be ignored.

La implementación de determina el modo en que se usan estos argumentos.The implementation determines the way these arguments are used. El método typeResolver debe devolver null si no puede resolver el tipo.The typeResolver method should return null if it cannot resolve the type. Si typeResolver devuelve null y throwOnError es true, esta sobrecarga de GetType produce una TypeLoadException.If typeResolver returns null and throwOnError is true, this overload of GetType throws a TypeLoadException.

Los efectos de las diferentes opciones de resolución de tipos se muestran como una tabla en la sección resolución de nombres mixta , para los nombres de tipo simple y calificado con el ensamblado.The effects of different type resolution options are displayed as a table in the Mixed Name Resolution section, for simple and assembly-qualified type names.

Resolver tipos anidadosResolving Nested Types

Si typeName es un tipo anidado, solo se pasa a typeResolverel nombre del tipo contenedor que lo contiene.If typeName is a nested type, only the name of the outermost containing type is passed to typeResolver. Cuando typeResolver devuelve este tipo, se llama al método GetNestedType de forma recursiva hasta que se haya resuelto el tipo anidado más interno.When typeResolver returns this type, the GetNestedType method is called recursively until the innermost nested type has been resolved.

Resolver tipos genéricosResolving Generic Types

Se llama al GetType de forma recursiva para resolver tipos genéricos: primero para resolver el tipo genérico en sí y, a continuación, para resolver sus argumentos de tipo.The GetType is called recursively to resolve generic types: First to resolve the generic type itself, and then to resolve its type arguments. Si un argumento de tipo es genérico, GetType se llama de forma recursiva para resolver sus argumentos de tipo, etc.If a type argument is generic, GetType is called recursively to resolve its type arguments, and so on.

La combinación de assemblyResolver y typeResolver que proporcione debe ser capaz de resolver todos los niveles de esta recursividad.The combination of assemblyResolver and typeResolver that you provide must be capable of resolving all levels of this recursion. Por ejemplo, supongamos que proporciona un assemblyResolver que controla la carga de MyAssembly.For example, suppose you supply an assemblyResolver that controls the loading of MyAssembly. Supongamos que desea resolver el tipo genérico Dictionary<string, MyType> (Dictionary(Of String, MyType) en Visual Basic).Suppose you want to resolve the generic type Dictionary<string, MyType> (Dictionary(Of String, MyType) in Visual Basic). Podría pasar el siguiente nombre de tipo genérico:You might pass the following generic type name:

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

Observe que MyType es el único argumento de tipo calificado con el ensamblado.Notice that MyType is the only assembly-qualified type argument. Los nombres de las clases Dictionary<TKey,TValue> y String no están calificados con el ensamblado.The names of the Dictionary<TKey,TValue> and String classes are not assembly-qualified. El typeResolver debe ser capaz de controlar un ensamblado o null, porque recibirá null de Dictionary<TKey,TValue> y String.Your typeResolver must be able handle either an assembly or null, because it will receive null for Dictionary<TKey,TValue> and String. Puede controlar ese caso mediante una llamada a una sobrecarga del método GetType que toma una cadena, ya que los dos nombres de tipos incompletos se encuentran en mscorlib. dll:It can handle that case by calling an overload of the GetType method that takes a string, because both of the unqualified type names are in Mscorlib.dll:

Type t = Type.GetType(test,
                      (aName) => aName.Name == "MyAssembly" ? 
                          Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") : null,
                      (assem, name, ignore) => assem == null ? 
                          Type.GetType(name, false, ignore) : 
                              assem.GetType(name, false, ignore)
                     ); 

No se llama al método assemblyResolver para el tipo de diccionario y el tipo de cadena, ya que los nombres de tipo no están calificados con el ensamblado.The assemblyResolver method is not called for the dictionary type and the string type, because those type names are not assembly-qualified.

Ahora Supongamos que en lugar de System.String, el primer tipo de argumento genérico es YourType, desde YourAssembly:Now suppose that instead of System.String, the first generic argument type is YourType, from YourAssembly:

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

Dado que este ensamblado no es ni mscorlib. dll ni el ensamblado que se está ejecutando actualmente, no puede resolver YourType sin un nombre calificado con el ensamblado.Because this assembly is neither Mscorlib.dll nor the currently executing assembly, you cannot resolve YourType without an assembly-qualified name. Dado que el assemblyResolve se llamará de forma recursiva, debe ser capaz de controlar este caso.Because your assemblyResolve will be called recursively, it must be able to handle this case. En lugar de devolver null para los ensamblados distintos de MyAssembly, ahora realiza una carga de ensamblado mediante el objeto AssemblyName proporcionado.Instead of returning null for assemblies other than MyAssembly, it now performs an assembly load using the supplied AssemblyName object.

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

Vuelva a las notas de uso.Back to Usage Notes.

Resolver nombres de tipos con caracteres especialesResolving Type Names with Special Characters

Ciertos caracteres tienen significados especiales en los nombres calificados con el ensamblado.Certain characters have special meanings in assembly-qualified names. Si un nombre de tipo simple contiene estos caracteres, los caracteres provocan errores de análisis cuando el nombre simple forma parte de un nombre calificado con el ensamblado.If a simple type name contains these characters, the characters cause parsing errors when the simple name is part of an assembly-qualified name. Para evitar los errores de análisis, debe escapar los caracteres especiales con una barra diagonal inversa antes de poder pasar el nombre calificado con el ensamblado al método GetType.To avoid the parsing errors, you must escape the special characters with a backslash before you can pass the assembly-qualified name to the GetType method. Por ejemplo, si un tipo se denomina Strange]Type, el carácter de escape se debe agregar antes del corchete de la manera siguiente: Strange\]Type.For example, if a type is named Strange]Type, the escape character must be added ahead of the square bracket as follows: Strange\]Type.

Nota

Los nombres con estos caracteres especiales no se pueden crear en C#Visual Basic o, pero se pueden crear mediante el lenguaje intermedio de Microsoft (MSIL) o mediante la emisión de ensamblados dinámicos.Names with such special characters cannot be created in Visual Basic or C#, but can be created by using Microsoft intermediate language (MSIL) or by emitting dynamic assemblies.

En la tabla siguiente se muestran los caracteres especiales de los nombres de tipo.The following table shows the special characters for type names.

CarácterCharacter SignificadoMeaning
, (coma), (comma) Delimitador para los nombres calificados con el ensamblado.Delimiter for assembly-qualified names.
[] (corchetes)[] (square brackets) Como un par de sufijo, indica un tipo de matriz; como un par de delimitadores, incluye listas de argumentos genéricos y nombres calificados con el ensamblado.As a suffix pair, indicates an array type; as a delimiter pair, encloses generic argument lists and assembly-qualified names.
& (y comercial)& (ampersand) Como sufijo, indica que un tipo es un tipo de referencia.As a suffix, indicates that a type is a reference type.
* (asterisco)* (asterisk) Como sufijo, indica que un tipo es un tipo de puntero.As a suffix, indicates that a type is a pointer type.
+ (más)+ (plus) Delimitador para los tipos anidados.Delimiter for nested types.
\ (barra diagonal inversa)\ (backslash) Carácter de escape.Escape character.

Propiedades como AssemblyQualifiedName devuelven cadenas de escape correctamente.Properties such as AssemblyQualifiedName return correctly escaped strings. Debe pasar correctamente las cadenas de escape al método GetType.You must pass correctly escaped strings to the GetType method. A su vez, el método GetType pasa los nombres de escape correctos a typeResolver y a los métodos de resolución de tipos predeterminados.In turn, the GetType method passes correctly escaped names to typeResolver and to the default type resolution methods. Si necesita comparar un nombre con un nombre sin escape en typeResolver, debe quitar los caracteres de escape.If you need to compare a name to an unescaped name in typeResolver, you must remove the escape characters.

Vuelva a las notas de uso.Back to Usage Notes.

Resolución de nombres mixtaMixed Name Resolution

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:The following table summarizes the interactions between assemblyResolver, typeResolver, and default name resolution, for all combinations of type name and assembly name in typeName:

Contenido de tipo NameContents of type name Método de resolución de ensambladoAssembly resolver method Método de resolución de tiposType resolver method ResultadoResult
tipo, ensambladotype, assembly nulonull nulonull Equivalente a llamar a la sobrecarga del método Type.GetType(String, Boolean, Boolean).Equivalent to calling the Type.GetType(String, Boolean, Boolean) method overload.
tipo, ensambladotype, assembly mencionadosprovided nulonull assemblyResolver devuelve el ensamblado o devuelve null si no puede resolver el ensamblado.assemblyResolver returns the assembly or returns null if it cannot resolve the assembly. Si el ensamblado se resuelve, se usa la sobrecarga del método Assembly.GetType(String, Boolean, Boolean) para cargar el tipo del ensamblado; de lo contrario, no se intenta resolver el tipo.If the assembly is resolved, the Assembly.GetType(String, Boolean, Boolean) method overload is used to load the type from the assembly; otherwise, there is no attempt to resolve the type.
tipo, ensambladotype, assembly nulonull mencionadosprovided Equivalente a convertir el nombre de ensamblado en un objeto AssemblyName y llamar a la sobrecarga del método Assembly.Load(AssemblyName) para obtener el ensamblado.Equivalent to converting the assembly name to an AssemblyName object and calling the Assembly.Load(AssemblyName) method overload to get the assembly. Si el ensamblado se resuelve, se pasa a typeResolver; de lo contrario, no se llama a typeResolver y no hay ningún intento adicional de resolver el tipo.If the assembly is resolved, it is passed to typeResolver; otherwise, typeResolver is not called and there is no further attempt to resolve the type.
tipo, ensambladotype, assembly mencionadosprovided mencionadosprovided assemblyResolver devuelve el ensamblado o devuelve null si no puede resolver el ensamblado.assemblyResolver returns the assembly or returns null if it cannot resolve the assembly. Si el ensamblado se resuelve, se pasa a typeResolver; de lo contrario, no se llama a typeResolver y no hay ningún intento adicional de resolver el tipo.If the assembly is resolved, it is passed to typeResolver; otherwise, typeResolver is not called and there is no further attempt to resolve the type.
typetype null, proporcionadonull, provided nulonull Equivalente a llamar a la sobrecarga del método Type.GetType(String, Boolean, Boolean).Equivalent to calling the Type.GetType(String, Boolean, Boolean) method overload. Dado que no se proporciona el nombre de ensamblado, solo se busca en mscorlib. dll y en el ensamblado que se está ejecutando actualmente.Because the assembly name is not provided, only Mscorlib.dll and the currently executing assembly are searched. Si se proporciona assemblyResolver, se omite.If assemblyResolver is provided, it is ignored.
typetype null, proporcionadonull, provided mencionadosprovided se llama a typeResolver y null se pasa para el ensamblado.typeResolver is called, and null is passed for the assembly. typeResolver puede proporcionar un tipo de cualquier ensamblado, incluidos los ensamblados que se cargan para el propósito.typeResolver can provide a type from any assembly, including assemblies it loads for the purpose. Si se proporciona assemblyResolver, se omite.If assemblyResolver is provided, it is ignored.
ensambladoassembly null, proporcionadonull, provided null, proporcionadonull, provided Se produce una FileLoadException, porque el nombre del ensamblado se analiza como si fuera un nombre de tipo calificado con el ensamblado.A FileLoadException is thrown, because the assembly name is parsed as if it were an assembly-qualified type name. Esto da como resultado un nombre de ensamblado no válido.This results in an invalid assembly name.

Volver a: notas de uso, resolver ensambladosy resolver tipos.Back to: Usage Notes, Resolving Assemblies, Resolving Types.

Se aplica a