Warum muss ich in nicht verwendeten Konstruktoren auf Typen verweisen?

Question

Lassen Sie uns sagen, dass ich eine Klasse (ClassA) enthält, ein Verfahren, das den Konstruktor einer anderen Klasse aufruft, wie folgt aus:

public class ClassA 
{ 
    public void CallClassBConstructor() 
    { 
     using(ClassB myB = new ClassB()) {...} 
    } 
} 

Die Klasse ClassB wie folgt aussieht:

public class ClassB : IDisposable 
{ 
    public ClassB(){} 
    public ClassB(string myString){} 
    public ClassB(ClassC myC){} 
    public void Dispose() {...} 
} 

... und ClassC ist noch einfacher:

public class ClassC{} 

Wenn ich diese Klassen in ihren eigenen Arsch embly und kompilieren Sie die ganze Lösung Ich bekomme keine Fehler. Aber wenn ich die Anweisung using mit diesem ersetzen:

using(ClassB myB = new ClassB("mystring")){...} 

ich einen Kompilierungsfehler fragen mich einen Verweis auf [mynamespace].ClassC in ClassA hinzuzufügen. Da ich überhaupt nicht ClassB(ClassC myC) anrufe, macht das für mich keinen Sinn - warum muss ich die Typen anderer Konstruktoren einbeziehen, egal ob ich sie verwende oder nicht? Was wäre, wenn ClassC in einer lizenzierten oder schwer zu erwerbenden Baugruppe enthalten wäre? Ist das ein Beispiel für schlechtes Design, das Entwickler vermeiden sollten, oder fehlt mir hier etwas?

Answer 1

Es hat mit der Methode Überladung Auflösung zu tun, wenn der ClassB Konstruktor aufrufen.

Wenn Sie den Konstruktor ohne Parameter aufrufen, gibt es keine Konflikte. Es gibt nur einen Kandidaten, also ist es gewählt. Es ist in diesem Fall nicht notwendig, ClassA auf ClassC zu verweisen.

Wenn Sie jedoch den Konstruktor mit einem Parameter aufrufen, dann sind am Anfang beide Einzelparameterkonstruktoren Kandidaten. Um diesen Aufruf aufzulösen, muss der Compiler über ClassC wissen. Soweit Sie wissen, könnte ClassC beispielsweise einen impliziten Konvertierungsoperator enthalten.

(Natürlich wissen wir, dass in diesem speziellen Beispiel solch ein impliziter Konvertierungsoperator sowieso nicht ausgelöst würde, weil es eine perfekte Übereinstimmung gibt, die eine Zeichenfolge annimmt - aber die Methodenüberladungsauflösungsregeln sind so definiert, dass sie sehr gut sind Stellen Sie sich vor, dass es so entworfen wurde, dass das Hinzufügen einer Referenz dazu führen kann, dass Ihr Code plötzlich eine andere Konstruktorüberladung aufruft.)

Answer 2

Um die Überladungen des Konstruktors aufzulösen, muss der Compiler die beteiligten Typen kennen. I.e. es muss ClassC wissen, um die richtige Überladung des Konstruktors für ClassB auszuwählen.

Answer 3

Es ist, weil ClassC, die Sie in einer separaten Assembly platziert haben, Teil der öffentlichen Schnittstelle von ClassB ist, da es ein Parameter von einem der Konstruktoren ist. Sie müssen auf die enthaltene Assembly dieses Typs verweisen, da der Compiler ansonsten keine Informationen dazu hat, wie die Typinformationen aufgelöst werden. In diesem speziellen Fall muss der Compiler alle Parametertypen von allen Überladungen des Konstruktors auflösen, so dass er den richtigen auswählen kann, aber dies ist kein Elementüberlastungsproblem per se. Dies geschieht immer dann, wenn der Compiler Typinformationen auflösen muss. Dies kann auch bei Rückgabetypen vorkommen.