Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Guida al Visual Basic .NET - I Generics Parte I

Guida al Visual Basic .NET

Capitolo 41° - I Generics Parte I

<< Precedente Prossimo >>


Panoramica sui Generics

I Generics sono un concetto molto importante per quanto riguarda la programmazione ad oggetti, specialmente in .NET e, se fino ad ora non ne conoscevate nemmeno l'esistenza, d'ora in poi non potrete farne a meno. Cominciamo col fare un paragone per esemplificare il concetto di generics. Ammettiamo di dichiarare una variabile I di tipo Int32: in questa variabile potremo immagazzinare qualsiasi informazione che consista di un numero intero rappresentabile su 32 bit. Possiamo dire, quindi, che il tipo Int32 costituisce un'astrazione di tutti i numeri interi esistenti da -2'147'483'648 a +2'147'483'647. Analogamente un tipo generic può assumere come valore un altro tipo e, quindi, astrae tutti i possibili tipi usabili in quella classe/metodo/proprietà eccetera. È come dire: definiamo la funzione Somma(A, B), dove A e B sono di un tipo T che non conosciamo. Quando utilizziamo la funzione Somma, oltre a specificare i parametri richiesti, dobbiamo anche "dire" di quale tipo essi siano (ossia immettere in T non un valore ma un tipo): in questo modo, definendo un solo metodo, potremo eseguire somme tra interi, decimali, stringhe, date, file, classi, eccetera... In VB.NET, l'operazione di specificare un tipo per un entità generic si attua con questa sintassi:
[NomeEntità](Of [NomeTipo])
Dato i generics di possono applicare ad ogni entità del .NET (metodi, classi, proprietà, strutture, interfacce, delegate, eccetera...), ho scritto solo "NomeEntità" per indicare il nome del target a cui si applicano. Il prossimo esempio mostra come i generics, usati sulle liste, possano aumentare di molto le performance di un programma.
La collezione ArrayList, molte volte impiegata negli esempi dei precedeti capitoli, permette di immagazzinare qualsiasi tipo di dato, memorizzando, quindi, variabili di tipo Object. Come già detto all'inizio del corso, l'uso di Object comporta molti rischi sia a livello di prestazioni, dovute alle continue operazioni di boxing e unboxing (e le garbage collection che ne conseguono, data la creazione di molti oggetti temporanei), sia a livello di correttezza del codice. Un esempio di questo ultimo caso si verifica quando si tenta di scorrere un ArrayList mediante un ciclo For Each e si incontra un record che non è del tipo specificato, ad esempio:
Dim A As New ArrayList
A.Add(2)
A.Add(3)
A.Add("C") 
'A run-time, sarà lanciata un'eccezione inerente il cast
'poichè la stringa "C" non è del tipo specificato 
'nel blocco For Each
For Each V As Int32 In A
  Console.WriteLine(V)
Next 
Infatti, se l'applicazione dovesse erroneamente inserire una stringa al posto di un numero intero, non verrebbe generato nessun errore, ma si verificherebbe un'eccezione successivamente. Altra problematica legata all'uso di collezioni a tipizzazione debole (ossia che registrano generici oggetti Object, come l'ArrayList, l'HashTable o la SortedList) è dovuta al fatto che sia necessaria una conversione esplicita di tipo nell'uso dei suoi elementi, almeno nella maggioranza dei casi. La soluzione adottata da un programmatore che non conoscesse i generics per risolvere tali inconvenienti sarebbe quella di creare una nuova lista, ex novo, ereditandola da un tipo base come CollectionBase e ridefinendone tutti i metodi (Add, Remove, IndexOf ecc...). L'uso dei Generics, invece, rende molto più veloce e meno insidiosa la scrittura di un codice robusto e solido nell'ambito non solo delle collezioni, ma di molti altri argomenti. Ecco un esempio di come implementare una soluzione basata sui Generics:
'La lista accetta solo oggetti di tipo Int32: per questo motivo
'si genera un'eccezione quando si tenta di inserirvi elementi di
'tipo diverso e la velocità di elaborazione aumenta!
Dim A As New List(Of Int32)
A.Add(1)
A.Add(4)
A.Add(8)
'A.Add("C") '<- Impossibile
For Each V As Int32 In A
  Console.WriteLine(V)
Next 
E questa è una dimostrazione dell'incremento delle prestazioni:
Module Module1
    Sub Main()
        Dim TipDebole As New ArrayList
        Dim TipForte As New List(Of Int32)
        Dim S As New Stopwatch

        'Cronometra le operazioni su ArrayList
        S.Start()
        For I As Int32 = 1 To 1000000
            TipDebole.Add(I)
        Next
        S.Stop()
        Console.WriteLine(S.ElapsedMilliseconds & _ 
            " millisecondi per ArrayList!")

        'Cronometra le operazioni su List
        S.Reset()
        S.Start()
        For I As Int32 = 1 To 1000000
            TipForte.Add(I)
        Next
        S.Stop()
        Console.WriteLine(S.ElapsedMilliseconds & _ 
            " millisecondi per List(Of T)!")

        Console.ReadKey()
    End Sub
End Module 
Sul mio computer portatile l'ArrayList impiega 197ms, mentre List 33ms: i Generics incrementano la velocità di 6 volte!
Oltre a List, esistono anche altre collezioni generic, ossia Dictionary e SortedDictionary: tutti questi sono la versione a tipizzazione forte delle normali collezioni già viste. Ma ora vediamo come scrivere nuove classi e metodi generic.


Generics Standard

Una volta imparato a dichiarare e scrivere entità generics, sarà anche altrettanto semplice usare quelli esistenti, perciò iniziamo col dare le prime informazioni su come scrivere, ad esempio, una classe generics.
Una classe generics si riferisce ad un qualsiasi tipo T che non possiamo conoscere al momento dela scrittura del codice, ma che il programmatore specificherà all'atto di dichiarazione di un oggetto rappresentato da questa classe. Il fatto che essa sia di tipo generico indica che anche i suoi membri, molto probabilmente, avranno lo stesso tipo: più nello specifico, potrebbero esserci campi di tipo T e metodi che lavorano su oggetti di tipo T. Se nessuna di queste due condizioni è verificata, allora non ha senso scrivere una classe generics. Ma iniziamo col vedere un semplice esempio:
Module Module1
    'Collezione generica che contiene un qualsiasi tipo T di
    'oggetto. T si dice "tipo generic aperto"
    Class Collection(Of T)
        'Per ora limitiamoci a dichiarare un array interno
        'alla classe.
        'Vedremo in seguito che è possibile ereditare da
        'una collezione generics già esistente.
        'Notate che la variabile è di tipo T: una volta che
        'abbiamo dichiarato la classe come generics su un tipo T,
        'è come se avessimo "dichiarato" l'esistenza di T
        'come tipo fittizio. 
        Private _Values() As T

        'Restituisce l'Index-esimo elemento di Values (anch'esso
        'è di tipo T)
        Public Property Values(ByVal Index As Int32) As T
            Get
                If (Index >= 0) And (Index < _Values.Length) Then
                    Return _Values(Index)
                Else
                    Throw New IndexOutOfRangeException()
                End If
            End Get
            Set(ByVal value As T)
                If (Index >= 0) And (Index < _Values.Length) Then
                    _Values(Index) = value
                Else
                    Throw New IndexOutOfRangeException()
                End If
            End Set
        End Property

        'Proprietà che restituiscono il primo e l'ultimo
        'elemento della collezione
        Public ReadOnly Property First() As T
            Get
                Return _Values(0)
            End Get
        End Property

        Public ReadOnly Property Last() As T
            Get
                Return _Values(_Values.Length - 1)
            End Get
        End Property

        'Stampa tutti i valori presenti nella collezione a schermo.
        'Su un tipo generic è sempre possibile usare
        'l'operatore Is (ed il suo corrispettivo IsNot) e 
        'confrontarlo con Nothing. Se si tratta di un tipo value
        'l'uguaglianza con Nothing sarà sempre falsa.
        Public Sub PrintAll()
            For Each V As T In _Values
                If V IsNot Nothing Then
                    Console.WriteLine(V.ToString())
                End If
            Next
        End Sub

        'Inizializza la collezione con Count elementi, tutti del
        'valore DefaultValue
        Sub New(ByVal Count As Int32, ByVal DefaultValue As T)
            If Count < 1 Then
                Throw New ArgumentOutOfRangeException()
            End If

            ReDim _Values(Count - 1)

            For I As Int32 = 0 To _Values.Length - 1
                _Values(I) = DefaultValue
            Next
        End Sub

    End Class

    Sub Main()
        'Dichiara quattro variabili contenenti quattro nuovi
        'oggetti Collection. Ognuno di questi, però, 
        'è specifico per un solo tipo che decidiamo 
        'noi durante la dichiarazione. String, Int32, Date 
        'e Person, ossia i tipi che stiamo inserendo nel tipo 
        'generico T, si dicono "tipi generic collegati",
        'poiché collegano il tipo fittizio T con un
        'reale tipo esistente
        Dim Strings As New Collection(Of String)(10, "null")
        Dim Integers As New Collection(Of Int32)(5, 12)
        Dim Dates As New Collection(Of Date)(7, Date.Now)
        Dim Persons As New Collection(Of Person)(10, Nothing)

        Strings.Values(0) = "primo"
        Integers.Values(3) = 45
        Dates.Values(6) = New Date(2009, 1, 1)
        Persons.Values(3) = New Person("Mario", "Rossi", Dates.Last)

        Strings.PrintAll()
        Integers.PrintAll()
        Dates.PrintAll()
        Persons.PrintAll()

        Console.ReadKey()
    End Sub

End Module
Ognuna della quattro variabili del sorgente contiene un oggetto di tipo Collection, ma tali oggetti non sono dello stesso tipo, poiché ognuno espone un differente tipo generics collegato. Quindi, nonostante si tratti sempre della stessa classe Collection, Collection(Of Int32) e Collection(Of String) sono a tutti gli effetti due tipi diversi: è come se esistessero due classi in cui T è sostituito in una da Int32 e nell'altra da String. Per dimostrare la loro diversità, basta scrivere:
Console.WriteLine(Strings.GetType() Is Integers.GetType())
'Output : False


Metodi Generics e tipi generics collegati impliciti

Se si decide di scrivere un solo metodo generics, e di focalizzare su di esso l'attenzione, solo accanto al suo nome apparirà la dichiarazione di un tipo generics aperto, con la consueta clausola "(Of T)". Anche se fin'ora ho usato come nome solamente T, nulla vieta di specificare un altro identificatore valido (ad esempio Pippo): tuttavia, è convenzione che il nome dei tipi generics aperti sia Tn (con n numero intero, ad esempio T1, T2, T3, eccetra...) o, in caso contrario, che inizi almeno con la lettera T (ad esempio TSize, TClass, eccetera...).
Sub [NomeProcedura](Of T)([Parametri])
    '...
End Sub

Function [NomeFunzione](Of T)([Parametri]) As [TipoRestituito]
    '...
End Function
Ecco un semplice esempio:
Module Module1

    'Scambia i valori di due variabili, passate
    'per indirizzo
    Public Sub Swap(Of T)(ByRef Arg1 As T, ByRef Arg2 As T)
        Dim Temp As T = Arg1
        Arg1 = Arg2
        Arg2 = Temp
    End Sub

    Sub Main()
        Dim X, Y As Double
        Dim Z As Single
        Dim A, B As String

        X = 90.0
        Y = 67.58
        Z = 23.01
        A = "Ciao"
        B = "Mondo"

        'Nelle prossime chiamate, Swap non presenta un
        'tipo generics collegato: il tipo viene dedotto dai
        'tipi degli argomenti
        
        'X e Y sono Double, quindi richiama il metodo con
        'T = Double
        Swap(X, Y)
        'A e B sono String, quindi richiama il metodo con
        'T = String
        Swap(A, B)
        
        'Qui viene generato un errore: nonostante Z sia
        'convertibile in Double implicitamente senza perdita
        'di dati, il suo tipo non corrisponde a quello di X,
        'dato che c'è un solo T, che può assumere
        'un solo valore-tipo. Per questo è necessario 
        'utilizzare una scappatoia
        'Swap(Z, X)
        
        'Soluzione 1: si esplicita il tipo generic collegato
        Swap(Of Double)(Z, X)
        'Soluzione 2: si converte Z in double esplicitamente
        Swap(CDbl(Z), X)

        Console.ReadKey()
    End Sub
End Module 


Generics multipli

Quando, anziché un solo tipo generics, se ne specificano due o più, si parla di genrics multipli. La dichiarazione avviene allo stesso modo di come abbiamo visto precedentemente e i tipi vengono separati da una virgola:
Module Module2
    'Una relazione qualsiasi fra due oggetti di tipo indeterminato
    Public Class Relation(Of T1, T2)
        Private Obj1 As T1
        Private Obj2 As T2

        Public ReadOnly Property FirstObject() As T1
            Get
                Return Obj1
            End Get
        End Property

        Public ReadOnly Property SecondObject() As T2
            Get
                Return Obj2
            End Get
        End Property

        Sub New(ByVal Obj1 As T1, ByVal Obj2 As T2)
            Me.Obj1 = Obj1
            Me.Obj2 = Obj2
        End Sub
    End Class

    Sub Main()
        'Crea una relazione fra uno studente e un insegnante,
        'utilizzando le classi create nei capitoli precedenti
        Dim R As Relation(Of Student, Teacher)
        Dim S As New Student("Pinco", "Pallino", Date.Parse("25/06/1990"), _
            "Liceo Scientifico N. Copernico", 4)
        Dim T As New Teacher("Mario", "Rossi", Date.Parse("01/07/1950"), _
        "Matematica")

        'Crea una nuova relazione tra lo studente e l'insegnante
        R = New Relation(Of Student, Teacher)(S, T)
        Console.WriteLine(R.FirstObject.CompleteName)
        Console.WriteLine(R.SecondObject.CompleteName)

        Console.ReadKey()
    End Sub
End Module
Notate che è anche possibile creare una relazione tra due relazioni (e la cosa diventa complicata):
Dim S As New Student("Pinco", "Pallino", Date.Parse("25/06/1990"), "Liceo Scientifico N. Copernico", 4)
Dim T As New Teacher("Mario", "Rossi", Date.Parse("01/07/1950"), "Matematica")
Dim StudentTeacherRelation As Relation(Of Student, Teacher)
Dim StudentClassRelation As Relation(Of Student, String)
Dim Relations As Relation(Of Relation(Of Student, Teacher), Relation(Of Student, String))

StudentTeacherRelation = New Relation(Of Student, Teacher)(S, T)
StudentClassRelation = New Relation(Of Student, String)(S, "5A")
Relations = New Relation(Of Relation(Of Student, Teacher), Relation(Of Student, String))(StudentTeacherRelation, StudentClassRelation)

'Relations.FirstObject.FirstObject
' > Student "Pinco Pallino"
'Relations.FirstObject.SecondObject
' > Teacher "Mario Rossi"
'Relations.SecondObject.FirstObject
' > Student "Pinco Pallino"
'Relations.SecondObject.SecondObject
' > String "5A"


Alcune regole per l'uso dei Generics

  • Si può sempre assegnare Nothing a una variabile di tipo generics. Nel caso il tipo generics collegato sia reference, alla variabile verrà assegnato normalmente Nothing; in caso contrario, essa assumerà il valore di default per il tipo;
  • Non si può ereditare da un tipo generic aperto:
    Class Example(Of T)
        Inherits T
        ' SBAGLIATO
    End Class
    Tuttavia si può ereditare da una classe generics specificando come tipo generics collegato lo stesso tipo aperto:
    Class Example(Of T)
        Inherits List(Of T)
        ' CORRETTO
    End Class
  • Allo stesso modo, non si può implementare T come se fosse un'interfaccia:
    Class Example(Of T)
        Implements T
        ' SBAGLIATO
    End Class
    Ma si può implementare un'interfaccia generics di tipo T:
    Class Example(Of T)
        Implements IEnumerable(Of T)
        ' CORRETTO
    End Class
  • Entità con lo stesso nome ma con generics aperti differenti sono considerate in overload. Pertanto, è lecito scrivere:
    Sub Example(Of T)(ByVal A As T)
        '...
    End Sub
    
    Sub Example(Of T1, T2)(ByVal A As T1)
        '...
    End Sub
<< Precedente Prossimo >>
A proposito dell'autore

Programmatore e analista .NET 2005/2008/2010 (in particolare C# e VB.NET), anche nell'implementazione Mono per Linux. Conoscenze approfondite di Pascal, PHP, XML, HTML 4.01/5, CSS 2.1/3, Javascript (e jQuery). Conoscenze buone di C, LUA, GML, Ruby, XNA, AJAX e Assembly 68000. Competenze basilari di C++, SQL, Hlsl, Java.