Variance en C# 4.0

Ce code :

IEnumerable<object> test = new List<string>();

Ne compilera pas sous .NET 3.5 et donnera ce message d'erreur : « Cannotimplicitlyconvert type 'System.Collections.Generic.List<string>' to 'System.Collections.Generic.IEnumerable<object>'. An explicit conversion exists (are youmissing a cast?) »

Pourtant List<T> implémente bien IEnumerable<T>, et string est bien dérivé d'object. Mais comme IEnumerable<T> n'est pas covariant, un IEnumerable <string> ne peut être considéré comme un IEnumerable<object> ! (cf. définition : du plus dérivé vers le moins dérivé).

Par contre, à partir de 4.0, pas de problème car IEnumerable<T> est covariant : le paramètre de sortie de type T peut être considéré comme un type U si T dérive de U.

Tentons une définition de la covariance : compatibilité d'assignation, pour une interface ou un délégué ayant un ou plusieurs paramètres génériques de sortie(voir plus bas) de type T1,T2... avec le même interface ou délégué ayant les paramètres génériques de sortie U1,U2... si T1,T2... dérivent de U1,U2...

Toutes les interfaces ne sont pas covariantes en .NET 4.0. Voici la liste de la liste de celles qui le sont :

• IEnumerable<out T>(T est covariant) ;
• IEnumerator<out T>(T est covariant) ;
• IQueryable<out T>(T est covariant) ;
• IGrouping<out TKey, out TElement>(TKeyetTElementsontcovariants) ;
• tous les délégués Func<in T1... , out TResult> (TResult est covariant).

Comme on le voit, la covariance ne concerne pas que les interfaces. Les délégués peuvent aussi être covariants :

public Func<string> stringfunc;
Func<object> objectfunc = stringfunc;

Comme vu dans cet exemple, je peux utiliser une fonction qui renvoie T comme une fonction qui renvoie U si T est dérivé de U.

Pour rendre une interface ou un délégué covariant, il faut ajouter le mot-clé out (http://msdn.microsoft.com/en-us/library/dd469487.aspx) au type paramètre concerné. Comme le mot-clé l'indique, celui-ci ne peut alors se trouver uniquement en paramètre de sortie.

2-B-1. Exemple d'interface covariant▲

    public interface IFruitTree<out T>
   {
       T GetFruit();
   }

    public class Tree { }
   public class Fruit { }
   public class Orange : Fruit { }
   public class OrangeTree : Tree, IFruitTree<Orange>
   {
       public Orange GetFruit()
       {
           return new Orange();
       }
   }

public void CatchFruit(IFruitTree<Fruit> fruittree)
{
           ///
}

var o = new OrangeTree();
CatchFruit(o);

2-B-2. Exemple de délégué covariant▲

public delegate T CovariantDelegate<out T>();
void ShowCovariance()
{
   var stringdelegate = new CovariantDelegate<string>(ReturnString);
   CovariantDelegate<object> objectdelegate = stringdelegate;
   object result = objectdelegate.Invoke();
 }
public string ReturnString()
{
   return "Covariance";
}

public interface IsInhabited<out T>
{   
   T DoSomething(T param);
}

public Func<Exception, int> OKFunc;
public Func<object, int> ProblemsAhead;
void Main()
{
 OKFunc = CountStackTrace;
 ProblemsAhead = OKFunc;
 ...
 var something = ProblemsAhead(new object());
}
public int CountStackTrace(Exception e)
{
 return e.StackTrace.Count();
}

Imaginons que nous ayons ceci :

    public class Animal {}
   public class Dog : Animal {}

Ainsi qu'un comparateur entre Animal qui implémente IEqualityComparer<T> (qui est contravariant) :

public class CompareAnimals : IEqualityComparer<Animal>
{
 public bool Equals(Animal x, Animal y)
 { 
   . 
 }
 public int GetHashCode(Animal obj)
 {
   .
 }
}

Si nous avons une liste de Dog, ceci est valide :

var dogs = new List<Dog>();
var distinct = dogs.Distinct(new CompareAnimals());

Alors que la signature de Distinct dans ce cas est : Distinct<Dog>(IEqualityComparer<Dog> Comparer).

Nous passons donc un type moins dérivé (IEqualityComparer<Animal>) à la place d'un plus dérivé (IEqualityComparer<Dog>). Ça peut paraitre paradoxal mais revenons à une définition plus affinée : conversion des paramètres d'entrées du moins dérivé vers le plus dérivé.

En effet : la covariance est uniquement sur les paramètres de sortie et la contravariance est uniquement sur les paramètres d'entrées. Distinct va appeler la méthode Equal(Animal x, Animal y) en lui passant deux instances de Dog alors qu'elle attend deux instances d'Animal. Mais, vu que Dog dérive d'Animal, ça ne pose pas de problème ! Ce qui semble contre nature est en fait tout à fait logique.

Tentons maintenant une définition de la contravariance : compatibilité d'assignation, pour un interface ou un délégué ayant un ou plusieurs paramètres génériques d'entréede type T1,T2... avec le même interface ou délégué ayant les paramètres génériques d'entrée U1,U2... si U1,U2... dérivent de T1,T2...

Voilà la liste des interfaces contravariants de .NET 4.0 :

• IComparer<in T>(T est contravariant) ;
• IEqualityComparer<in T>(T est contravariant) ;
• IComparable<in T>(T est contravariant) ;
• tous les délégués Action<in T>, Action<in T1...>(T, T1... sont contravariants) ;
• tous les délégués Func<in T1..., outTResult>(T, T1... sont contravariants).

Comme pour la covariance, les délégués peuvent aussi être contravariants :

public Action<object> OKAction;
void ShowCovariance()
{
 OKAction = new Action<object>((o) => o.ToString());
 DoSomethingWithAction(OKAction);
} 
static void DoSomethingWithAction(Action<string> action)
{
 action("Contravariance");
}

Pour créer une interface ou un délégué contravariant, il faut utiliser le mot-clé in (http://msdn.microsoft.com/en-us/library/dd469484.aspx). Comme le nom l'indique aussi, les paramètres en in ne peuvent être que des paramètres d'entrées.

3-B-1. Exemple d'interface contravariant▲

public interface ICompareWeigth<in T> where T:Animal
{
  int Weight { get; set; }

  bool SameWeight(T animal);
}

public class CompareAnimalWeight : ICompareWeigth<Animal>
{
  public int CompareWeight (Animal animal1, Animal animal2) 
  {
    // do something;
  }
}

public int CompareDogWeight(ICompareWeigth<Dog> comparison, Dog dog1, Dog dog2)
{
  return comparison.CompareWeight(dog1,dog2);
}

CompareDogWeight(new CompareAnimalWeight(), new Dog(), new Dog());

3-B-2. Exemple de délégué contravariant▲

public delegate void ContravariantDelegate<in T>(T param);
public void DoThing(object o){}
public void TestContravariance(ContravariantDelegate<string> del)
{
 del.Invoke("Contravariance");
}
void ShowContravariance()
{
 ContravariantDelegate<object> OKDelegate = DoThing;
 TestContravariance(OKDelegate);
}