Problema de compreensão da contravariância de covariância com genéricos em C #

Não consigo entender por que o seguinte código C # não compila.

Como você pode ver, tenho um método genérico estático Something com um IEnumerable<T>parâmetro (e Testá restrito a ser uma IAinterface) e esse parâmetro não pode ser convertido implicitamente para IEnumerable<IA>.

Qual é a explicação? (Não procuro uma solução alternativa, apenas para entender por que ela não funciona).

public interface IA { }
public interface IB : IA { }
public class CIA : IA { }
public class CIAD : CIA { }
public class CIB : IB { }
public class CIBD : CIB { }

public static class Test
{
    public static IList<T> Something<T>(IEnumerable<T> foo) where T : IA
    {
        var bar = foo.ToList();

        // All those calls are legal
        Something2(new List<IA>());
        Something2(new List<IB>());
        Something2(new List<CIA>());
        Something2(new List<CIAD>());
        Something2(new List<CIB>());
        Something2(new List<CIBD>());
        Something2(bar.Cast<IA>());

        // This call is illegal
        Something2(bar);

        return bar;
    }

    private static void Something2(IEnumerable<IA> foo)
    {
    }
}

Erro que recebo na Something2(bar)fila:

Argumento 1: não é possível converter de 'System.Collections.Generic.List' em 'System.Collections.Generic.IEnumerable'

A mensagem de erro não é suficientemente informativa e a culpa é minha. Me desculpe por isso.

O problema que você está enfrentando é uma consequência do fato de que a covariância só funciona em tipos de referência.

Você provavelmente está dizendo "mas IAé um tipo de referência" agora. Sim, ele é. Mas você não disse que T é igual a IA . Você disse que Té um tipo que implementa IA , e um tipo de valor pode implementar uma interface . Portanto, não sabemos se a covariância funcionará e não a permitimos.

Se você deseja que a covariância funcione, você deve informar ao compilador que o parâmetro de tipo é um tipo de referência com a classrestrição, bem como a IArestrição de interface.

A mensagem de erro realmente deveria dizer que a conversão não é possível porque a covariância requer uma garantia de tipo de referência, uma vez que esse é o problema fundamental.

Eu só queria complementar a excelente resposta interna de Eric com um exemplo de código para aqueles que podem não estar familiarizados com restrições genéricas.

Altere Somethinga assinatura da seguinte forma: A classrestrição tem que vir primeiro .

public static IList<T> Something<T>(IEnumerable<T> foo) where T : class, IA