Procedura: definire una classe in grado di fornire funzionalità identiche con tipi di dati diversi (Visual Basic)

Articolo
08/11/2011

È possibile definire una classe dalla quale creare oggetti in grado di fornire funzionalità identiche su tipi di dati diversi. A questo scopo, specificare uno o più parametri di tipo nella definizione. La classe potrà quindi servire come modello per gli oggetti che utilizzano tipi di dati diversi. Una classe definita in questo modo viene definita classe generica.

Il vantaggio della definizione di una classe generica sta nel fatto che viene definita un'unica volta e che non è possibile che venga utilizzata dal codice per la creazione di molti oggetti che utilizzano una vasta gamma di tipi di dati. Questa operazione può comportare prestazioni migliori rispetto alla definizione della classe con il tipo Object.

Oltre alle classi, è possibile inoltre definire e utilizzare strutture, interfacce, routine e delegati generici.

Per definire una classe con un parametro di tipo

Definire la classe nel modo normale.
Aggiungere (Of parametrotipo) subito dopo il nome della classe per specificare il tipo di parametro.
Se esiste più di un parametro di tipo, creare un elenco separato da virgole all'interno delle parentesi. Non ripetere la parola chiave Of.
Se le operazioni eseguite dal codice su un parametro di tipo sono diverse da una semplice assegnazione, far seguire il parametro di tipo da una clausola As per l'aggiunta di uno o più vincoli. Grazie a un vincolo si garantisce che il tipo fornito per quel parametro di tipo soddisfa un requisito, ad esempio:
- Supporta un'operazione, quale >, eseguita dal codice
- Supporta un membro, quale un metodo, al quale accede il codice
- Espone un costruttore senza parametri
Se non si specifica alcun vincolo, le uniche operazioni e gli unici membri utilizzati dal codice sono quelli supportati dal Tipo di dati Object. Per ulteriori informazioni, vedere Elenco dei tipi (Visual Basic).
Identificare ogni membro di classi da dichiarare con un tipo fornito e dichiararlo As typeparameter. Ciò si applica all'archiviazione interna, ai parametri della routine e ai valori restituiti.

Accertarsi che il codice utilizzi solo operazioni e metodi supportati da qualsiasi tipo di dati che può fornire a itemType.

Nell'esempio riportato di seguito viene definita una classe che gestisce un elenco molto semplice. La lista è contenuta negli items della matrice interna e il tipo di dati degli elementi dell'elenco può essere dichiarato dal codice di utilizzo. Un costruttore con parametri consente al codice di utilizzo di impostare il limite superiore di items, quindi il costruttore predefinito lo imposta a 9 (per un totale di 10 elementi).

Public Class simpleList(Of itemType)
  Private items() As itemType
  Private top As Integer
  Private nextp As Integer
  Public Sub New()
    Me.New(9)
  End Sub
  Public Sub New(ByVal t As Integer)
    MyBase.New()
    items = New itemType(t) {}
    top = t
    nextp = 0
  End Sub
  Public Sub add(ByVal i As itemType)
    insert(i, nextp)
  End Sub
  Public Sub insert(ByVal i As itemType, ByVal p As Integer)
    If p > nextp OrElse p < 0 Then
      Throw New System.ArgumentOutOfRangeException("p", 
        " less than 0 or beyond next available list position")
    ElseIf nextp > top Then
      Throw New System.ArgumentException("No room to insert at ", 
        "p")
    ElseIf p < nextp Then
      For j As Integer = nextp To p + 1 Step -1
        items(j) = items(j - 1)
      Next j
    End If
    items(p) = i
    nextp += 1
  End Sub
  Public Sub remove(ByVal p As Integer)
    If p >= nextp OrElse p < 0 Then
        Throw New System.ArgumentOutOfRangeException("p", 
            " less than 0 or beyond last list item")
    ElseIf nextp = 0 Then
        Throw New System.ArgumentException("List empty; cannot remove ", 
            "p")
    ElseIf p < nextp - 1 Then
        For j As Integer = p To nextp - 2
            items(j) = items(j + 1)
        Next j
    End If
    nextp -= 1
  End Sub
  Public ReadOnly Property listLength() As Integer
    Get
      Return nextp
    End Get
  End Property
  Public ReadOnly Property listItem(ByVal p As Integer) As itemType
    Get
      If p >= nextp OrElse p < 0 Then
        Throw New System.ArgumentOutOfRangeException("p", 
          " less than 0 or beyond last list item")
        End If
      Return items(p)
    End Get
  End Property
End Class

È possibile dichiarare una classe da simpleList per contenere un elenco di valori relativi alla Integer, un'altra classe per contenere un elenco di valori String e un altro per contenere valori Date. Ad eccezione del tipo di dati dei membri dell'elenco, gli oggetti creati da tutte queste classi si comportano in maniera identica.

L'argomento di tipo fornito dal codice di utilizzo a itemType può essere di tipo intrinseco come Boolean o Double, una struttura, un'enumerazione o qualsiasi tipo di classe, compresa una di quelle definite dall'applicazione.

È possibile verificare la classe simpleList con il codice seguente.

Public Sub useSimpleList()
  Dim iList As New simpleList(Of Integer)(2)
  Dim sList As New simpleList(Of String)(3)
  Dim dList As New simpleList(Of Date)(2)
  iList.add(10)
  iList.add(20)
  iList.add(30)
  sList.add("First")
  sList.add("extra")
  sList.add("Second")
  sList.add("Third")
  sList.remove(1)
  dList.add(#1/1/2003#)
  dList.add(#3/3/2003#)
  dList.insert(#2/2/2003#, 1)
  Dim s = 
    "Simple list of 3 Integer items (reported length " &
     CStr(iList.listLength) & "):" &
     vbCrLf & CStr(iList.listItem(0)) &
     vbCrLf & CStr(iList.listItem(1)) &
     vbCrLf & CStr(iList.listItem(2)) &
     vbCrLf &
     "Simple list of 4 - 1 String items (reported length " &
     CStr(sList.listLength) & "):" &
     vbCrLf & CStr(sList.listItem(0)) &
     vbCrLf & CStr(sList.listItem(1)) &
     vbCrLf & CStr(sList.listItem(2)) &
     vbCrLf &
     "Simple list of 2 + 1 Date items (reported length " &
     CStr(dList.listLength) & "):" &
     vbCrLf & CStr(dList.listItem(0)) &
     vbCrLf & CStr(dList.listItem(1)) &
     vbCrLf & CStr(dList.listItem(2))
  MsgBox(s)
End Sub

Vedere anche

Condividi tramite

Procedura: definire una classe in grado di fornire funzionalità identiche con tipi di dati diversi (Visual Basic)

Per definire una classe con un parametro di tipo

Vedere anche

Attività

Riferimenti

Concetti

Risorse aggiuntive