Compartir a través de


Cómo: Definir una clase que pueda proporcionar la misma funcionalidad en tipos de datos diferentes (Visual Basic)

Puede definir una clase a partir de la cual crear objetos que proporcionen funcionalidad idéntica en tipos de datos diferentes.Para ello, especifica uno o más parámetros de tipo en la definición.La clase puede actuar a continuación como una plantilla para objetos que utilizan distintos tipos de datos.Una clase definida de esta manera se denomina una clase genérica.

La ventaja de definir una clase genérica es que la define una sola vez y el código puede utilizarla para crear diferentes objetos que utilizan una amplia variedad de tipos de datos.De esta manera consigue mayor rendimiento que si define la clase con el tipo Object.

Además de clases, también puede definir y utilizar estructuras genéricas, interfaces, procedimientos y delegados.

Para definir una clase con un parámetro de tipo

  1. Defina la clase de la manera normal.

  2. Agregue (Of parámetroDeTipo) inmediatamente después del nombre de clase para especificar un parámetro de tipo.

  3. Si tiene más de un parámetro de tipo, incluya una lista separada por comas entre paréntesis.No repita la palabra clave Of.

  4. Si el código realiza operaciones en un parámetro de tipo distintas de la asignación, incluya una cláusula As después del parámetro de tipo para agregar una o más restricciones.Una restricción garantiza que el tipo proporcionado para ese parámetro de tipo satisface un requisito como el siguiente:

    • Admite una operación, como >, que realiza el código

    • Admite un miembro, como un método, al que tiene acceso el código

    • Expone un constructor sin parámetros

    Si no especifica ninguna restricción, las únicas operaciones y miembros que puede utilizar el código son las que admite Object (Tipo de datos).Para obtener más información, vea Lista de tipos (Visual Basic).

  5. Identifique cada miembro de clase que se va a declarar con un tipo proporcionado y declárelo As typeparameter.Esto se aplica al almacenamiento interno, parámetros de procedimiento y valores devueltos.

  6. Asegúrese de que el código sólo utiliza operaciones y métodos admitidos por cualquier tipo de datos que puede proporcionar a itemType.

    El ejemplo siguiente define una clase que administra una lista muy simple.Mantiene la lista en la matriz interna items y el código puede declarar el tipo de datos de los elementos de la lista.Un constructor con parámetros permite que el código establezca el límite superior de items y el constructor predeterminado lo establece en 9 (para un total de 10 elementos).

    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
    

    Puede declarar una clase a partir de simpleList para que incluya una lista de valores de tipo Integer, otra clase para que incluya una lista de valores de tipo String y otra para que incluya valores de tipo Date.Los objetos creados a partir de estas clases se comportan de forma idéntica, excepto en el tipo de datos de los miembros de lista.

    El argumento de tipo que el código proporciona a itemType puede ser un tipo intrínseco como Boolean o Double, una estructura, una enumeración o cualquier clase de tipo, incluida una definida por la aplicación.

    Puede probar la clase simpleList con el código siguiente.

    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
    

Vea también

Tareas

Cómo: Usar clases genéricas (Visual Basic)

Referencia

Of (Cláusula, Visual Basic)

Lista de tipos (Visual Basic)

Object (Tipo de datos)

Conceptos

Tipos de datos en Visual Basic

Tipos genéricos en Visual Basic (Visual Basic)

Common Language Specification