Type.GetType Método

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

public:
 Type ^ GetType();

public:
 virtual Type ^ GetType();

public Type GetType();

override this.GetType : unit -> Type

Public Function GetType () As Type

Devoluciones

Objeto actual Type.

Implementaciones

Excepciones

Consulte también

• TypeLoadException
• Especificación de nombres de tipo completos

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

public static Type GetType(string typeName);

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName);

public static Type? GetType(string typeName);

static member GetType : string -> Type

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string -> Type

Public Shared Function GetType (typeName As String) As Type

Parámetros

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Ejemplos

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

using System;

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

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

open System

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

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

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

         Console.WriteLine()

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

Comentarios

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

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

En .NET Framework, para usar en un módulo dinámico, suscríbase al evento /> antes de guardar. De lo contrario, obtendrá dos copias del ensamblado en memoria.

En .NET Core 3.0 y versiones posteriores, las cargas de ensamblado desencadenadas por esta API se ven afectadas por el valor actual de AssemblyLoadContext.CurrentContextualReflectionContext.

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

Tipo de miembro	Static	No estático
Constructor	No	No
Campo	No	Yes. Un campo siempre se oculta según el nombre y la firma.
Event	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.
Método	No	Yes. Un método (tanto virtual como no virtual) puede ocultarse por nombre o por nombre y firma.
Tipo anidado	No	No
Propiedad	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.

1. En ocultar por nombre y firma se tienen en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.

2. En reflexión, las propiedades y eventos se ocultan por nombre y firma. 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 clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.

3. Los atributos personalizados no forman parte del sistema de tipos común.

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

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

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

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

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

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

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

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

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

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

Este nombre completo se puede conservar y, después, usarse para cargar .Type Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo completo del ensamblado. GetType con el nombre de tipo solo buscará en Type el ensamblado del autor de la llamada y, a continuación, en el ensamblado System. GetType con el nombre de tipo completo del ensamblado buscará Type en cualquier ensamblado.

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

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

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

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

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

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

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

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

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

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

Consulte también

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Especificación de nombres de tipo completos

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, bool throwOnError);

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

static member GetType : string * bool -> Type

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * bool -> Type

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

Parámetros

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Ejemplos

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

using System;

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

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

open System

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

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

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

         Console.WriteLine()

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

Comentarios

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

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

En .NET Framework, para usar en un módulo dinámico, suscríbase al evento /> antes de guardar. De lo contrario, obtendrá dos copias del ensamblado en memoria.

En .NET Core 3.0 y versiones posteriores, las cargas de ensamblado desencadenadas por esta API se ven afectadas por el valor actual de AssemblyLoadContext.CurrentContextualReflectionContext.

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

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

Tipo de miembro	Static	No estático
Constructor	No	No
Campo	No	Yes. Un campo siempre se oculta según el nombre y la firma.
Event	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.
Método	No	Yes. Un método (tanto virtual como no virtual) puede ocultarse por nombre o por nombre y firma.
Tipo anidado	No	No
Propiedad	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.

1. En ocultar por nombre y firma se tienen en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.

2. En reflexión, las propiedades y eventos se ocultan por nombre y firma. 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 clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.

3. Los atributos personalizados no forman parte del sistema de tipos común.

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

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

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

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

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

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

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

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

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

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

Este nombre completo se puede conservar y, después, usarse para cargar .Type Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo completo del ensamblado. GetType con el nombre de tipo solo buscará en Type el ensamblado del autor de la llamada y, a continuación, en el ensamblado System. GetType con el nombre de tipo completo del ensamblado buscará Type en cualquier ensamblado.

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

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

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

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

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

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

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

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

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

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

Consulte también

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Especificación de nombres de tipo completos

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, bool throwOnError, bool ignoreCase);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * bool * bool -> Type

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

Parámetros

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Comentarios

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

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

En .NET Framework, para usar en un módulo dinámico, suscríbase al evento /> antes de guardar. De lo contrario, obtendrá dos copias del ensamblado en memoria.

En .NET Core 3.0 y versiones posteriores, las cargas de ensamblado desencadenadas por esta API se ven afectadas por el valor actual de AssemblyLoadContext.CurrentContextualReflectionContext.

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

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

Tipo de miembro	Static	No estático
Constructor	No	No
Campo	No	Yes. Un campo siempre se oculta según el nombre y la firma.
Event	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.
Método	No	Yes. Un método (tanto virtual como no virtual) puede ocultarse por nombre o por nombre y firma.
Tipo anidado	No	No
Propiedad	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.

1. En ocultar por nombre y firma se tienen en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.

2. En reflexión, las propiedades y eventos se ocultan por nombre y firma. 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 clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.

3. Los atributos personalizados no forman parte del sistema de tipos común.

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

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

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

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

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

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

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

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

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

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

Este nombre completo se puede conservar y, después, usarse para cargar .Type Para buscar y cargar un Type, use GetType solo con el nombre de tipo o con el nombre de tipo completo del ensamblado. GetType con el nombre de tipo solo buscará en Type el ensamblado del autor de la llamada y, a continuación, en el ensamblado System. GetType con el nombre de tipo completo del ensamblado buscará Type en cualquier ensamblado.

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

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

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

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

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

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

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

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

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

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

Consulte también

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Especificación de nombres de tipo completos

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> -> Type

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

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Comentarios

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

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

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool -> Type

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

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Comentarios

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

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

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError, bool ignoreCase);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool * bool -> Type

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

Devoluciones

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

Atributos

RequiresUnreferencedCodeAttribute

Excepciones

Comentarios

En .NET Core 3.0 y versiones posteriores, si assemblyResolver es null, las cargas de ensamblado desencadenadas por esta API se ven afectadas por el valor actual de AssemblyLoadContext.CurrentContextualReflectionContext.

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

• Controle en qué versión de un ensamblado se carga un tipo.
• Indique otros sitio donde buscar un nombre de tipo que no incluya un nombre de ensamblado.
• Cargue ensamblados mediante nombres de ensamblado parciales.
• Devuelve subclases de System.Type que common Language Runtime (CLR) no crea.

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

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

Notas de uso

Esta sobrecarga y las sobrecargas asociadas analizan typeName para convertirlo en el nombre de un tipo y el nombre de un ensamblado y después resuelven los nombres. La resolución del nombre del ensamblado se produce antes de la resolución del nombre de tipo, ya que un nombre de tipo debe resolverse en el contexto de un ensamblado.

Si typeName no es un nombre calificado de ensamblado, no se realiza la resolución del ensamblado. Los nombres de tipo no calificados se pueden resolver en el contexto de mscorlib.dll/System.Private.CoreLib.dll o en el ensamblado que se está ejecutando en ese momento; u opcionalmente puede usted mismo usar un ensamblado en el parámetro typeResolver. Los efectos de incluir o omitir el nombre del ensamblado para diferentes tipos de resolución de nombres se muestran como una tabla en la sección Resolución de nombres mixtos .

Notas de uso general:

• No pase métodos a assemblyResolver o typeResolver si proceden de llamadores desconocidos o que no sean de confianza. Use solo métodos con los que proporcione o con los que esté familiarizado.

  Caution

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

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

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

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

Resolución de ensamblados

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

Si assemblyResolver no está proporcionado, se usa el sondeo de ensamblado estándar para localizar el ensamblado. Si se usa assemblyResolver, el método GetType no realizará la detección estándar; en ese caso, debe asegurarse de que assemblyResolver puede gestionar todos los ensamblados que se le pasan.

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

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

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

Resolución de tipos

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

El typeResolver método recibe tres argumentos:

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

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

Los efectos de las diferentes opciones de resolución de tipos figuran en una tabla de la sección Resolución de nombres mixtos, para nombres de tipo simples y calificados de ensamblado.

Resolución de tipos anidados

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

Resolución de tipos genéricos

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

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

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

Observe que MyType es el único argumento de tipo calificado del ensamblado. Los nombres de las clases Dictionary<TKey,TValue> y String no están calificados en términos de ensamblado. El typeResolver debe ser capaz de controlar un ensamblado o un valor null, ya que recibirá null en Dictionary<TKey,TValue> y String. Puede dar solución a esto llamando a una sobrecarga del método GetType que toma una cadena, ya que ambos nombres de tipo no calificados están en mscorlib.dll/System.Private.CoreLib.dll:

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

let t =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else null),
        fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr))

El método assemblyResolver no se invoca en el tipo de diccionario y el tipo de cadena, porque esos nombres de tipo no están calificados del ensamblado.

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

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

Dado que este ensamblado no es ni mscorlib.dllniSystem.Private.CoreLib.dll, ni el ensamblado que se está ejecutando actualmente, no se puede resolver YourType sin un nombre calificado de ensamblado. Como el assemblyResolve se llamará de forma recursiva, debe ser capaz de controlar este caso. En lugar de devolver null para ensamblados distintos de MyAssembly, ahora realiza una carga de ensamblado mediante el objeto AssemblyName facilitado.

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

let t2 =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else Assembly.Load aName),
        (fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr)), true)

Resolución de nombres de tipo con caracteres especiales

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

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

Carácter	Meaning
, (coma)	Delimitador para nombres calificados de ensamblados.
[] (corchetes)	Como par de sufijos, indica un tipo de matriz; como par de delimitador, incluye listas de argumentos genéricos y nombres calificados de ensamblados.
& (Y comercial)	Como sufijo, indica que un tipo es un tipo de referencia.
* (asterisco)	Como sufijo, indica que un tipo es un tipo de puntero.
+ (más)	Delimitador para tipos anidados.
\ (barra diagonal inversa)	Escape de carácter.

Las propiedades como AssemblyQualifiedName devuelven cadenas con escapes correctamente. Debe pasar correctamente las cadenas de escape al método GetType. A su vez, el método GetType pasa los nombres correctamente que se han escapado a typeResolver y a los métodos de resolución de tipos predeterminados. Si necesita comparar un nombre con uno sin caracteres de escape en typeResolver, debe quitar los caracteres de escape.

Resolución de nombres mixtos

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

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