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 reverte.

O código a seguir demonstra a diferença entre a compatibilidade da atribuição, a covariância e a 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 é fortemente tipada, 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. Isso permite atribuir a delegados não apenas os métodos que têm correspondência de assinaturas, mas também métodos que retornam tipos mais derivados (covariância) ou que aceitam parâmetros que têm tipos menos derivados (contravariância) do que o especificado 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 da covariância e da 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 mais recente, 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 será chamado 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ópicos Relacionados

Título	Descrição
Variação em interfaces genéricas (Visual Basic)	Discute a covariância e a contravariância em interfaces genéricas e fornece uma lista de interfaces genéricas variáveis 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 de covariância e contravariância nas interfaces IEnumerable<T> e IComparable<T> pode ajudar na reutilização do 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.