Module.GetType Método

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Devuelve el tipo especificado.

Sobrecargas

GetType(String)	Devuelve el tipo especificado, mediante una búsqueda en la que se distingue entre mayúsculas y minúsculas.
GetType(String, Boolean)	Devuelve el tipo especificado, buscando el módulo con la distinción de mayúsculas y minúsculas especificada.
GetType(String, Boolean, Boolean)	Devuelve el tipo especificado, indicando si se realiza una búsqueda que distinga entre mayúsculas y minúsculas del módulo y si se produce una excepción si no se puede encontrar el tipo.

GetType(String)

Source:

Module.cs

Devuelve el tipo especificado, mediante una búsqueda en la que se distingue entre mayúsculas y minúsculas.

public:
 virtual Type ^ GetType(System::String ^ className);

public virtual Type? GetType (string className);

override this.GetType : string -> Type

Public Overridable Function GetType (className As String) As Type

Parámetros

className

String

Nombre del tipo que se buscará. El nombre debe ser completo y debe estar en consonancia con el espacio de nombres.

Devoluciones

Type

Objeto Type que representa el tipo determinado, si el tipo está en este módulo; en caso contrario, es null.

Excepciones

ArgumentNullException

className es null.

TargetInvocationException

Se invoca a los inicializadores de clase y se produce una excepción.

ArgumentException

className es cadena de longitud cero.

FileNotFoundException

className requiere un ensamblado dependiente que no se pudo encontrar.

FileLoadException

className requiere un ensamblado dependiente que se encontró, pero no se pudo cargar.

o bien

El ensamblado actual se cargó en el contexto de solo reflexión y className requiere un ensamblado dependiente que no se haya cargado previamente.

BadImageFormatException

className requiere un ensamblado dependiente, pero el archivo no es un ensamblado válido.

o bien

className requiere un ensamblado dependiente compilado para una versión del tiempo de ejecución posterior a la versión cargada actualmente.

Ejemplos

En el ejemplo siguiente se muestra el nombre de un tipo en el módulo especificado.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->Assembly->GetModules( false );
   
   //In a simple project with only one module, the module at index
   // 0 will be the module containing these classes.
   Module^ myModule = moduleArray[ 0 ];
   Type^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass" );
   Console::WriteLine( "Got type: {0}", myType );
}

using System;
using System.Reflection;

namespace ReflectionModule_Examples
{
    class MyMainClass
    {
        static void Main()
        {
            Module[] moduleArray;
            
            moduleArray = typeof(MyMainClass).Assembly.GetModules(false);
            
            //In a simple project with only one module, the module at index
            // 0 will be the module containing these classes.
            Module myModule = moduleArray[0];

            Type myType;

            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass");
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
Namespace ReflectionModule_Examples
    Class MyMainClass
        Shared Sub Main()
            Dim moduleArray() As [Module]

            moduleArray = GetType(MyMainClass).Assembly.GetModules(False)

            'In a simple project with only one module, the module at index
            ' 0 will be the module containing these classes.
            Dim myModule As [Module] = moduleArray(0)

            Dim myType As Type

            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass")
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentarios

Nota

Si el tipo se ha reenviado a otro ensamblado, este método todavía lo devuelve. Para obtener información sobre el reenvío de tipos, vea Reenvío de tipos en Common Language Runtime.

Un tipo se puede recuperar de un módulo específico mediante Module.GetType. Llamar Module.GetType al módulo que contiene el manifiesto no buscará en todo el ensamblado. Para recuperar un tipo de un ensamblado, independientemente del módulo en el que se encuentra, debe llamar a Assembly.GetType.

GetType(String, Boolean)

Source:

Module.cs

Devuelve el tipo especificado, buscando el módulo con la distinción de mayúsculas y minúsculas especificada.

public:
 virtual Type ^ GetType(System::String ^ className, bool ignoreCase);

public virtual Type? GetType (string className, bool ignoreCase);

override this.GetType : string * bool -> Type

Public Overridable Function GetType (className As String, ignoreCase As Boolean) As Type

Parámetros

className

String

Nombre del tipo que se buscará. El nombre debe ser completo y debe estar en consonancia con el espacio de nombres.

ignoreCase

Boolean

true en el caso de búsqueda sin distinción entre mayúsculas y minúsculas; en caso contrario, false.

Devoluciones

Type

Objeto Type que representa el tipo determinado, si el tipo está en este módulo; en caso contrario, es null.

Excepciones

ArgumentNullException

className es null.

TargetInvocationException

Se invoca a los inicializadores de clase y se produce una excepción.

ArgumentException

className es cadena de longitud cero.

FileNotFoundException

className requiere un ensamblado dependiente que no se pudo encontrar.

FileLoadException

className requiere un ensamblado dependiente que se encontró, pero no se pudo cargar.

o bien

El ensamblado actual se cargó en el contexto de solo reflexión y className requiere un ensamblado dependiente que no se haya cargado previamente.

BadImageFormatException

className requiere un ensamblado dependiente, pero el archivo no es un ensamblado válido.

o bien

className requiere un ensamblado dependiente compilado para una versión del tiempo de ejecución posterior a la versión cargada actualmente.

Ejemplos

En el ejemplo siguiente se muestra el nombre de un tipo en el módulo especificado, especificando false para el ignoreCase parámetro para que no se omita ese caso.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->Assembly->GetModules( false );
   
   //In a simple project with only one module, the module at index
   // 0 will be the module containing these classes.
   Module^ myModule = moduleArray[ 0 ];
   Type^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass", false );
   Console::WriteLine( "Got type: {0}", myType );
}

using System;
using System.Reflection;

namespace ReflectionModule_Examples
{
    class MyMainClass
    {
        static void Main()
        {
            Module[] moduleArray;
            
            moduleArray = typeof(MyMainClass).Assembly.GetModules(false);
            
            //In a simple project with only one module, the module at index
            // 0 will be the module containing these classes.
            Module myModule = moduleArray[0];

            Type myType;
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", false);
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
Namespace ReflectionModule_Examples
    Class MyMainClass
        Shared Sub Main()
            Dim moduleArray() As [Module]

            moduleArray = GetType(MyMainClass).Assembly.GetModules(False)

            'In a simple project with only one module, the module at index
            ' 0 will be the module containing these classes.
            Dim myModule As [Module] = moduleArray(0)

            Dim myType As Type
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", False)
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentarios

Nota

Si el tipo se ha reenviado a otro ensamblado, este método todavía lo devuelve. Para obtener información sobre el reenvío de tipos, vea Reenvío de tipos en Common Language Runtime.

Un tipo se puede recuperar de un módulo específico mediante Module.GetType. Llamar Module.GetType al módulo que contiene el manifiesto no buscará en todo el ensamblado. Para recuperar un tipo de un ensamblado, independientemente del módulo en el que se encuentra, debe llamar a Assembly.GetType.

GetType(String, Boolean, Boolean)

Source:

Module.cs

Devuelve el tipo especificado, indicando si se realiza una búsqueda que distinga entre mayúsculas y minúsculas del módulo y si se produce una excepción si no se puede encontrar el tipo.

public:
 virtual Type ^ GetType(System::String ^ className, bool throwOnError, bool ignoreCase);

public virtual Type? GetType (string className, bool throwOnError, bool ignoreCase);

override this.GetType : string * bool * bool -> Type

Public Overridable Function GetType (className As String, throwOnError As Boolean, ignoreCase As Boolean) As Type

Parámetros

className

String

Nombre del tipo que se buscará. El nombre debe ser completo y debe estar en consonancia con el espacio de nombres.

throwOnError

Boolean

Es true para producir una excepción si no se puede encontrar el tipo; es false para devolver null.

ignoreCase

Boolean

true en el caso de búsqueda sin distinción entre mayúsculas y minúsculas; en caso contrario, false.

Devoluciones

Type

Objeto Type que representa el tipo especificado, si el tipo se declara en este módulo; en caso contrario, es null.

Excepciones

ArgumentNullException

className es null.

TargetInvocationException

Se invoca a los inicializadores de clase y se produce una excepción.

ArgumentException

className es cadena de longitud cero.

TypeLoadException

throwOnError es truey no se puede encontrar el tipo.

FileNotFoundException

className requiere un ensamblado dependiente que no se pudo encontrar.

FileLoadException

className requiere un ensamblado dependiente que se encontró, pero no se pudo cargar.

o bien

El ensamblado actual se cargó en el contexto de solo reflexión y className requiere un ensamblado dependiente que no se haya cargado previamente.

BadImageFormatException

className requiere un ensamblado dependiente, pero el archivo no es un ensamblado válido.

o bien

className requiere un ensamblado dependiente compilado para una versión del tiempo de ejecución posterior a la versión cargada actualmente.

Ejemplos

En el ejemplo siguiente se muestra el nombre de un tipo en el módulo especificado. Los throwOnError parámetros y ignoreCase se especifican como false.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->Assembly->GetModules( false );
   
   //In a simple project with only one module, the module at index
   // 0 will be the module containing this class.
   Module^ myModule = moduleArray[ 0 ];
   Type^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass", false, false );
   Console::WriteLine( "Got type: {0}", myType );
}

using System;
using System.Reflection;

namespace ReflectionModule_Examples
{
    class MyMainClass
    {
        static void Main()
        {
            Module[] moduleArray;
            
            moduleArray = typeof(MyMainClass).Assembly.GetModules(false);
            
            //In a simple project with only one module, the module at index
            // 0 will be the module containing this class.
            Module myModule = moduleArray[0];

            Type myType;
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", false, false);
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
Namespace ReflectionModule_Examples
    Class MyMainClass
        Shared Sub Main()
            Dim moduleArray() As [Module]

            moduleArray = GetType(MyMainClass).Assembly.GetModules(False)

            'In a simple project with only one module, the module at index
            ' 0 will be the module containing this class.
            Dim myModule As [Module] = moduleArray(0)

            Dim myType As Type
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", False, False)
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentarios

El throwOnError parámetro afecta solo a lo que sucede cuando no se encuentra el tipo. No afecta a ninguna otra excepción que se pueda producir. En concreto, si se encuentra el tipo pero no se puede cargar, TypeLoadException se puede producir incluso si throwOnError es false.

Nota

Si el tipo se ha reenviado a otro ensamblado, este método todavía lo devuelve. Para obtener información sobre el reenvío de tipos, vea Reenvío de tipos en Common Language Runtime.

Un tipo se puede recuperar de un módulo específico mediante Module.GetType. Llamar Module.GetType al módulo que contiene el manifiesto no buscará en todo el ensamblado. Para recuperar un tipo de un ensamblado, independientemente del módulo en el que se encuentra, debe llamar a Assembly.GetType.