Compartilhar via

Covariância e contravariância (Visual Basic)

No Visual Basic, a covariância e a contravariância habilitam a conversão de referência implícita para tipos de matriz, tipos delegados e argumentos de tipo genérico. A covariância preserva a compatibilidade de atribuição e a contravariância a reverte.

O código a seguir demonstra a diferença entre compatibilidade de atribuição, covariância e contravariância.

' 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 uma matriz de um tipo mais derivado em uma matriz de um tipo menos derivado. Mas essa operação não é tipo segura, conforme mostrado no exemplo de código a seguir.

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

O suporte de covariância e contravariância aos grupos de método permite a correspondência de assinaturas de método com tipos de delegados. Essa correspondência permite que você atribua a um delegado não apenas um método que tenha uma assinatura correspondente, mas também um método que:

  • Retorna um tipo mais derivado (covariância) do que o tipo de retorno especificado pelo tipo delegado.
  • Aceita parâmetros que têm tipos menos derivados (contravariância) do que os especificados pelo tipo delegado.

Para obter mais informações, consulte Variação em Delegados (Visual Basic) e Usando Variação em Delegados (Visual Basic).

O exemplo de código a seguir mostra o suporte a 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

No .NET Framework 4 ou posterior, o Visual Basic dá suporte à covariância e à contravariância em interfaces e delegados genéricos e permite a conversão implícita de parâmetros de tipo genérico. 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 a conversão de referência implícita para interfaces genéricas.

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

Uma interface ou delegado genérico é chamado de variante se seus parâmetros genéricos forem declarados covariantes ou contravariantes. O Visual Basic permite que você crie suas próprias interfaces variantes e delegados. Para obter mais informações, consulte Criando interfaces genéricas variantes (Visual Basic) e Variação em delegados (Visual Basic).

Título Descrição
Variação em interfaces genéricas (Visual Basic) Discute covariância e contravariância em interfaces genéricas e fornece uma lista de interfaces genéricas variantes no .NET Framework.
Criando interfaces genéricas variantes (Visual Basic) Mostra como criar interfaces variantes personalizadas.
Usando variação em interfaces para coleções genéricas (Visual Basic) Mostra como o suporte à covariância e à contravariância nas interfaces IEnumerable<T> e IComparable<T> pode ajudá-lo a reutilizar o código.
Variação em delegados (Visual Basic) Discute a covariância e a contravariância em interfaces genéricas e não genéricas e fornece uma lista de interfaces genéricas variáveis no .NET Framework.
Usando variação em delegados (Visual Basic) Mostra como usar o suporte de covariância e contravariância em delegados não genéricos para corresponder às assinaturas de método com tipos delegados.
Usando variação para delegados genéricos Func e Action (Visual Basic) Mostra como o suporte de covariância e contravariância nos delegados Func e Action pode ajudar na reutilização do código.