Compartir a través de

Varianza en interfaces genéricas (C#)

.NET Framework 4 introdujo compatibilidad de varianza para varias interfaces genéricas existentes. La compatibilidad con la varianza permite la conversión implícita de clases que implementan estas interfaces.

A partir de .NET Framework 4, las interfaces siguientes son variantes:

A partir de .NET Framework 4.5, las interfaces siguientes son variantes:

La Covarianza permite que un método tenga un tipo de valor devuelto más derivado que el definido por el parámetro de tipo genérico de la interfaz. Para ilustrar la característica de covarianza, tenga en cuenta estas interfaces genéricas: IEnumerable<Object> y IEnumerable<String>. La IEnumerable<String> interfaz no hereda la IEnumerable<Object> interfaz. Sin embargo, el String tipo hereda el Object tipo y, en algunos casos, es posible que desee asignar objetos de estas interfaces entre sí. Esto se muestra en el ejemplo de código siguiente.

IEnumerable<String> strings = new List<String>();
IEnumerable<Object> objects = strings;

En versiones anteriores de .NET Framework, este código provoca un error de compilación en C# y, si Option Strict está activado, en Visual Basic. Pero ahora puede usar strings en lugar de objects, como se muestra en el ejemplo anterior, porque la IEnumerable<T> interfaz es covariante.

Contravariance permite que un método tenga tipos de argumentos menos derivados que los especificados por el parámetro genérico de la interfaz. Para ilustrar la contravarianza, supongamos que ha creado una BaseComparer clase para comparar instancias de la BaseClass clase. La clase BaseComparer implementa la interfaz IEqualityComparer<BaseClass>. Dado que la IEqualityComparer<T> interfaz ahora es contravariante, puede usar BaseComparer para comparar instancias de clases que heredan la BaseClass clase. Esto se muestra en el ejemplo de código siguiente.

// Simple hierarchy of classes.
class BaseClass { }
class DerivedClass : BaseClass { }

// Comparer class.
class BaseComparer : IEqualityComparer<BaseClass>
{
    public int GetHashCode(BaseClass baseInstance)
    {
        return baseInstance.GetHashCode();
    }
    public bool Equals(BaseClass x, BaseClass y)
    {
        return x == y;
    }
}
class Program
{
    static void Test()
    {
        IEqualityComparer<BaseClass> baseComparer = new BaseComparer();

        // Implicit conversion of IEqualityComparer<BaseClass> to
        // IEqualityComparer<DerivedClass>.
        IEqualityComparer<DerivedClass> childComparer = baseComparer;
    }
}

Para obtener más ejemplos, consulte Uso de varianza en interfaces para colecciones genéricas (C#).

La varianza para interfaces genéricas solo es compatible con tipos de referencia. Los tipos de valor no admiten la varianza. Por ejemplo, IEnumerable<int> no se puede convertir implícitamente en IEnumerable<object>, porque los enteros se representan mediante un tipo de valor.

IEnumerable<int> integers = new List<int>();
// The following statement generates a compiler error,
// because int is a value type.
// IEnumerable<Object> objects = integers;

También es importante recordar que las clases que implementan interfaces variant siguen siendo invariables. Por ejemplo, aunque List<T> implementa la interfaz IEnumerable<T>covariante , no se puede convertir List<String> implícitamente a List<Object>. Esto se muestra en el ejemplo de código siguiente.

// The following line generates a compiler error
// because classes are invariant.
// List<Object> list = new List<String>();

// You can use the interface object instead.
IEnumerable<Object> listObjects = new List<String>();

Consulte también