Avec l’un de mes collègues, nous avons récemment eu un débat autour de cette question, que nous avons fini par élucider. Voici le contexte : nous avons une classe A et une classe B, aucun héritage n’existe entre ces 2 classes, par contre nous redéfinissons l’opérateur de cast explicite de cette manière :

   1:  public class B

   2:  {

   3:  }

   4:   

   5:  public class A

   6:  {

   7:      public static explicit operator B(A a)

   8:      {

   9:          return new B();

  10:      }

  11:  }

Une fois que nous avons défini ces 2 classes, il est tout à fait possible d’effectuer un cast entre un objet A et un objet B :

   1:  A a = new A();

   2:   

   3:  B b = (B)a;

Maintenant que ce passe-t-il si on instancie une liste d’objets A et que l’on appelle la méthode d’extension Cast<T> comme ceci :

   1:  var list = new List<A>() { new A(), new A() };

   2:  list.Cast<B>().ToList();

Et bien à l’exécution, notre opérateur de cast explicite n’est pas appelé. Par contre une exception InvalidCastException est levée. La première réponse que l’on m’a donné était de dire que la méthode d’extension Cast<T> ne fait pas un cast…

Utilisons notre outil préféré (ou presque puisqu’il va bientôt devenir payant… ;)) Reflector. En reflectant la méthode Cast<T>, on peut voir qu’elle fait appel à la classe CastIterator. Celle-ci est tout simplement un itérateur sur notre collection qui dans la méthode MoveNext affecte à l’objet courant l’objet casté :

Donc oui la méthode Cast<T> fait un cast… d’après le code C#.  Car en fait, plus précisément, elle fait une opération de type unbox.any, comme le montre le code IL suivant :

C’est justement là qu’est notre problème. La classe CastIterator ne connait pas notre type A et elle itère sur une liste de type IEnumerable. Donc pour la classe CastIterator, nos objets sont de type System.Object. A cet endroit, un cast est effectué entre un objet de type System.Object et un type TResult. Du coup il fait un unbox (équivalent à l’opérateur castclass).

Décompilons maintenant le code écrit au tout début de ce post, qui caste notre variable de type A en type B :

Nous voyons bien que le compilateur a trouvé notre opérateur explicite et donc l’appelle pour effectuer la conversion.

Pour reproduire ce qu’il se passe au niveau du CastIterator, il suffit d’écrire ceci :

   1:  A a = new A();

   2:   

   3:  object o = a;

   4:   

   5:  B b = (B)o;

Et ici, le compilateur fait appel à l’opérateur castclass et non à notre opérateur de cast explicite :

Pour palier ce problème nous avons 2 solutions. La 1ère consiste à effectuer le cast soit même dans un Select :

   1:  var list = new List<A>() { new A(), new A() };

   2:  var result = list.Select(a => (B) a);

La seconde solution consiste a utiliser le mécanisme de Reflection pour retrouver l’existence de l’opérateur. On peut ainsi définir la méthode d’extension suivante :

   1:  public static class EnumarableExtensions

   2:  {

   3:      public static MethodInfo GetMethod(Type toSearch, string methodName, Type returnType, BindingFlags bindingFlags)

   4:      {

   5:          return Array.Find(toSearch.GetMethods(bindingFlags), delegate(MethodInfo inf) { return ((inf.Name == methodName) && (inf.ReturnType == returnType)); });

   6:      }

   7:   

   8:      public static IEnumerable<T> DynamicCast<T>(this IEnumerable list)

   9:      {

  10:          foreach (var obj in list)

  11:          {

  12:              Type ot = obj.GetType();

  13:              MethodInfo meth = GetMethod(ot, "op_Implicit", typeof(T), BindingFlags.Static | BindingFlags.Public);

  14:   

  15:              if (meth == null)

  16:              {

  17:                  meth = GetMethod(ot, "op_Explicit", typeof(T), BindingFlags.Static | BindingFlags.Public);

  18:              }

  19:   

  20:              if (meth == null)

  21:                  yield return (T)obj;

  22:              else

  23:                  yield return (T)meth.Invoke(null, new[] { obj });

  24:          }

  25:   

  26:      }

  27:  }

Et notre appel se fait ainsi :

   1:  var list = new List<A>() { new A(), new A() };

   2:  var result = list.DynamicCast<B>();

Et voilà un mystère d’élucidé! :)