Comment la covariance et la contre-variance génériques sont-elles mises en œuvre dans C # 4.0?

Je n’ai pas assisté à PDC 2008, mais j’ai entendu des nouvelles que le C # 4.0 est annoncé pour supporter la covariance et la contre-variance génériques. En d’autres termes, List peut être affecté à List . Comment cela pourrait-il être?

Dans le livre de Jon Skeet, C # in Depth , on explique pourquoi les génériques en C # ne supportent pas la covariance et la contre-variance. C’est principalement pour écrire du code sécurisé. Maintenant, C # 4.0 a changé pour les supporter. Cela amènerait-il le chaos?

Quelqu’un sait que les détails sur C # 4.0 peuvent donner des explications?

La variance ne sera supscope que de manière sûre – en fait, en utilisant les capacités du CLR. Donc, les exemples que je donne dans le livre de l’utilisation d’une List tant que List (ou peu importe ce que c’était) ne fonctionneront toujours pas – mais quelques autres scénarios le feront.

Tout d’abord, il ne sera pris en charge que pour les interfaces et les delegates.

Deuxièmement, l’auteur de l’interface / délégué doit décorer les parameters de type comme in (pour contravariance) ou out (pour covariance). L’exemple le plus évident est IEnumerable qui ne vous laisse jamais sortir les valeurs – il ne vous permet pas d’en append de nouvelles. Cela deviendra IEnumerable . Cela ne nuit en rien à la sécurité des types, mais vous permet de renvoyer une IEnumerable partir d’une méthode déclarée pour renvoyer par exemple IEnumerable .

La contre-variance est plus difficile à donner des exemples concrets d’utilisation des interfaces, mais c’est facile avec un délégué. Considérons Action – qui représente simplement une méthode qui prend un paramètre T Ce serait bien de pouvoir convertir de manière transparente une Action en Action – toute méthode qui prend un paramètre d’ object va être correcte quand elle sera présentée avec une ssortingng . Bien sûr, C # 2 a déjà une covariance et une variance des delegates dans une certaine mesure, mais via une conversion réelle d’un type de délégué à un autre (création d’une nouvelle instance) – voir P141-144 pour des exemples. C # 4 rendra cela plus générique, et (je crois) évitera de créer une nouvelle instance pour la conversion. (Ce sera une conversion de référence à la place.)

J’espère que cela clarifie un peu – s’il vous plaît laissez-moi savoir si cela n’a pas de sens!

Ce n’est pas que Jon ne l’a pas déjà couvert, mais voici quelques liens vers des blogs et des vidéos d’Eric Lippert. Il fait un bon travail en l’expliquant avec des exemples.

https://blogs.msdn.microsoft.com/ericlippert/2007/10/16/covariance-and-contravariance-in-c-part-one/

Les vidéos:

https://www.youtube.com/watch?v=3MQDrKbzvqU

https://www.youtube.com/watch?v=XRIadQaBYlI

https://www.youtube.com/watch?v=St9d2EDZfrg