Partilhar via

Como: Definir uma classe que pode fornecer funcionalidade idêntica em diferentes tipos de dados (Visual Basic)

  • Artigo

Você pode definir uma classe a partir 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. A classe pode então 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 Object tipo.

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 type

  1. Defina a classe da maneira normal.

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

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

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

    • Suporta uma operação, como >, que seu código executa

    • Suporta 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 são aqueles suportados pelo Tipo de Dados do Objeto. Para obter mais informações, consulte Lista de tipos.

  5. Identifique cada membro da classe que deve ser declarado com um tipo fornecido e declare-o As typeparameter. Isso se aplica ao armazenamento interno, parâmetros de procedimento e valores de retorno.

  6. Certifique-se de que seu código usa apenas operações e métodos suportados por qualquer tipo de dados que ele possa fornecer ao itemType.

    O exemplo a seguir define uma classe que gerencia uma lista muito simples. Ele contém a lista na matriz itemsinterna e o código de uso pode declarar o tipo de dados dos elementos da 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 Integer valores, outra classe para manter uma lista de String valores e outra para manter Date valores. Exceto para o tipo de dados dos membros da lista, os objetos criados a partir de todas essas classes se comportam de forma idêntica.

    O argumento type que o código usando fornece para itemType pode ser um tipo intrínseco, como Boolean ou Double, uma estrutura, uma enumeração ou qualquer tipo de classe, incluindo uma 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

Consulte também