Résolution de surcharge de la méthode comportement inattendu

Question

Je suis aux prises avec une résolution de surcharge de .net. J'ai écrit un petit échantillon de reproduire le problème:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var test = new OverloadTest(); 
     test.Execute(0); 
     test.Execute(1); 

     Console.ReadLine(); 
    } 
} 

public class OverloadTest 
{ 
    public void Execute(object value) 
    { 
     Console.WriteLine("object overload: {0}", value); 
    } 

    public void Execute(MyEnum value) 
    { 
     Console.WriteLine("enum overload: {0}", value); 
    } 
} 

public enum MyEnum 
{ 
    First = 1, Second = 2, Third = 3 
} 

imprimera:

enum overload: 0 
object overload: 1 

Fondamentalement, la surcharge appelée est différente en fonction de la valeur (0, 1) au lieu du type de données .

Quelqu'un pourrait-il expliquer?

Mise à jour

Je aurais dû signaler qu'il ya un comportement différent entre C# 2 et C# 3

Do((long)0) => object overload //C# 2 
Do((long)0) => enum overload //C# 3 

Answer 1

Oui - la constante 0 est implicitement convertibles à tout type enum. La constante 1 est seulement explicitement convertible au type enum. Les deux sont implicitement convertibles en object (via la boxe) mais la conversion en enum est préférable là où elle est disponible.

Notez que cela a rien à voir avec avec quelles valeurs l'enum définit. La conversion pour toute valeur non nulle est explicite si elle correspond à une valeur dans l'énumération ou non. C'est juste un cas particulier pour la valeur 0, ce qui rend un autre code plus simple (en particulier lorsqu'il s'agit de drapeaux). Je n'ai pas les spécifications pour trouver la référence, j'en ai peur.

Étrangeté supplémentaire: en raison d'un bogue dans le compilateur MS (ne jamais être corrigé - il y aurait une rétrocompatibilité), il s'agit en fait de various zero constants, et pas seulement d'un nombre entier. Donc, Execute(0d) et Execute(0m) vont convertir un double et un nombre décimal à l'enum aussi. Cela ne fonctionne pas pour chaque constante - cela dépend de la nature exacte du code source. Tout est très étrange - suivez le lien où Eric Lippert révèle tout ...

Answer 2

Un Enum est juste mis en correspondance avec un int (par défaut). 0 ne correspond pas à votre Enum donc la surcharge qui prend un objet est utilisée. 1 correspond à votre énumération, de sorte que la surcharge Enum est utilisée.

Vous pouvez le faire:

Execute((object) 1); 

à la sortie

surcharge d'objet: 1

Answer 3

Je suis d'accord avec la réponse de Jon Skeet - se référer à son poste (ci-dessus) le 11 janvier à 17h32. Pour développer plus loin, s'il vous plaît se référer à C# spécification langage - page: 110

6.1.3 conversions d'énumération implicite Une conversion d'énumération implicite permet la décimale entier littéral 0 à convertir à tout type ENUM et à tout type nullable dont le type sous-jacent est un type enum. Dans ce dernier cas, la conversion est évaluée en convertissant au type enum sous-jacent et en enveloppant le résultat (§4.1.10).

Encore il y a un problème:

ajoutant l'instruction:

test.Execute (-0,0); // surcharge d'objet: 0

tout en ajoutant ce qui suit:

test.Execute (0,0); // surcharge Enum: 0

Jacques Colmenero Enterprise Architect colmeneroj@videotron.ca