regole di conversione per operatori di conversione di overload

Question

dato il codice seguente:

using System; 

namespace Test721 
{ 
    class MainClass 
    { 
     public static void Main(string[] args) 
     { 
      Console.WriteLine(new A()); //prints 666 
      Console.WriteLine(new B()); //prints 666 
      Console.ReadLine(); 
     } 
    } 

    public class A 
    { 
     public static implicit operator int(A a) 
     { 
      return 666; 
     } 
    } 

    public class B : A 
    { 
     public static implicit operator double(B b) 
     { 
      return 667; 
     } 
    } 
} 

i risultati sono come nei commenti - entrambe le linee stampate 666.

mi aspetto Console.WriteLine(new B()); di scrivere 667, mentre non v'è a double sovraccarico di Console.WriteLine.

Perché sta succedendo?

Answer 1

Questo argomento è trattato nella sezione 7.4.3.4 del 3.5 C# specifica della lingua Questa sezione tratta della risoluzione di sovraccarico e di come vengono considerate le conversioni in questo processo. La riga applicabile è

Se esiste una conversione implicita da T1 a T2 e non esiste alcuna conversione implicita da T2 a T1, C1 è la conversione migliore.

In questo caso esiste una conversione implicita da B sia int (T1) e double (T2). Esiste una conversione implicita da int a double ma non viceversa. Quindi la conversione implicita da B a int è considerata migliore e vince.

Answer 2

Dal momento che non si è specificato che cosa il cast del valore al compilatore sta facendo

Console.WriteLine((int)(new B())); 

si dovrebbe usare in seguito, invece

Console.WriteLine((double)(new B()));