La classe System.Type

• Tramite l'operatore GetType(Tipo);
• Tramite la funzione d'istanza GetType();
• Tramite la funzione condivisa Type.GetType("nometipo").

Module Module1

    Sub Main()
        'Ottiene un OT per il tipo double tramite
        'l'operatore GetType
        Dim DoubleType As Type = GetType(Double)
        Console.WriteLine(DoubleType.FullName)
        
        'Ottiene un OT per il tipo string tramite
        'la funzione statica Type.GetType. Essa richiede
        'come parametro il nome (possibilmente completo)
        'del tipo. Nel caso il nome non corrisponda a
        'nessun tipo, verrà restituito Nothing
        Dim StringType As Type = Type.GetType("System.String")
        Console.WriteLine(StringType.FullName)

        'Ottiene un OT per il tipo ArrayList tramite
        'la funzione d'istanza GetType. Da notare che,
        'mentre le precedenti usavano come punto
        'di partenza direttamente un tipo (o il suo nome),
        'questa richiede un oggetto di quel tipo.
        Dim A As New ArrayList
        Dim ArrayListType As Type = A.GetType()
        Console.WriteLine(ArrayListType.FullName)

        Console.ReadKey()
    End Sub

End Module

Module Module1

    Sub Main()
        Dim Type1 As Type = GetType(String)
        Dim Type2 As Type = Type.GetType("System.String")
        Dim Type3 As Type = "Ciao".GetType()

        Console.WriteLine(Type1 Is Type2)
        '> True
        Console.WriteLine(Type2 Is Type3)
        '> True

        'Gli OT contenuti in Type1, Type2 e Type3 
        'SONO lo stesso oggetto
        
        Console.ReadKey()
    End Sub

End Module

• Assembly : restituisce l'assembly a cui il tipo appartiene (ossia in cui è stato dichiarato);
• AssemblyQualifiedName : restituisce il nome dell'assembly a cui il tipo appartiene;
• BaseType : se il tipo corrente eredita da una classe base, questa proprietà restituisce un oggetto Type in riferimento a tale classe;
• DeclaringMethod : se il tipo corrente è parametro di un metodo, questa proprietà restituisce un oggetto MethodBase che rappresenta tale metodo;
• DeclaringType : se il tipo corrente è membro di una classe, questa proprietà restituisce un oggetto Type che rappresenta tale classe; questa proprietà viene valorizzata, quindi, solo se il tipo è stato dichiarato all'interno di un altro tipo (ad esempio classi nidificate);
• FullName : il nome completo del tipo corrente;
• IsAbstract : determina se il tipo è una classe astratta;
• IsArray : determina se è un array;
• IsClass : determina se è una classe;
• IsEnum : determina se è un enumeratore;
• IsInterface : determina se è un'interfaccia;
• IsNested : determina se il tipo è nidificato: questo significa che rappresenta un membro di classe o di struttura; di conseguenza tutte le proprietà il cui nome inizia per "IsNested" servono a determinare l'ambito di visibilità del membro, e quindi il suo specificatore di accesso;
• IsNestedAssembly : determina se il membro è Friend;
• IsNestedFamily : determina se il membro è Protected;
• IsNestedFamORAssem : determina se il membro è Protected Friend;
• IsNestedPrivate : determina se il membro è Private;
• IsNestedPublic : determina se il membro è Public;
• IsNotPublic : determina se il tipo non è Public (solo per tipi non nidificati). Vi ricordo, infatti, che all'interno di un namespace, gli unici specificatori possibili sono Public e Friend (gli altri si adottano solo all'interno di una classe);
• IsPointer : determina se è un puntatore;
• IsPrimitive : determina se è uno dei tipi primitivi;
• IsPublic : determina se il tipo è Public (solo per tipi non nidificati);
• IsSealed : determina se è una classe sigillata;
• IsValueType : determina se è un tipo value;
• Name : il nome del tipo corrente;
• Namespace : il namespace in cui è contenuto il tipo corrente.

Module Module1

    Sub EnumerateTypes(ByVal Asm As Assembly)
        Dim Category As String

        'GetTypes restituisce un array di Type che
        'indicano tutti i tipi definiti all'interno
        'dell'assembly Asm
        For Each T As Type In Asm.GetTypes
            If T.IsClass Then
                Category = "Class"
            ElseIf T.IsInterface Then
                Category = "Interface"
            ElseIf T.IsEnum Then
                Category = "Enumerator"
            ElseIf T.IsValueType Then
                Category = "Structure"
            ElseIf T.IsPrimitive Then
                Category = "Base Type"
            End If
            Console.WriteLine("{0} ({1})", T.Name, Category)
        Next
    End Sub

    Sub Main()
        'Ottiene un riferimento all'assembly in esecuzione,
        'quindi al programma. Non otterrete molti tipi
        'usando questo codice, a meno che il resto del
        'modulo non sia pieno di codice vario come nel
        'mio caso XD
        Dim Asm As Assembly = Assembly.GetExecutingAssembly()

        EnumerateTypes(Asm)

        Console.ReadKey()
    End Sub

End Module

Il nostro piccolo segreto

Module Module1

    'Analizza l'albero di ereditarietà di un tipo
    Sub AnalyzeInheritance(ByVal T As Type)
        'La proprietà BaseType restituisce la classe
        'base da cui T è derivata
        If T.BaseType IsNot Nothing Then
            Console.WriteLine("> " & T.BaseType.FullName)
            AnalyzeInheritance(T.BaseType)
        End If
    End Sub

    Enum Status
        Enabled
        Disabled
        Standby
    End Enum

    Structure Example
        Dim A As Int32
    End Structure

    Delegate Sub Sample()

    Sub Main()
        Console.WriteLine("Integer:")
        AnalyzeInheritance(GetType(Integer))
        Console.WriteLine()

        Console.WriteLine("Enum Status:")
        AnalyzeInheritance(GetType(Status))
        Console.WriteLine()

        Console.WriteLine("Structure Example:")
        AnalyzeInheritance(GetType(Example))
        Console.WriteLine()

        Console.WriteLine("Delegate Sample:")
        AnalyzeInheritance(GetType(Sample))
        Console.WriteLine()

        Console.ReadKey()
    End Sub

End Module

Enumerare i membri

• GetConstructors() : restituisce un array di ConstructorInfo, ognuno dei quali rappresenta uno dei costruttori definiti per quel tipo;
• GetEvents() : restituisce un array di EventInfo, ognuno dei quali rappresenta uno degli eventi dichiarati in quel tipo;
• GetFields() : restituisce un array di FieldInfo, ognuno dei quali rappresenta uno dei campi dichiarati in quel tipo;
• GetInterfaces() : restituisce un array di Type, ognuno dei quali rappresenta una delle interfacce implementate da quel tipo;
• GetMembers() : restituisce un array di MemberInfo, ognuno dei quali rappresenta uno dei membri dichiarati in quel tipo;
• GetMethods() : restituisce un array di MethodInfo, ognuno dei quali rappresenta uno dei metodi dichiarati in quel tipo;
• GetNestedTypes() : restituisce un array di Type, ognuno dei quali rappresenta uno dei tipi dichiarati in quel tipo;
• GetProperties() : restituisce un array di PropertyInfo, ognuno dei quali rappresenta una delle proprietà dichiarate in quel tipo;

Module Module1
    Sub Main()
        Dim T As Type = GetType(String)

        'Elenca tutti i membri di String
        For Each M As MemberInfo In T.GetMembers
            'La proprietà MemberType restituisce un enumeratore che
            'specifica di che tipo sia il membro, se una proprietà,
            'un metodo, un costruttore, eccetera...
            Console.WriteLine(M.MemberType.ToString & " " & M.Name)
        Next

        Console.ReadKey()
    End Sub
End Module 

• DeclaringType : la classe che dichiara questo membro;
• MemberType : categoria del membro;
• Name : il nome del membro;
• ReflectedType : il tipo usato per ottenere un riferimento a questo membro tramite reflection;

• GetBaseDefinition() : se il metodo è modificato tramite polimorfismo, restituisce la versione della classe base (se non è stato sottoposto a polimorfismo, restituisce Nothing);
• GetCurrentMethod() : restituisce un MethodInfo in riferimento al metodo in cui questa funzione viene chiamata;
• GetMethodBody() : restituisce un oggetto MethodBody (che vedremo in seguito) contenente informazioni sulle variabili locali, le eccezioni e il codice IL;
• GetParameters() : restituisce un elenco di ParameterInfo rappresentanti i parametri del metodo;
• IsAbstract : determina se il metodo è MustOverride;
• IsConstructor : determina se è un costruttore;
• IsFinal : determina se è NotOverridable;
• IsStatic : determina se è Shared;
• IsVirtual : determina se è Overridable;
• ReturnParameter : qualora il metodo fosse una funzione, restituisce informazioni sul valore restituito;
• ReturnType : in una funzione, restituisce l'oggetto Type associato al tipo restituito. Se il metodo non è una funzione, restituisce Nothing o uno speciale OT in riferimento al tipo System.Void.

• GetRawCostantValue() : se il campo è una costante, ne restituisce il valore;
• IsLiteral : determina se è una costante;
• IsInitOnly : determina se è una variabile readonly;

• CanRead : determina se si può leggere la proprietà;
• CanWrite : determina se si può impostare la proprietà;
• GetGetMethod() : restituisce un MethodInfo corrispondente al blocco Get;
• GetSetMethod() : restituisce un MethodInfo corrispondente al blocco Set;
• GetPropertyType() : restituisce un oggetto Type in riferimento al tipo della proprietà.

• GetAddMethod() : restituisce un riferimento al metodo usato per aggiungere gli handler d'evento;
• GetRaiseMethod() : restituisce un riferimento al metodo che viene richiamato quando si scatena l'evento;
• GetRemoveMethod() : restituisce un riferimento al metodo usato per rimuovere gli handler d'evento;
• IsMulticast : indica se l'evento è gestito tramite un delegate multicast.

Module Module1
    'Analizza il metodo rappresentato dall'oggetto MI
    Sub AnalyzeMethod(ByVal MI As MethodInfo)
        'Il nome
        Dim Name As String
        'Il nome completo, con scpecificatori di accesso,
        'modificatori, signature e tipo restituito. Per 
        'ulteriori informazioni sul tipo StringBuilder,
        'vedere il capitolo "Magie con le stringhe"
        Dim CompleteName As New System.Text.StringBuilder
        'Lo specificatore di accesso
        Dim Scope As String
        'Gli eventuali modificatori
        Dim Modifier As String
        'La categoria: Sub o Function
        Dim Category As String
        'La signature del metodo, che andremo a costruire
        Dim Signature As New System.Text.StringBuilder

        'Di solito, tutti i metodi hanno un tipo restituito,
        'poiché, in analogia con la sintassi del C#, una
        'procedura è una funzione che restituisce Void,
        'ossia niente. Per questo bisogna controllare anche il
        'nome del tipo di ReturnParameter
        If MI.ReturnParameter IsNot Nothing AndAlso _
            MI.ReturnType.FullName <> "System.Void" Then
            Category = "Function"
        Else
            Category = "Sub"
        End If

        If MI.IsConstructor Then
            Name = "New"
        Else
            Name = MI.Name
        End If

        If MI.IsAssembly Then
            Scope = "Friend"
        ElseIf MI.IsFamily Then
            Scope = "Protected"
        ElseIf MI.IsFamilyOrAssembly Then
            Scope = "Protected Friend"
        ElseIf MI.IsPrivate Then
            Scope = "Private"
        Else
            Scope = "Public"
        End If

        If MI.IsFinal Then
            'Vorrei far notare una sottigliezza. Se il metodo è
            'Final, ossia NotOverridable, significa che non può
            'essere modificato nelle classi derivate. Ma tutti i
            'membri non dichiarati esplicitamente Overridable
            'non sono modificabili nelle classi derivate. Quindi,
            'definire un metodo senza modificatori polimorfici
            '(come quelli che seguono qua in basso), equivale a
            'definirlo NotOverridable. Perciò non si 
            'aggiunge nessun modificatore in questo caso
        ElseIf MI.IsAbstract Then
            Modifier = "MustOverride"
        ElseIf MI.IsVirtual Then
            Modifier = "Overridable"
        ElseIf MI.GetBaseDefinition IsNot Nothing AndAlso _
            MI IsNot MI.GetBaseDefinition Then
            Modifier = "Overrides"
        End If

        If MI.IsStatic Then
            If Modifier <> "" Then
                Modifier = "Shared " & Modifier
            Else
                Modifier = "Shared"
            End If
        End If

        'Inizia la signature con una parentesi tonda aperta.
        'Append aggiunge una stringa a Signature
        Signature.Append("(")
        For Each P As ParameterInfo In MI.GetParameters
            'Se P è un parametro successivo al primo, lo separa dal
            'precedente con una virgola
            If P.Position > 0 Then
                Signature.Append(", ")
            End If

            'Se P è passato per valore, ci vuole ByVal, altrimenti
            'ByRef. IsByRef è un membro di Type, ma viene
            'usato solo quando il tipo in questione indica il tipo
            'di un parametro
            If P.ParameterType.IsByRef Then
                Signature.Append("ByRef ")
            Else
                Signature.Append("ByVal ")
            End If

            'Se P è opzionale, ci vuole la keyword Optional
            If P.IsOptional Then
                Signature.Append("Optional ")
            End If

            
            Signature.Append(P.Name)
            If P.ParameterType.IsArray Then
                Signature.Append("()")
            End If
            'Dato che la sintassi del nome è in stile C#, al
            'posto delle parentesi tonde in un array ci sono delle 
            'quadre: rimediamo
            Signature.Append(" As " & P.ParameterType.Name.Replace("[]",""))

            'Si ricordi che i parametri optional hanno un valore 
            'di default
            If P.IsOptional Then
                Signature.Append(" = " & P.DefaultValue.ToString)
            End If
        Next
        Signature.Append(")")

        If MI.ReturnParameter IsNot Nothing AndAlso _
            MI.ReturnType.FullName <> "System.Void" Then
            Signature.Append(" As " & MI.ReturnType.Name)
        End If

        'Ed ecco il nome completo
        CompleteName.AppendFormat("{0} {1} {2} {3}{4}", Scope, Modifier, _
        Category, Name, Signature.ToString)
        Console.WriteLine(CompleteName.ToString)
        Console.WriteLine()

        'Ora ci occupiamo del corpo
        Dim MB As MethodBody = MI.GetMethodBody

        If MB Is Nothing Then
            Exit Sub
        End If

        'Massima memoria occupata sullo stack
        Console.WriteLine("Massima memoria stack : {0} bytes", _
            MB.MaxStackSize)
        Console.WriteLine()

        'Variabili locali (LocalVariableInfo è una variante di
        'FieldInfo)
        Console.WriteLine("Variabili locali:")
        For Each L As LocalVariableInfo In MB.LocalVariables
            'Dato che non si può ottenere il nome, ci si deve 
            'accontentare di un indice
            Console.WriteLine("  Var({0}) As {1}", L.LocalIndex, _ 
                L.LocalType.Name)
        Next
        Console.WriteLine()

        'Gestione delle eccezioni
        Console.WriteLine("Gestori di eccezioni:")
        For Each Ex As ExceptionHandlingClause In MB.ExceptionHandlingClauses
            'Tipo di clausola: distingue tra filtro (When), 
            'clausola (Catch) o un blocco Finally
            Console.WriteLine("  Tipo : {0}", Ex.Flags.ToString)
            'Se si tratta di un blocco Catch, ne specifica la
            'natura
            If Ex.Flags = ExceptionHandlingClauseOptions.Clause Then
                Console.WriteLine("    Catch Ex As " & Ex.CatchType.Name)
            End If
            'Offset, ossia posizione in bytes nel Try, del gestore
            Console.WriteLine("  Offset : {0}", Ex.HandlerOffset)
            'Lunghezza, in bytes, del codice eseguibile del gestore
            Console.WriteLine("  Lunghezza : {0}", Ex.HandlerLength)
            Console.WriteLine()
        Next
    End Sub

    Sub Test(ByVal Num As Int32, ByVal S As String)
        Dim T As Date
        Dim V As String

        Try
            Console.WriteLine("Prova 1, 2, 3")
        Catch Ex As ArithmeticException
            Console.WriteLine("Errore 1")
        Catch Ex As ArgumentException
            Console.WriteLine("Errore 2")
        Finally
            Console.WriteLine("Ciao")
        End Try
    End Sub

    Sub Main()
        Dim T As Type = GetType(Module1)
        Dim Methods() As MethodInfo = T.GetMethods
        Dim Index As Int16

        Console.WriteLine("Inserire un numero tra i seguenti per analizzare il metodo corrispondente:")
        Console.WriteLine()
        For I As Int16 = 0 To Methods.Length - 1
            Console.WriteLine("{0} - {1}", I, Methods(I).Name)
        Next
        Console.WriteLine()
        Index = Console.ReadLine

        If Index >= 0 And Index &rt; Methods.Length Then
            AnalyzeMethod(Methods(Index))
        End If

        Console.ReadKey()
    End Sub
    
End Module

Public Shared Sub Test(ByVal Num As Int32, ByVal S As String)

Massima memoria stack : 2 bytes

Variabili locali:
  Var(0) As DateTime
  Var(1) As String
  Var(2) As ArithmeticException
  Var(3) As ArgumentException
  
Gestori di eccezioni:
  Tipo : Clause
    Catch Ex As ArithmeticException
  Offset : 15
  Lunghezza : 26
  
  Tipo : Clause
    Catch Ex As ArgumentException
  Offset : 41
  Lunghezza : 26
  
  Tipo : Finally
  Offset : 67
  Lunghezza : 13