Génériques, héritage et résolution de méthode échouée du compilateur C#

Question

J'ai rencontré un problème de compilation aujourd'hui qui m'a déconcerté. Considérez ces deux classes de conteneur.

public class BaseContainer<T> : IEnumerable<T> 
{ 
    public void DoStuff(T item) { throw new NotImplementedException(); } 

    public IEnumerator<T> GetEnumerator() { } 
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { } 
} 
public class Container<T> : BaseContainer<T> 
{ 
    public void DoStuff(IEnumerable<T> collection) { } 

    public void DoStuff <Tother>(IEnumerable<Tother> collection) 
     where Tother: T 
    { 
    } 
} 

Les anciens et les DoStuff(T item) définit celui-ci avec le surcharge DoStuff <Tother>(IEnumerable<Tother>) spécifiquement pour contourner l'absence de covariance/contravariance de C# (jusqu'à 4 je l'entends).

Ce code

Container<string> c = new Container<string>(); 
c.DoStuff("Hello World"); 

frappe une erreur de compilation assez étrange. Notez l'absence de <char> à partir de l'appel de méthode.

Le type 'char' ne peut pas être utilisé comme paramètre de type 'Tautre' dans le type générique ou la méthode 'Container.DoStuff (System.Collections.Generic.IEnumerable). Il n'y a pas de conversion de boxe de 'char' à 'string'.

Essentiellement, le compilateur essaie de bloquer mon appel à DoStuff(string) en Container.DoStuff<char>(IEnumerable<char>) parce que string met en œuvre IEnumerable<char>, plutôt que d'utiliser BaseContainer.DoStuff(string).

La seule façon que j'ai trouvé pour faire de cette compilation est d'ajouter DoStuff(T) à la classe dérivée

public class Container<T> : BaseContainer<T> 
{ 
    public new void DoStuff(T item) { base.DoStuff(item); } 

    public void DoStuff(IEnumerable<T> collection) { } 

    public void DoStuff <Tother>(IEnumerable<Tother> collection) 
     where Tother: T 
    { 
    } 
} 

Pourquoi le compilateur tente de bloquer une chaîne comme IEnumerable<char> quand 1), il sait qu'il peut » t (étant donné la présence d'une erreur de compilation) et 2) il a une méthode dans la classe de base qui compile bien? Ai-je mal compris quelque chose sur les génériques ou les trucs de méthode virtuelle en C#? Y a-t-il une autre solution autre que l'ajout d'un new DoStuff(T item) à Container?

Answer 1

Modifier

Ok ... Je pense que je vois votre confusion maintenant. Vous vous êtes attendu à ce que DoStuff (chaîne) ait gardé le paramètre sous forme de chaîne et ait parcouru la liste des méthodes BaseClass en recherchant d'abord une signature appropriée, et en échouant cette tentative de conversion du paramètre en un autre type.

Mais il est arrivé l'inverse ... Au lieu Container.DoStuff(string) est allé, meh "theres une méthode de classe de base là-bas qui correspond à la facture, mais je vais convertir en un IEnumerable et avoir une crise cardiaque sur ce qui est disponible dans la classe actuelle à la place ...

Hmmm ... Je suis sûr que Jon ou Marc seraient en mesure de carillon à ce point au paragraphe spécifique C# Spec couvre ce coin cas

originale

Les deux méthodes attendent un Col IEnumerable lection

Vous passez une chaîne individuelle.

Le compilateur prend cette chaîne et va,

Ok, j'ai une chaîne, deux méthodes attendre un IEnumerable<T>, donc je vais transformer cette chaîne en un IEnumerable<char> ... Fait

droite, cochez la première méthode ... hmmm ... cette classe est un Container<string> mais j'ai une IEnumerable<char> si ça ne va pas.

Vérifiez la deuxième méthode, hmmm .... Je ont un IEnumerable<char> mais ombles n'implémente pas la chaîne de sorte que ce ne va pas non plus.

COMPILER erreur

Alors, que # s le correctif, bien que cela dépend complètement ce que vous essayez d'atteindre ... les deux éléments suivants seraient valables, pour l'essentiel, vos types d'utilisation est juste incorrect dans votre incarnation.

 Container<char> c1 = new Container<char>(); 
     c1.DoStuff("Hello World"); 

     Container<string> c2 = new Container<string>(); 
     c2.DoStuff(new List<string>() { "Hello", "World" }); 

Answer 2

Je pense que cela a quelque chose à voir avec le fait que char est un type de valeur et que string est un type de référence. On dirait que vous définissez

TOther : T 

et le charbon ne dérive pas de chaîne.

Answer 3

Le compilateur essaie de faire correspondre le paramètre à IEnumerable <T>. Le type String implémente IEnumerable <char>, donc il suppose que T est "char". Après cela, le compilateur vérifie l'autre condition "où OtherT: T", et cette condition n'est pas remplie. D'où l'erreur du compilateur.

Answer 4

Mon GUESS, et c'est une supposition parce que je ne sais pas vraiment, c'est qu'il regarde d'abord dans la classe dérivée pour résoudre l'appel de la méthode (parce que votre objet est celui du type dérivé). Si, et seulement s'il ne le peut pas, il passe à l'examen des méthodes des classes de base pour le résoudre. Dans votre cas, comme il peut résoudre le problème en utilisant la surcharge, il a essayé de le bloquer dans cela. Donc, il peut résoudre le problème en ce qui concerne le paramètre, mais il se heurte à un problème sur les contraintes. À ce stade, il est déjà résolu votre surcharge, donc il ne regarde pas plus loin, mais renvoie juste une erreur. Avoir du sens?

Answer 5

Comme Eric Lippert a expliqué, le compilateur choisit la méthode DoStuff<Tother>(IEnumerable<Tother>) where Tother : T {} parce qu'il choisit les méthodes avant de vérifier les contraintes. Puisque la chaîne peut faire IEnumerable<>, le compilateur l'associe à cette méthode de classe enfant. Le compilateur fonctionne correctement comme décrit dans la spécification C#.

L'ordre de résolution de méthode souhaité peut être forcé en implémentant DoStuff en tant que extension method. Les méthodes d'extension sont vérifiées après méthodes de classe de base, donc il ne sera pas essayer de faire correspondre string contre l » IEnumerable<Tother>DoStuff jusqu'à après il a essayé de faire correspondre contre DoStuff<T>.

Le code suivant illustre l'ordre, la covariance et l'héritage de résolution de méthode souhaités. Veuillez le copier/coller dans un nouveau projet.

Ce plus grand inconvénient je peux penser est si loin que vous ne pouvez pas utiliser base dans les méthodes prépondérants, mais je pense qu'il ya des façons de contourner cela (vous demander si vous êtes intéressé).

using System; 
using System.Collections.Generic; 

namespace MethodResolutionExploit 
{ 
    public class BaseContainer<T> : IEnumerable<T> 
    { 
     public void DoStuff(T item) { Console.WriteLine("\tbase"); } 
     public IEnumerator<T> GetEnumerator() { return null; } 
     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return null; } 
    }   
    public class Container<T> : BaseContainer<T> { } 
    public class ContainerChild<T> : Container<T> { } 
    public class ContainerChildWithOverride<T> : Container<T> { } 
    public static class ContainerExtension 
    { 
     public static void DoStuff<T, Tother>(this Container<T> container, IEnumerable<Tother> collection) where Tother : T 
     { 
      Console.WriteLine("\tContainer.DoStuff<Tother>()"); 
     } 
     public static void DoStuff<T, Tother>(this ContainerChildWithOverride<T> container, IEnumerable<Tother> collection) where Tother : T 
     { 
      Console.WriteLine("\tContainerChildWithOverride.DoStuff<Tother>()"); 
     } 
    } 

    class someBase { } 
    class someChild : someBase { } 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Console.WriteLine("BaseContainer:"); 
      var baseContainer = new BaseContainer<string>(); 
      baseContainer.DoStuff(""); 

      Console.WriteLine("Container:"); 
      var container = new Container<string>(); 
      container.DoStuff(""); 
      container.DoStuff(new List<string>()); 

      Console.WriteLine("ContainerChild:"); 
      var child = new ContainerChild<string>(); 
      child.DoStuff(""); 
      child.DoStuff(new List<string>()); 

      Console.WriteLine("ContainerChildWithOverride:"); 
      var childWithOverride = new ContainerChildWithOverride<string>(); 
      childWithOverride.DoStuff(""); 
      childWithOverride.DoStuff(new List<string>()); 

      //note covariance 
      Console.WriteLine("Covariance Example:"); 
      var covariantExample = new Container<someBase>(); 
      var covariantParameter = new Container<someChild>(); 
      covariantExample.DoStuff(covariantParameter); 

      // this won't work though :(
      // var covariantExample = new Container<Container<someBase>>(); 
      // var covariantParameter = new Container<Container<someChild>>(); 
      // covariantExample.DoStuff(covariantParameter); 

      Console.ReadKey(); 
     } 
    } 
} 

est ici la sortie:

BaseContainer: 
     base 
Container: 
     base 
     Container.DoStuff<Tother>() 
ContainerChild: 
     base 
     Container.DoStuff<Tother>() 
ContainerChildWithOverride: 
     base 
     ContainerChildWithOverride.DoStuff<Tother>() 
Covariance Example: 
     Container.DoStuff<Tother>() 

Pouvez-vous voir des problèmes avec ce travail autour?

Answer 6

Je ne suis pas vraiment clair sur ce que vous essayez d'accomplir, ce qui vous empêche de simplement en utilisant deux méthodes, DoStuff(T item) and DoStuff(IEnumerable<T> collection)?