Covariância e Contravariância (Visual Basic)

Em Visual Basic, a covariância e a contravariância permitem a conversão implícita de referência para tipos de matrizes, tipos de delegados e argumentos genéricos. A covariância preserva a compatibilidade da atribuição e a contravariância inverte-a.

O código que se segue demonstra a diferença entre compatibilidade de atribuição, covariância e contravabilidade.

' Assignment compatibility.
Dim str As String = "test"
' An object of a more derived type is assigned to an object of a less derived type.
Dim obj As Object = str

' Covariance.
Dim strings As IEnumerable(Of String) = New List(Of String)()
' An object that is instantiated with a more derived type argument
' is assigned to an object instantiated with a less derived type argument.
' Assignment compatibility is preserved.
Dim objects As IEnumerable(Of Object) = strings

' Contravariance.
' Assume that there is the following method in the class:
' Shared Sub SetObject(ByVal o As Object)
' End Sub
Dim actObject As Action(Of Object) = AddressOf SetObject

' An object that is instantiated with a less derived type argument
' is assigned to an object instantiated with a more derived type argument.
' Assignment compatibility is reversed.
Dim actString As Action(Of String) = actObject

A covariância para matrizes permite a conversão implícita de um conjunto de um tipo mais derivado para uma matriz de um tipo menos derivado. Mas esta operação não é tipo seguro, como mostra o seguinte exemplo de código.

Dim array() As Object = New String(10) {}
' The following statement produces a run-time exception.
' array(0) = 10

O suporte à covariância e contravariância para grupos de métodos permite a correspondência de assinaturas de métodos com os tipos de delegados. Isto permite-lhe atribuir aos delegados não só métodos que tenham assinaturas correspondentes, mas também métodos que devolvem tipos mais derivados (covariância) ou que aceitam parâmetros que têm menos tipos derivados (contravariância) do que os especificados pelo tipo de delegado. Para obter mais informações, consulte Variação em Delegados (Visual Basic) e Utilização de Variação em Delegados (Visual Basic).

O exemplo de código que se segue mostra o suporte à covariância e contravariância para grupos de métodos.

Shared Function GetObject() As Object
    Return Nothing
End Function

Shared Sub SetObject(ByVal obj As Object)
End Sub

Shared Function GetString() As String
    Return ""
End Function

Shared Sub SetString(ByVal str As String)

End Sub

Shared Sub Test()
    ' Covariance. A delegate specifies a return type as object,
    ' but you can assign a method that returns a string.
    Dim del As Func(Of Object) = AddressOf GetString

    ' Contravariance. A delegate specifies a parameter type as string,
    ' but you can assign a method that takes an object.
    Dim del2 As Action(Of String) = AddressOf SetObject
End Sub

Em .NET Framework 4 ou posteriormente, Visual Basic suporta a covariância e contravariância em interfaces genéricas e delegados e permite a conversão implícita de parâmetros genéricos do tipo. Para obter mais informações, consulte Variação em Interfaces Genéricas (Visual Basic) e Variação em Delegados (Visual Basic).

O exemplo de código a seguir mostra uma conversão implícita de referência para interfaces genéricas.

Dim strings As IEnumerable(Of String) = New List(Of String)
Dim objects As IEnumerable(Of Object) = strings

Uma interface genérica ou delegado é chamada de variante se os seus parâmetros genéricos forem declarados covariante ou contravariante. Visual Basic permite-lhe criar as suas próprias interfaces e delegados variantes. Para obter mais informações, consulte Criar Interfaces Genéricas variantes (Visual Basic) e Variação em Delegados (Visual Basic).

Tópicos relacionados