Compartilhar via

Como definir uma classe capaz de fornecer uma funcionalidade idêntica em tipos de dados diferentes (Visual Basic)

  • Artigo

Você pode definir uma classe da qual você pode criar objetos que fornecem funcionalidade idêntica em diferentes tipos de dados. Para fazer isso, especifique um ou mais parâmetros de tipo na definição. Em seguida, a classe pode servir como um modelo para objetos que usam vários tipos de dados. Uma classe definida dessa forma é chamada de classe genérica.

A vantagem de definir uma classe genérica é que você a define apenas uma vez e seu código pode usá-la para criar muitos objetos que usam uma ampla variedade de tipos de dados. Isso resulta em melhor desempenho do que definir a classe com o tipo Object.

Além das classes, você também pode definir e usar estruturas genéricas, interfaces, procedimentos e delegados.

Para definir uma classe com um parâmetro de tipo

  1. Defina a classe da maneira normal.

  2. Adicione (Of typeparameter) imediatamente após o nome de classe para especificar um parâmetro de tipo.

  3. Se você tiver mais de um parâmetro de tipo, faça uma lista separada por vírgula dentro dos parênteses. Não repita a palavra-chave Of.

  4. Se o código executar operações em um parâmetro de tipo diferente de atribuição simples, siga esse parâmetro de tipo com uma cláusula As para adicionar uma ou mais restrições. Uma restrição garante que o tipo fornecido para esse parâmetro de tipo atenda a um requisito como o seguinte:

    • Dá suporte a uma operação, por exemplo >, que seu código executa

    • Dá suporte a um membro, como um método, que seu código acessa

    • Expõe um construtor sem parâmetros

    Se você não especificar nenhuma restrição, as únicas operações e membros que seu código pode usar serão aqueles compatíveis com o Tipo de Dados de Objeto. Para obter mais informações, consulte Lista de Tipos.

  5. Identifique todos os membros da classe que devem ser declarados com um tipo fornecido e declare-os As typeparameter. Isso se aplica ao armazenamento interno, aos parâmetros de procedimento e aos valores retornados.

  6. Verifique se o código usa apenas operações e métodos compatíveis com qualquer tipo de dados que ele possa fornecer para itemType.

    O exemplo a seguir define uma classe que gerencia uma lista muito simples. Ele contém a lista na matriz interna items e o código de uso pode declarar o tipo de dados dos elementos de lista. Um construtor parametrizado permite que o código de uso defina o limite superior de items e o construtor sem parâmetros define isso como 9 (para um total de 10 itens).

    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

    Você pode declarar uma classe de simpleList para manter uma lista de valores de Integer, outra classe para manter uma lista de valores de String e outra para manter valores de Date. Exceto pelo tipo de dados dos membros da lista, os objetos criados de todas essas classes se comportam de maneira idêntica.

    O argumento de tipo que o código de uso fornece para itemType pode ser um tipo intrínseco, como Boolean ou Double, uma estrutura, uma enumeração ou qualquer tipo de classe, incluindo um que seu aplicativo define.

    Você pode testar a classe simpleList com o código a seguir.

    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

Confira também