Covariância e contravariância (Visual Basic)

No Visual Basic, covariância e 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 da 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 para uma matriz de um tipo menos derivado. Mas essa operação não é segura de tipo, como 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 a covariância e contravariância para grupos de métodos permite a correspondência de assinaturas de método com tipos 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 menos tipos derivados (contravariância) do que aqueles especificados pelo tipo delegado.

Para obter mais informações, consulte Variância em delegados (Visual Basic) e Usando variância em delegados (Visual Basic).

O exemplo de código a seguir mostra suporte a covariância e contravariância para grupos de método.

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 oferece suporte a covariância e contravariância em interfaces genéricas e delegados e permite a conversão implícita de parâmetros de tipo genéricos. Para obter mais informações, consulte Variância em interfaces genéricas (Visual Basic) e Variância 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 genérica ou delegado é chamada(o) de variante se os seus parâmetros genéricos forem declarados covariante ou contravariante. Visual Basic permite que você crie suas próprias interfaces de variante e delegados. Para obter mais informações, consulte Criação de interfaces genéricas variantes (Visual Basic) e Variância em delegações (Visual Basic).

Artigos relacionados

Título	Descrição
Variância 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 variância 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 código.
Variação em Delegados (Visual Basic)	Discute covariância e contravariância em delegados genéricos e não genéricos e fornece uma lista de delegados genéricos variantes no .NET Framework.
Usando Variância em Delegates (Visual Basic)	Mostra como usar suporte de covariância e contravariância em delegados não genéricos para fazer corresponder assinaturas de métodos aos tipos de delegados.
Usando Variância para Delegados Genéricos Func e Action (Visual Basic)	Mostra como o suporte a covariância e contravariância nos delegados Func e Action pode ajudá-lo a reutilizar código.