C# Genérico método sobrecargado despachar ambigua

Question

me acaba de golpear una situación en la que un despacho método era ambigua y se preguntó si alguien podría explicar en qué se basa el compilador (.NET 4.0.30319) elige lo sobrecargue llamar

interface IfaceA 
{ 

} 

interface IfaceB<T> 
{ 
    void Add(IfaceA a); 
    T Add(T t); 
} 

class ConcreteA : IfaceA 
{ 

} 

class abstract BaseClassB<T> : IfaceB<T> 
{ 
    public virtual T Add(T t) { ... } 
    public virtual void Add(IfaceA a) { ... } 
} 

class ConcreteB : BaseClassB<IfaceA> 
{ 
    // does not override one of the relevant methods 
} 

void code() 
{ 
    var concreteB = new ConcreteB(); 

    // it will call void Add(IfaceA a) 
    concreteB.Add(new ConcreteA()); 
} 

En cualquier caso, ¿por qué el compilador no me advierte o incluso por qué compila? Muchas gracias por cualquier respuesta.

Answer 1

Sigue las normas de la sección 7.5.3.2 de la C# 4 specification ("miembro de una mejor función").

Primero (bueno, después de ver que ambos métodos son aplicable) necesitamos verificar las conversiones de tipos de argumentos a tipos de parámetros. En este caso, es razonablemente simple porque solo hay un argumento. Ni la conversión del tipo de argumento al tipo de parámetro es "mejor" porque ambos se están convirtiendo de ConcreteA a IfaceA. Por lo tanto, se mueve a la siguiente serie de criterios, incluyendo lo siguiente:

De lo contrario, si MP tiene tipos de parámetros más específicos de MQ, a continuación, MP es mejor que MQ. Deje {R1, R2, ..., RN} y {S1, S2, ..., SN} representar los tipos de parámetros sin expandir y de MP y MQ. tipos de parámetros de MP son más específicos que de MQ si, para cada parámetro, RX no es menos específica que la SX, y, por lo menos un parámetro, RX es más específica de SX: específico de SX:

• Un parámetro de tipo es menos específico que un parámetro que no es de tipo.
• ...

Así que, aunque la conversión es igual de bueno, la sobrecarga de uso de IfaceA directamente (en lugar de a través de delegados) se considera "mejor" porque un parámetro de tipo IfaceA es más específica que un parámetro de tipo T.

No hay forma de que el compilador advierta sobre este comportamiento, es solo una resolución de sobrecarga normal.

Answer 2

Porque el compilador elige primero lo más específico.

¿Qué pasa si se llama así:

void code() 
{ 
    var concreteB = new ConcreteB(); 

    IfaceA x = concreteB.Add(new ConcreteA()); 
} 

Answer 3

Esto me recuerda un poco de la "inferencia de tipos a-go-go" en Jon Skeet's BrainTeaser. Si no desea confiar en el compilador, es posible que desee forzar su elección llamando Add<ConcreteA>(new ConcreteA())