Compréhension du problème de la contravariance des covariances avec les génériques en C #

Je ne comprends pas pourquoi le code C # suivant ne se compile pas.

Comme vous pouvez le voir, j'ai une méthode générique statique Something avec un IEnumerable<T>paramètre (et Test contraint d'être une IAinterface), et ce paramètre ne peut pas être converti implicitement en IEnumerable<IA>.

Quelle est l'explication? (Je ne recherche pas de solution de contournement, juste pour comprendre pourquoi cela ne fonctionne pas).

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)
    {
    }
}

Erreur que je reçois en Something2(bar)ligne:

Argument 1: impossible de convertir de «System.Collections.Generic.List» en «System.Collections.Generic.IEnumerable»

Le message d'erreur n'est pas suffisamment informatif, et c'est ma faute. Désolé pour ça.

Le problème que vous rencontrez est une conséquence du fait que la covariance ne fonctionne que sur les types de référence.

Vous dites probablement "mais IAest un type de référence" en ce moment. Oui, ça l'est. Mais vous n'avez pas dit que T c'était égal à IA . Vous avez dit que Tc'est un type qui implémente IA , et qu'un type valeur peut implémenter une interface . Par conséquent, nous ne savons pas si la covariance fonctionnera et nous la rejetons.

Si vous voulez que la covariance fonctionne, vous devez indiquer au compilateur que le paramètre de type est un type de référence avec la classcontrainte ainsi que la IAcontrainte d'interface.

Le message d'erreur devrait vraiment dire que la conversion n'est pas possible car la covariance nécessite une garantie de type de référence, puisque c'est le problème fondamental.

Je voulais juste compléter l'excellente réponse d'initié d'Eric avec un exemple de code pour ceux qui ne sont peut-être pas familiers avec les contraintes génériques.

Changez Somethingla signature de la manière suivante: la classcontrainte doit venir en premier .

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