Module.GetType Metodo

Definizione

Spazio dei nomi:

System.Reflection

Assembly:

System.Runtime.dll

Restituisce il tipo specificato.

Overload

GetType(String)	Restituisce il tipo specificato, eseguendo una ricerca con distinzione tra maiuscole e minuscole.
GetType(String, Boolean)	Restituisce il tipo specificato, cercando il modulo con la distinzione tra maiuscole e minuscole specificate.
GetType(String, Boolean, Boolean)	Restituisce il tipo specificato, specificando se eseguire una ricerca con distinzione tra maiuscole e minuscole del modulo e se generare un'eccezione se non è possibile trovare il tipo.

GetType(String)

Origine:

Module.cs

Restituisce il tipo specificato, eseguendo una ricerca con distinzione tra maiuscole e minuscole.

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

Parametri

className

String

Nome del tipo da individuare. Il nome deve essere completo con lo spazio dei nomi .

Restituisce

Type

Oggetto Type che rappresenta il tipo specificato, se il tipo si trova in questo modulo; in caso contrario, null.

Eccezioni

ArgumentNullException

className è null.

TargetInvocationException

Gli inizializzatori di classe vengono richiamati e viene generata un'eccezione.

ArgumentException

className è una stringa di lunghezza zero.

FileNotFoundException

className richiede un assembly dipendente che non è stato trovato.

FileLoadException

className richiede un assembly dipendente trovato ma che non è stato possibile caricare.

-o-

L'assembly corrente è stato caricato nel contesto di sola reflection e className richiede un assembly dipendente che non è stato precaricato.

BadImageFormatException

className richiede un assembly dipendente, ma il file non è un assembly valido.

-o-

className richiede un assembly dipendente compilato per una versione del runtime successiva alla versione attualmente caricata.

Esempio

Nell'esempio seguente viene visualizzato il nome di un tipo nel modulo specificato.

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

Commenti

Nota

Se il tipo è stato inoltrato a un altro assembly, viene comunque restituito da questo metodo. Per informazioni sull'inoltro dei tipi, vedere inoltro dei tipi in Common Language Runtime.

Un tipo può essere recuperato da un modulo specifico usando Module.GetType. La chiamata di Module.GetType nel modulo che contiene il manifesto non eseguirà ricerche nell'intero assembly. Per recuperare un tipo da un assembly, indipendentemente dal modulo in cui si trova, è necessario chiamare Assembly.GetType.

GetType(String, Boolean)

Origine:

Module.cs

Restituisce il tipo specificato, cercando il modulo con la distinzione tra maiuscole e minuscole specificate.

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

Parametri

className

String

Nome del tipo da individuare. Il nome deve essere completo con lo spazio dei nomi .

ignoreCase

Boolean

true per la ricerca senza distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

Type

Oggetto Type che rappresenta il tipo specificato, se il tipo si trova in questo modulo; in caso contrario, null.

Eccezioni

ArgumentNullException

className è null.

TargetInvocationException

Gli inizializzatori di classe vengono richiamati e viene generata un'eccezione.

ArgumentException

className è una stringa di lunghezza zero.

FileNotFoundException

className richiede un assembly dipendente che non è stato trovato.

FileLoadException

className richiede un assembly dipendente trovato ma che non è stato possibile caricare.

-o-

L'assembly corrente è stato caricato nel contesto di sola reflection e className richiede un assembly dipendente che non è stato precaricato.

BadImageFormatException

className richiede un assembly dipendente, ma il file non è un assembly valido.

-o-

className richiede un assembly dipendente compilato per una versione del runtime successiva alla versione attualmente caricata.

Esempio

Nell'esempio seguente viene visualizzato il nome di un tipo nel modulo specificato, specificando false per il parametro ignoreCase in modo che il case non venga ignorato.

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

Commenti

Nota

Se il tipo è stato inoltrato a un altro assembly, viene comunque restituito da questo metodo. Per informazioni sull'inoltro dei tipi, vedere inoltro dei tipi in Common Language Runtime.

Un tipo può essere recuperato da un modulo specifico usando Module.GetType. La chiamata di Module.GetType nel modulo che contiene il manifesto non eseguirà ricerche nell'intero assembly. Per recuperare un tipo da un assembly, indipendentemente dal modulo in cui si trova, è necessario chiamare Assembly.GetType.

GetType(String, Boolean, Boolean)

Origine:

Module.cs

Restituisce il tipo specificato, specificando se eseguire una ricerca con distinzione tra maiuscole e minuscole del modulo e se generare un'eccezione se non è possibile trovare il 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

Parametri

className

String

Nome del tipo da individuare. Il nome deve essere completo con lo spazio dei nomi .

throwOnError

Boolean

true generare un'eccezione se non è possibile trovare il tipo; false per restituire null.

ignoreCase

Boolean

true per la ricerca senza distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

Type

Oggetto Type che rappresenta il tipo specificato, se il tipo viene dichiarato in questo modulo; in caso contrario, null.

Eccezioni

ArgumentNullException

className è null.

TargetInvocationException

Gli inizializzatori di classe vengono richiamati e viene generata un'eccezione.

ArgumentException

className è una stringa di lunghezza zero.

TypeLoadException

throwOnError è truee non è possibile trovare il tipo .

FileNotFoundException

className richiede un assembly dipendente che non è stato trovato.

FileLoadException

className richiede un assembly dipendente trovato ma che non è stato possibile caricare.

-o-

L'assembly corrente è stato caricato nel contesto di sola reflection e className richiede un assembly dipendente che non è stato precaricato.

BadImageFormatException

className richiede un assembly dipendente, ma il file non è un assembly valido.

-o-

className richiede un assembly dipendente compilato per una versione del runtime successiva alla versione attualmente caricata.

Esempio

Nell'esempio seguente viene visualizzato il nome di un tipo nel modulo specificato. I parametri throwOnError e ignoreCase vengono specificati come 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

Commenti

Il parametro throwOnError influisce solo su ciò che accade quando il tipo non viene trovato. Non influisce su altre eccezioni che potrebbero essere generate. In particolare, se il tipo viene trovato ma non può essere caricato, è possibile generare TypeLoadException anche se throwOnError è false.

Nota

Se il tipo è stato inoltrato a un altro assembly, viene comunque restituito da questo metodo. Per informazioni sull'inoltro dei tipi, vedere inoltro dei tipi in Common Language Runtime.

Un tipo può essere recuperato da un modulo specifico usando Module.GetType. La chiamata di Module.GetType nel modulo che contiene il manifesto non eseguirà ricerche nell'intero assembly. Per recuperare un tipo da un assembly, indipendentemente dal modulo in cui si trova, è necessario chiamare Assembly.GetType.