(Der Versuch, einen Titel zu finden, der ein Problem zusammenfasst, kann eine sehr entmutigende Aufgabe sein!)

Ich habe die folgenden Klassen mit einigen überladenen Methoden, die einen Fehler beim Aufruf des Mehrdeutigkeits-Compilers verursachen:

public class MyClass
{
    public static void OverloadedMethod(MyClass l) { }
    public static void OverloadedMethod(MyCastableClass l) { }

    //Try commenting this out separately from the next implicit operator. 
    //Comment out the resulting offending casts in Test() as well.
    public static implicit operator MyCastableClass(MyClass l)
    {
        return new MyCastableClass();
    }

    //Try commenting this out separately from the previous implicit operator.
    //Comment out the resulting offending casts in Test() as well.
    public static implicit operator MyClass(MyCastableClass l)
    {
        return new MyClass();
    }

    static void Test()
    {
        MyDerivedClass derived = new MyDerivedClass();
        MyClass class1 = new MyClass();
        MyClass class2 = new MyDerivedClass();
        MyClass class3 = new MyCastableClass();
        MyCastableClass castableClass1 = new MyCastableClass();
        MyCastableClass castableClass2 = new MyClass();
        MyCastableClass castableClass3 = new MyDerivedClass();

        OverloadedMethod(derived); //Ambiguous call between OverloadedMethod(MyClass l) and OverloadedMethod(MyCastableClass l)
        OverloadedMethod(class1);
        OverloadedMethod(class2);
        OverloadedMethod(class3);
        OverloadedMethod(castableClass1);
        OverloadedMethod(castableClass2);
        OverloadedMethod(castableClass3);

    }

public class MyDerivedClass : MyClass {  }

public class MyCastableClass { }

Es gibt zwei sehr interessante Dinge zu beachten:

Kommentieren Sie eine der impliziten Operatormethoden aus, um die Mehrdeutigkeit zu beseitigen.enn Sie versuchen, die erste Methodenüberladung in VS umzubenennen, werden die ersten vier Aufrufe in der Test () - Methode umbenann

Dies wirft natürlich zwei Fragen auf:

Was ist die Logik hinter dem Compilerfehler (d. H. Wie ist der Compiler zu einer Mehrdeutigkeit gekommen)?Ist mit diesem Design etwas nicht in Ordnung? Intuitiv sollte es keine Mehrdeutigkeit geben und der anstößige Aufruf sollte in der ersten Methodenüberladung OverloadedMethod(MyClass l, MyClass r)) wieMyDerivedClass ist enger verwandt mitMyClass eher als die castable aber sonst irrelevantMyCastableClass. Darüber hinaus scheint VS Refactoring dieser Intuition zuzustimmen.

BEARBEITEN Nachdem ich mit dem VS-Refactoring herumgespielt hatte, stellte ich fest, dass VS den anstößigen Methodenaufruf mit der ersten Überladung, die im Code definiert ist, übereinstimmt. Wenn wir also die beiden Überladungen vertauschen, stimmt VS mit dem anstößigen Aufruf mit dem @ übereiMyCastableClass Parameter. Die Fragen sind jedoch noch gültig.