Wie kann ich Mitglieder der internen Schnittstellen implementieren
Frage
Ich habe Refactoring die Codebasis des Projektes, das ich aktuell bin so dass Klassen / Schnittstellen, die über die Grenzen der Anordnung nicht verwendbar sind, soll als internes deklariert werden (und nicht öffentlich). Aber ich habe ein Problem mit dem folgenden Code ausführen:
internal interface IFirstInterface
{
...
}
internal interface ISecondInterface
{
IFirstInterface First{ get; }
...
}
public class Implementer : ISecondInterface
{
public IFirstInterface First {get; private set;}
...
}
Meine Fragen:
-
Warum haben Sie Mitglieder der internen Schnittstellen werden öffentlich umgesetzt? Wenn Sie die Schnittstelle auf einer internen Klasse implementieren, sollten nicht die implementierten Mitglieder intern sein? Das ist kein großes Problem, da die Schnittstelle Mitglieder nicht öffentlich ohnehin zugänglich sein werden, da die Klasse ist intern. Es scheint nur unlogisch.
-
Das Hauptproblem ist mit dem oben beschriebenen Szenario, da ich einen öffentlichen Getter für IFirstInterface nicht haben kann, da sie angeblich eine interne Schnittstelle ist das heißt ich bekomme die folgende Fehlermeldung vom Compiler:
Uneinheitliche Zugänglichkeit: Eigentum Typ ‚IFirstInterface‘ kleiner zugänglich als Eigentum 'Implementer.First'
Gibt es eine Möglichkeit, um dieses?
Hinweis . Ich weiß, dass es wahrscheinlich wenig Wert in dieser Refactoring Übung ist, aber ich dachte, es ist ein guter Weg für mich sein würde tiefer die Auswirkungen des internen Modifikator zu verstehen
Lösung
Just zu beachten - der Code, den Sie tatsächlich zur Verfügung gestellt haben hat kompilieren, weil Implementer
ist eine interne Klasse. Das Problem kommt, wenn Implementer
öffentlich ist.
Die Art und Weise dieser Runde ist explizite Schnittstellenimplementierung zu verwenden:
public class Implementer : ISecondInferface
{
private IFirstInterface first;
IFirstInterface ISecondInterface.First { get { return first; } }
}
Sie können nicht die Setter haben dort, weil Sie die Schnittstelle explizit sind Implementierung, die nicht die Setter nicht definiert. Sie könnte tun dies als eine Alternative:
public class Implementer : ISecondInterface
{
internal IFirstInterface First { get; private set; }
IFirstInterface ISecondInterface.First { get { return First; } }
}
Es ist bedauerlich, dass interne Schnittstellen öffentliche Mitglieder haben - es verkompliziert Dinge wie diese. Es wäre seltsam, für eine öffentliche Schnittstelle ein internes Mitglied zu haben (was es zu intern wäre - die Implementierer oder declarer). Aber für die internen Schnittstellen macht es viel mehr Sinn
Andere Tipps
Warum Mitglieder der internen Schnittstellen haben öffentlich umgesetzt werden?
Wenn Sie eine Schnittstelle zu definieren, Sie definieren nicht Zugriffsebene für die Mitglieder, da alle Schnittstellenelemente public
sind. Auch wenn die Schnittstelle als solche internal
ist, werden die Mitglieder noch public
betrachtet. Wenn Sie eine implizite Umsetzung eines solchen Elements machen muss die Signatur übereinstimmen, so muss es public
werden.
Im Hinblick auf die Getter aussetzt, würde ich eine explizite Implementierung der Schnittstelle statt, und die Schaffung einer internal
Eigenschaft schlagen vor, um den Wert zu entlarven:
internal IFirstInterface First { get; private set; }
IFirstInterface ISecondInterface.First
{
get { return this.First; }
}
Ich weiß, dass dieser Beitrag ein paar Jahre alt, aber ich denke, es ist erwähnenswert, dass Sie eine interne Schnittstelle auf einer öffentlichen Klasse implementieren können, finden Sie unter den folgenden Links:
http://forums.create.msdn.com/forums/p/29808/ 167820.aspx
http://msdn.microsoft.com/en-us/ library / aa664591% 28VS.71% 29.aspx
Ein Beispiel aus dem ersten Link:
internal interface ISecretInterface
{
string Property1 { get; }
}
public class PublicClass : ISecretInterface
{
// class property
public string Property1
{
get { return "Foo"; }
}
// interface property
string ISecretInterface.Property1
{
get { return "Secret"; }
}
}