Out (Modificador genérico) (Visual Basic)

En los parámetros de tipo genérico, la palabra clave Out especifica que el tipo es covariante.

Comentarios

La covarianza permite usar un tipo más derivado que el especificado por el parámetro genérico. Esto permite la conversión implícita de las clases que implementan interfaces variantes y de los tipos delegados.

Para obtener más información, vea Covarianza y contravarianza (C# y Visual Basic).

Reglas

Puede usar la palabra clave Out en delegados e interfaces genéricos.

En una interfaz genérica, un parámetro de tipo se puede declarar como covariante si cumple las siguientes condiciones:

  • El parámetro de tipo se usa solamente como tipo de valor devuelto de los métodos de interfaz y no como tipo de los argumentos de método.

    Nota

    Hay una excepción para esta regla. Si en una interfaz covariante tiene un delegado genérico contravariante como parámetro de método, puede usar el tipo covariante como parámetro de tipo genérico para este delegado. Para obtener más información sobre los delegados genéricos covariantes y contravariantes, vea Varianza en delegados (C# y Visual Basic) y Usar la varianza para los delegados genéricos Func y Action (C# y Visual Basic).

  • El parámetro de tipo no se usa como restricción genérica para los métodos de interfaz.

En un delegado genérico, un parámetro de tipo se puede declarar como covariante si se usa solamente como tipo de valor devuelto por un método y no se usa para los argumentos de método.

La covarianza y contravarianza son compatibles con los tipos de referencia, pero no con los tipos de valor.

En Visual Basic, no se pueden declarar eventos en las interfaces covariantes sin especificar el tipo de delegado. Además, una interfaz covariante no puede tener clases, enumeraciones o estructuras anidadas, pero sí interfaces anidadas.

Behavior

Una interfaz con un parámetro de tipo covariante permite que sus métodos devuelvan tipos más derivados que los especificados por el parámetro de tipo. Por ejemplo, dado que en .NET Framework 4, en IEnumerable<T>, el tipo T es covariante, puede asignar un objeto del tipo IEnumerabe(Of String) a otro objeto del tipo IEnumerable(Of Object) sin usar ningún método de conversión especial.

A un delegado covariante se le puede asignar otro delegado del mismo tipo, pero con un parámetro de tipo genérico más derivado.

Ejemplo

En el ejemplo siguiente se muestra cómo declarar, extender e implementar una interfaz genérica covariante. También se muestra cómo usar la conversión implícita para las clases que implementan una interfaz covariante.

' Covariant interface.
Interface ICovariant(Of Out R)
End Interface

' Extending covariant interface.
Interface IExtCovariant(Of Out R)
    Inherits ICovariant(Of R)
End Interface

' Implementing covariant interface.
Class Sample(Of R)
    Implements ICovariant(Of R)
End Class

Sub Main()
    Dim iobj As ICovariant(Of Object) = New Sample(Of Object)()
    Dim istr As ICovariant(Of String) = New Sample(Of String)()

    ' You can assign istr to iobj because
    ' the ICovariant interface is covariant.
    iobj = istr
End Sub

En el ejemplo siguiente se muestra cómo declarar, invocar y crear instancias de un delegado genérico covariante. También se muestra cómo usar la conversión implícita para los tipos de delegado.

' Covariant delegate.
Public Delegate Function DCovariant(Of Out R)() As R

' Methods that match the delegate signature.
Public Shared Function SampleControl() As Control
    Return New Control()
End Function

Public Shared Function SampleButton() As Button
    Return New Button()
End Function

Private Sub Test()

    ' Instantiating the delegates with the methods.
    Dim dControl As DCovariant(Of Control) =
        AddressOf SampleControl
    Dim dButton As DCovariant(Of Button) =
        AddressOf SampleButton

    ' You can assign dButton to dControl
    ' because the DCovariant delegate is covariant.
    dControl = dButton

    ' Invoke the delegate.
    dControl()
End Sub

Vea también

Referencia

In (Modificador genérico) (Visual Basic)

Conceptos

Varianza en interfaces genéricas (C# y Visual Basic)