Genéricos, herencia y resolución de métodos fallidos del compilador de C#

Question

Hoy encontré un problema de compilación que me desconcertaba. Considere estas dos clases de contenedor.

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

Los primero define DoStuff(T item) y los segundos sobrecargas de TI con DoStuff <Tother>(IEnumerable<Tother>) específicamente para moverse por la ausencia de covariance/contravariance de C# (hasta 4 escucho).

Este código

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

realiza un error de compilación bastante extraño. Tenga en cuenta la ausencia de <char> de la llamada a método.

El tipo char 'no se puede utilizar como parámetro de tipo 'Tother' en el tipo genérico o método 'Container.DoStuff (System.Collections.Generic.IEnumerable)'. No hay conversión de boxeo de 'char' a 'cadena'.

En esencia, el compilador está tratando de atascar mi llamada a DoStuff(string) en Container.DoStuff<char>(IEnumerable<char>) PORQUE string implementos IEnumerable<char>, en lugar de utilizar BaseContainer.DoStuff(string).

La única forma que he encontrado para hacer esta compilación es añadir DoStuff(T) a la clase derivada

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

¿Por qué es el compilador tratando de atascar una cadena como IEnumerable<char> cuando: 1) se sabe que puede' t (dada la presencia de un error de compilación) y 2) tiene un método en la clase base que compila bien? ¿Estoy malentendiendo algo sobre genéricos o cosas de métodos virtuales en C#? ¿Hay alguna otra solución que no sea agregar un new DoStuff(T item) al Container?

Answer 1

Editar

Ok ... Me parece ver su confusión ahora. Habría esperado que DoStuff (cadena) mantuviera el parámetro como una cadena y recorriera la Lista de métodos de BaseClass buscando primero una firma adecuada y, en su defecto, tratando de convertir el parámetro a otro tipo.

Pero sucedió al revés ... En vez Container.DoStuff(string) fueron, meh "theres un método de clase base hay que encaja a la perfección, pero voy a convertir en una interfaz IEnumerable y tener un ataque al corazón de lo que está disponible en la clase actual en lugar ...

Hmmm ... estoy seguro de Jon o Marc sería capaz de meter su cuchara en este punto con el párrafo C# Spec específica que cubre este caso particular rincón

original

Ambos métodos esperan una Columna IEnumerable lection

Estás pasando una cadena individual.

El compilador está tomando esa cadena y venir,

Ok, tengo una cadena, Ambos métodos esperar una IEnumerable<T>, así que voy a convertir esta cadena en un IEnumerable<char> ... Hecho

correcta, verifica el primer método ... hmmm ... esta clase es un Container<string> pero tengo una IEnumerable<char> de manera que no es correcto.

Comprobar el segundo método, hmmm .... Me tiene un IEnumerable<char> pero Char no implementa cuerda de manera que es no está bien tampoco.

error del compilador

Entonces, ¿qué # s la revisión, así que depende por completo lo que su tratando de lograr ... ambos de los siguientes sería válida, en esencia, su uso de tipos es simplemente incorrecto en tu encarnación.

 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

Creo que tiene algo que ver con el hecho de que char es un tipo de valor y la cadena es un tipo de referencia. Parece que está definiendo

TOther : T 

y char no deriva de la cadena.

Answer 3

El compilador intentará hacer coincidir el parámetro con IEnumerable <T>. El tipo String implementa IEnumerable <char>, por lo que se supone que T es "char".

Después de eso, el compilador comprueba la otra condición "donde OtherT: T" no se cumple, y esa condición. De ahí el error del compilador.

Answer 4

Mi GUESS, y esto es una suposición porque realmente no sé, es que primero se ve en la clase derivada para resolver la llamada al método (porque su objeto es el del tipo derivado). Si, y solo si no puede, pasa a mirar los métodos de las clases base para resolverlo. En su caso, dado que PUEDE resolverlo utilizando la sobrecarga

DoStuff <Tother>(IEnumerable<Tother> collection) 

, intentó atascarse en eso. Por lo tanto, PUEDE resolverlo en lo que respecta al parámetro, pero luego se topa con un obstáculo en las restricciones. En ese punto, ya se ha resuelto su sobrecarga, por lo que no busca más, pero solo genera un error. ¿Tener sentido?

Answer 5

Como se ha explicado Eric Lippert, el compilador elige el método DoStuff<Tother>(IEnumerable<Tother>) where Tother : T {} porque elige métodos antes de comprobar las limitaciones. Como la cadena puede hacer IEnumerable<>, el compilador lo compara con ese método de clase hijo. El compilador funciona correctamente como se describe en la especificación C#.

El orden de resolución de método que desee puede forzarse implementando DoStuff como extension method. Los métodos de extensión se comprueban después métodos de la clase base, por lo que no van a tratar de igualar string contra DoStuff 's IEnumerable<Tother> hasta después de que se ha tratado de compararlo con DoStuff<T>.

El siguiente código muestra el orden de resolución de método, la covarianza y la herencia deseados. Copie/pegue en un nuevo proyecto.

Este inconveniente mayor que se me ocurre es que hasta el momento no se puede utilizar en los métodos base primordiales, pero creo que hay formas de evitar que (pregunte si está interesado).

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(); 
     } 
    } 
} 

Aquí está la salida:

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

hay algún problema con esta solución?

Answer 6

No estoy muy claro en lo que estamos tratando de lograr, lo que te impide simplemente usando dos métodos, DoStuff(T item) and DoStuff(IEnumerable<T> collection)?