C#: pasar el método nulo a sobrecargado, ¿qué método se llama?

Question

Decir que tengo dos versiones sobrecargadas de un método de C#:

void Method(TypeA a) { } 
void Method(TypeB b) { } 

que llamo el método con:

Method(null); 

Qué sobrecarga del método se llama? ¿Qué puedo hacer para garantizar que se llame a una sobrecarga en particular?

Answer 1

Depende de TypeA y TypeB.

• Si exactamente una de ellas es aplicable (por ejemplo, no hay conversión de null a TypeB porque es un tipo de valor, pero TypeA es un tipo de referencia) y luego se hizo la llamada a la aplicable.
• De lo contrario, depende de la relación entre TypeA y TypeB.
  • Si hay una conversión implícita TypeA-TypeB pero no la conversión implícita TypeB-TypeA entonces se usará la sobrecarga usando TypeA.
  • Si hay una conversión implícita TypeB-TypeA pero no la conversión implícita TypeA-TypeB entonces se usará la sobrecarga usando TypeB.
  • De lo contrario, la llamada es ambigua y no podrá compilarse.

Véase la sección 7.4.3.4 de la especificación C# 3.0 para las modalidades.

Aquí hay un ejemplo de que no es ambiguo. Aquí TypeB deriva de TypeA, lo que significa que hay una conversión implícita de TypeB a TypeA, pero no al revés. Así, la sobrecarga de uso de TypeB se utiliza:

using System; 

class TypeA {} 
class TypeB : TypeA {} 

class Program 
{ 
    static void Foo(TypeA x) 
    { 
     Console.WriteLine("Foo(TypeA)"); 
    } 

    static void Foo(TypeB x) 
    { 
     Console.WriteLine("Foo(TypeB)"); 
    } 

    static void Main() 
    { 
     Foo(null); // Prints Foo(TypeB) 
    } 
} 

En general, incluso en la cara de una llamada de otra manera ambigua, para asegurarse de que se utiliza una sobrecarga en particular, simplemente fundido:

Foo((TypeA) null); 

o

Foo((TypeB) null); 

Tenga en cuenta que si se trata de la herencia en las clases que declaran (es decir una clase está sobrecargando un método declarado por su clase base) que está en un todo otro problema, y ​​usted ne ed para lanzar el objetivo del método en lugar del argumento.

Answer 2

ambigous call. (error de tiempo de compilación).

Answer 3

Jon Skeet ha dado una respuesta completa, pero desde el punto de vista del diseño no debe depender de los casos de esquina de la especificación del compilador. Si nada más, si tiene que buscar lo que hace antes de escribirlo, la siguiente persona que intente leerlo tampoco sabrá qué es lo que hace. No es mantenible.

Las sobrecargas están ahí por conveniencia, y dos sobrecargas diferentes con el mismo nombre deberían hacer lo mismo. Si los dos métodos hacen cosas diferentes, cambie el nombre de uno o ambos.

Es más habitual que un método sobrecargado tenga variantes con números variables de parámetros, y para la sobrecarga con menos parámetros para proporcionar valores predeterminados razonables.

p. Ej. string ToString(string format, System.IFormatProvider provider) tiene la mayoría de los parámetros,
string ToString(System.IFormatProvider provider) suministra un formato predeterminado y
string ToString() suministra un formato predeterminado y el proveedor,

Answer 4

Una solución sencilla es crear otro método con la firma de:

void Method() { } 

o mejor para actualizar la firma en uno de los métodos a ser:

void Method(TypeB b = null) { } 

y luego llamar i t como tan:

Method(); 

En tiempo de compilación el valor null tiene tipo por lo que el compilador no puede hacerlo coincidir con una de las firmas de métodos. En el tiempo de ejecución, cualquier variable que pueda resolverse en null seguirá escribiéndose y por lo tanto no causará ningún problema.

Answer 5

Jon Skeet ya respondió qué sobrecarga se elige de manera predeterminada, pero si desea asegurarse de que se llame a una sobrecarga en particular, a menudo es mejor usar parámetros con nombre que el molde.

Si usted tiene:

void Method(TypeA a) { } 
void Method(TypeB b) { } 

se le puede llamar Method(a: null); o Method(b: null);