Varianza en Interfaces genéricas (Visual Basic)Variance in Generic Interfaces (Visual Basic)

En .NET Framework 4 se ha presentado la compatibilidad con la varianza para varias interfaces genéricas existentes..NET Framework 4 introduced variance support for several existing generic interfaces. La compatibilidad con la varianza permite la conversión implícita de clases que implementan estas interfaces.Variance support enables implicit conversion of classes that implement these interfaces. Las interfaces siguientes ahora son variantes:The following interfaces are now variant:

La covarianza permite que un método tenga un tipo de valor devuelto más derivado que los que se definen en los parámetros de tipo genérico de la interfaz.Covariance permits a method to have a more derived return type than that defined by the generic type parameter of the interface. Para ilustrar la característica de la covarianza, considere estas interfaces genéricas: IEnumerable(Of Object) y IEnumerable(Of String).To illustrate the covariance feature, consider these generic interfaces: IEnumerable(Of Object) and IEnumerable(Of String). La interfaz IEnumerable(Of String) no hereda la interfaz IEnumerable(Of Object).The IEnumerable(Of String) interface does not inherit the IEnumerable(Of Object) interface. En cambio, el tipo String hereda el tipo Object, y en algunos casos puede que quiera asignar objetos de estas interfaces entre sí.However, the String type does inherit the Object type, and in some cases you may want to assign objects of these interfaces to each other. Esto se muestra en el ejemplo de código siguiente.This is shown in the following code example.

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

En versiones anteriores de .NET Framework, este código provoca un error de compilación en Visual Basic con Option Strict On.In earlier versions of the .NET Framework, this code causes a compilation error in Visual Basic with Option Strict On. Pero ahora puede usar strings en lugar de objects, como se muestra en el ejemplo anterior, porque la interfaz IEnumerable<T> es covariante.But now you can use strings instead of objects, as shown in the previous example, because the IEnumerable<T> interface is covariant.

La contravarianza permite que un método tenga tipos de argumento menos derivados que los que se especifican en el parámetro genérico de la interfaz.Contravariance permits a method to have argument types that are less derived than that specified by the generic parameter of the interface. Para ilustrar la contravarianza, se presupone que ha creado una clase BaseComparer para comparar instancias de la clase BaseClass.To illustrate contravariance, assume that you have created a BaseComparer class to compare instances of the BaseClass class. La clase BaseComparer implementa la interfaz IEqualityComparer(Of BaseClass).The BaseComparer class implements the IEqualityComparer(Of BaseClass) interface. Como la interfaz IEqualityComparer<T> ahora es contravariante, puede usar BaseComparer para comparar instancias de clases que heredan la clase BaseClass.Because the IEqualityComparer<T> interface is now contravariant, you can use BaseComparer to compare instances of classes that inherit the BaseClass class. Esto se muestra en el ejemplo de código siguiente.This is shown in the following code example.

' Simple hierarchy of classes.  
Class BaseClass  
End Class  
  
Class DerivedClass  
    Inherits BaseClass  
End Class  
  
' Comparer class.  
Class BaseComparer  
    Implements IEqualityComparer(Of BaseClass)  
  
    Public Function Equals1(ByVal x As BaseClass,  
                            ByVal y As BaseClass) As Boolean _  
                            Implements IEqualityComparer(Of BaseClass).Equals  
        Return (x.Equals(y))  
    End Function  
  
    Public Function GetHashCode1(ByVal obj As BaseClass) As Integer _  
        Implements IEqualityComparer(Of BaseClass).GetHashCode  
        Return obj.GetHashCode  
    End Function  
End Class  
Sub Test()  
    Dim baseComparer As IEqualityComparer(Of BaseClass) = New BaseComparer  
    ' Implicit conversion of IEqualityComparer(Of BaseClass) to   
    ' IEqualityComparer(Of DerivedClass).  
    Dim childComparer As IEqualityComparer(Of DerivedClass) = baseComparer  
End Sub  

Para obtener más ejemplos, vea usar varianza en Interfaces para las colecciones genéricas (Visual Basic).For more examples, see Using Variance in Interfaces for Generic Collections (Visual Basic).

La varianza para interfaces genéricas solo es compatible con tipos de referencia.Variance in generic interfaces is supported for reference types only. Los tipos de valor no admiten la varianza.Value types do not support variance. Por ejemplo, IEnumerable(Of Integer) no puede convertirse implícitamente en IEnumerable(Of Object), porque los enteros se representan mediante un tipo de valor.For example, IEnumerable(Of Integer) cannot be implicitly converted to IEnumerable(Of Object), because integers are represented by a value type.

Dim integers As IEnumerable(Of Integer) = New List(Of Integer)  
' The following statement generates a compiler error  
' with Option Strict On, because Integer is a value type.  
' Dim objects As IEnumerable(Of Object) = integers  

También es importante recordar que las clases que implementan las interfaces variantes siguen siendo invariables.It is also important to remember that classes that implement variant interfaces are still invariant. Por ejemplo, aunque List<T> implementa la interfaz covariante IEnumerable<T>, no puede convertir List(Of Object) en List(Of String) implícitamente.For example, although List<T> implements the covariant interface IEnumerable<T>, you cannot implicitly convert List(Of Object) to List(Of String). Esto se muestra en el siguiente código de ejemplo.This is illustrated in the following code example.

' The following statement generates a compiler error  
' because classes are invariant.  
' Dim list As List(Of Object) = New List(Of String)  
  
' You can use the interface object instead.  
Dim listObjects As IEnumerable(Of Object) = New List(Of String)  

Vea tambiénSee also