Reflection dei generics

Class Example(Of T, K)
    '...
End Class

Example`2

• IsGenericTypeDefinition : determina se questo Type rappresenta una definizione di un tipo generics. Fate attenzione ai dettagli, poiché esiste un'altra proprietà molto simile con la quale ci si può confondere. Affinché questa properietà restituisca True è necessario (e sufficiente) che il tipo che stiamo esaminando contenga una definizione di uno o più tipi generics APERTI (e non collegati). Ad esempio:
  

  Module Module1
  
      'Dichiaro questa classe e la prossima variabile come
      'pubblici perchè se fossero Friend bisognerebbe
      'usare un overload troppo lungo di GetField e
      'GetNestedTypes specificando ci cercare i membri non
      'pubblici. Di default, le funzioni di ricerca operano
      'solo su membri pubblici
      
      Public Class Example(Of T)
  
      End Class
  
      Public E As Example(Of Int32)
  
      Sub Main()
          'Ottiene il tipo di questo modulo
          Dim ModuleType As Type = GetType(Module1)
  
          'Enumera tutti i tipi presenti nel modulo fino a
          'trovare la classe Example. Ho usato un for perchè
          'non si può usare GetType (in qualsiasi
          'sua versione) su una classe generics senza specificare
          'un tipo generics collegato, cosa che noi non
          'vogliamo affatto. Per ottenere il riferimento a
          'Example(Of T) bisogna per forza usare una funzione
          'che restituisca tutti i tipi esistenti e poi
          'cercarlo tra questi.
          For Each T As Type In ModuleType.GetNestedTypes()
              If T.Name.StartsWith("Example") Then
                  Console.WriteLine("{0}  -  IsGenericTypeDefinition: {1}", _
                      T.Name, T.IsGenericTypeDefinition)
              End If
          Next
  
          'Ottiene un riferimento al campo E dichiarayo sopra
          Dim EField As FieldInfo = ModuleType.GetField("E")
          'E ne ottiene il tipo
          Dim EType As Type = EField.FieldType
  
          Console.WriteLine("{0}  -  IsGenericTypeDefinition: {1}", EType.Name, EType.IsGenericTypeDefinition)
  
          Console.ReadKey()
      End Sub
  
  End Module

  A schermo apparirà lo stesso nome due volte, ma in un caso IsGenericTypeDefinition sarà True e nell'altro False. Questo perchè il tipo della variabile E è sì dichiarato come generic, ma all'atto pratico lavora su un solo tipo: Int32; perciò non si tratta di una definizione di tipo generic, ma di un uso di un tipo generic;
• IsGenericType : molto simile alla precedente, ma funziona al contrario, ossia restituisce True se il tipo NON è una definizione di tipo generic, ma una sua applicazione mediante tipi collegati. Nell'esempio di prima, EType.IsGenericType sarebbe stato True;
• GetGenericArguments() : se almeno uno tra IsGenericTypeDefinition e IsGenericType è vero, allora abbiamo a che fare con tipi generics. Questa funzione restituisce gli OT dei tipi generics aperti (nel primo caso) o collegati (nel secondo caso). Tra breve ne vedremo un esempio.

Module Module1

    Sub EnumerateGenerics(ByVal Asm As Assembly)
        For Each T As Type In Asm.GetTypes
            'Controlla se si tratta di un tipo contenente
            'tipi generics aperti
            If T.IsGenericTypeDefinition Then
                'Ottiene il nome semplice di quel tipo (la
                'versione completa è troppo lunga XD)
                Dim Name As String = T.Name

                'Controlla che il nome contenga l'accento tonico.
                'Infatti, possono esistere casi in cui la
                'propietà IsGeneircTypeDefinition è vera,
                'ma non ci troviamo di fronte a un tipo la cui
                'signature contenga effettivamente tipi generics.
                'Ne darò un esempio dopo...
                If Not Name.Contains("`") Then
                    Continue For
                End If

                'Ottiene una stringa in cui elimina tutti i
                'caratteri a partire dall'indice del'accento
                Name = T.Name.Remove(T.Name.IndexOf("`"))
                'E poi gli aggiunge un "(Of ", per far vedere che
                'si sta iniziando una dichiarazione generic
                Name &= "(Of "
                'Quindi aggiunge tutti gli argomenti generic
                For Each GenT As Type In T.GetGenericArguments
                    'Se il parametro non è il primo, lo separa dal
                    'precedente con una virgola.
                    If GenT.GenericParameterPosition > 0 Then
                        Name &= ", "
                    End If
                    'Quindi vi aggiunge il nome
                    Name &= GenT.Name
                Next
                'E chiude la parentesi
                Name &= ")"
                Console.WriteLine(Name)
            End If
        Next
    End Sub
    
    'Notate che la classe Type espone molte proprietà che
    'si possono usare solo in determinati casi. Ad esempio, in
    'questo codice è lecito richiamare GenericParametrPosition
    'poiché sappiamo a priori che quel Type indica un tipo
    'generic in una signature generic. Ma un in un qualsiasi OT
    'non ha alcun senso usare tale proprietà!

    Sub Main()
        'Ottiene un riferimento all'assembly corrente
        Dim Asm As Assembly = Assembly.GetExecutingAssembly()

        EnumerateGenerics(Asm)

        Console.ReadKey()
    End Sub
    
End Module

ThreadSafeObjectProvider(Of T)
Collection(Of T)
ComparableCollection(Of T)
Relation(Of T1, T2)
IsARelation(Of T, U)
DataFilter(Of T)

Class Example(Of T)
    Delegate Sub DoSomething(ByVal Data As T)
    '...
End Class

Module Module1

    'Enumera solo i campi generic di un tipo
    Sub EnumerateGenericFieldMembers(ByVal T As Type)
        For Each F As FieldInfo In T.GetFields()
            If F.FieldType.IsGenericType Then
                Dim Name As String = F.FieldType.Name
                Dim I As Int16 = 0

                If Not Name.Contains("`") Then
                    Continue For
                End If

                Name = Name.Remove(Name.IndexOf("`"))
                Name &= "(Of "
                For Each GenP As Type In F.FieldType.GetGenericArguments
                    'Dato che non si stanno analizzando dei
                    'parametri generic, non si può utilizzare
                    'la proprietà GenericParameterPosition
                    If I > 0 Then
                        Name &= ", "
                    End If
                    Name &= GenP.Name
                    I += 1
                Next
                Name &= ")"
                Console.WriteLine("Dim {0} As {1}", F.Name, Name)
            End If
        Next
    End Sub

    Public L As New List(Of Integer)
    Public I As Int32?

    Sub Main()
        EnumerateGenericFieldMembers(GetType(Module1))

        Console.ReadKey()
    End Sub
End Module

L'uso della Reflection

Module Module1

    'Stampa tutte le informazioni ricavabili dalle
    'proprietà di un dato oggetto O. Indent è solo
    'una variabile d'appoggio per la formattazione, in modo
    'da indentare bene le righe nel caso i valori delle
    'proprietà siano altri oggetti.
    Public Sub PrintInfo(ByVal O As Object, ByVal Indent As String)
        'Ottiene il tipo di O
        Dim T As Type = O.GetType()

        Console.WriteLine("{0}Object of type {1}", Indent, T.Name)
        'Enumera tutte le proprietà
        For Each Prop As PropertyInfo In T.GetProperties()
            'Ottiene il tipo restituito dalla proprietà
            Dim PropType As Type = Prop.PropertyType()

            'Se si tratta di una proprietà parametrica,
            'la salta: in questo esempio non volevo dilungarmi,
            'ma potete completare il codice se desiderate.
            If Prop.GetIndexParameters().Count > 0 Then
                Continue For
            End If

            'Se è un di tipo base o una stringa (giacché le
            'stringhe non sono tipo base ma reference), ne stampa
            'direttamente il valore a schermo
            If (PropType.IsPrimitive) Or (PropType Is GetType(String)) Then
                Console.WriteLine("{0}  {1} = {2}", _
                    Indent, Prop.Name, Prop.GetValue(O, Nothing))
                    
            'Altrimenti, se si tratta di un oggetto, lo analizza a
            'sua volta
            ElseIf PropType.IsClass Then
                Console.WriteLine("{0}  {1} = ", Indent, Prop.Name)
                PrintInfo(Prop.GetValue(O, Nothing), Indent & "    ")
            End If
        Next
        Console.WriteLine()
    End Sub

    Sub Main()
        'Crea alcuni oggetti vari
        Dim P As New Person("Mario", "Rossi", New Date(1982, 3, 17))
        Dim T As New Teacher("Luigi", "Bianchi", New Date(1879, 8, 21), "Storia")
        Dim R As New Relation(Of Person, Teacher)(P, T)
        Dim Q As New List(Of Int32)
        Dim K As New Text.StringBuilder()

        'Ne stampa le proprietà, senza sapere nulla a priori
        'sulla natura degli oggetti.
        'Notate che i nomi generics rimangono con l'accento...
        PrintInfo(P, "")
        PrintInfo(T, "")
        PrintInfo(R, "")
        PrintInfo(Q, "")
        PrintInfo(K, "")

        Console.ReadKey()
    End Sub
End Module

Object of type Person
  FirstName = Mario
  LastName = Rossi
  CompleteName = Mario Rossi

Object of type Teacher
  Subject = Storia
  LastName = Prof. Bianchi
  CompleteName = Prof. Luigi Bianchi, dottore in Storia
  FirstName = Luigi

Object of type Relation`2
  FirstObject = 
    Object of type Person
      FirstName = Mario
      LastName = Rossi
      CompleteName = Mario Rossi

  SecondObject = 
    Object of type Teacher
      Subject = Storia
      LastName = Prof. Bianchi
      CompleteName = Prof. Luigi Bianchi, dottore in Storia
      FirstName = Luigi


Object of type List`1
  Capacity = 0
  Count = 0

Object of type StringBuilder
  Capacity = 16
  MaxCapacity = 2147483647
  Length = 0

Module Module1

    'Non riscrivo PrintInfo, ma considero che stia
    'ancora in questo modulo

    Sub Main()
        Dim P As New Person("Mario", "Rossi", New Date(1982, 3, 17))
        Dim T As New Teacher("Luigi", "Bianchi", New Date(1879, 8, 21), "Storia")
        Dim R As New Relation(Of Person, Teacher)(P, T)
        Dim Q As New List(Of Int32)
        Dim K As New Text.StringBuilder()
        Dim Objects() As Object = {P, T, R, Q, K}
        Dim Cmd As Int32

        Console.WriteLine("Oggetti nella collezione: ")
        For I As Int32 = 0 To Objects.Length - 1
            Console.WriteLine("{0} - Istanza di {1}", _
                I, Objects(I).GetType().Name)
        Next
        Console.WriteLine("Inserire il numero corrispondente all'oggetto da modificare: ")
        Cmd = Console.ReadLine

        If Cmd < 0 Or Cmd > Objects.Length - 1 Then
            Console.WriteLine("Nessun oggetto corrispondente!")
            Exit Sub
        End If

        Dim Selected As Object = Objects(Cmd)
        Dim SelectedType As Type = Selected.GetType()
        Dim Properties As New List(Of PropertyInfo)

        For Each Prop As PropertyInfo In SelectedType.GetProperties()
            If (Prop.PropertyType.IsPrimitive Or Prop.PropertyType Is GetType(String)) And _
               Prop.CanWrite Then
                Properties.Add(Prop)
            End If
        Next

        Console.Clear()
        Console.WriteLine("Proprietà dell'oggetto:")
        For I As Int32 = 0 To Properties.Count - 1
            Console.WriteLine("{0} - {1}", _
                I, Properties(I).Name)
        Next
        Console.WriteLine("Inserire il numero corrispondente alla proprietà da modificare:")
        Cmd = Console.ReadLine

        If Cmd < 0 Or Cmd > Objects.Length - 1 Then
            Console.WriteLine("Nessuna proprietà corrispondente!")
            Exit Sub
        End If

        Dim SelectedProp As PropertyInfo = Properties(Cmd)
        Dim NewValue As Object

        Console.Clear()
        Console.WriteLine("Nuovo valore: ")
        NewValue = Console.ReadLine

        'Imposta il nuovo valore della proprietà. Noterete che
        'si ottiene un errore di cast con tutti i tipi che
        'non siano String. Questo accade poiché viene
        'eseguito un matching sul tipo degli argomenti: se essi
        'sono diversi, indipendentemente dal fatto che possano
        'essere convertiti l'uno nell'altro (al contrario di
        'quanto dice il testo dell'errore), viene sollevata
        'quell'eccezione. Per aggirare il problema, si
        'dovrebbe eseguire un cast esplicito controllando prima
        'il tipo della proprietà:
        '  If SelectedProp.PropertyType Is GetType(Int32) Then
        '    NewValue = CType(NewValue, Int32)
        '  ElseIf SelectedProp. ...
        'È il prezzo da pagare quando si lavora con
        'uno strumento così generale come la Reflection.
        '[Generalmente si conosce in anticipo il tipo]
        SelectedProp.SetValue(Selected, NewValue, Nothing)

        Console.WriteLine("Proprietà modificata!")

        PrintInfo(Selected, "")

        Console.ReadKey()
    End Sub
End Module