Die nützlichste Anwendung, die ich gefunden habe, ist die Implementierung von Fabriken. In vielen Fällen ist es nützlich, Klassen zu erstellen, die innerhalb der Factory veränderbar, aber für externe Klassen unveränderlich sind. Dies kann einfach in Java mithilfe innerer Klassen implementiert werden, indem die Felder und ihre Setter privat gemacht werden und die Getter nur als öffentliche Mitglieder verfügbar gemacht werden. In C # musste ich jedoch explizite Schnittstellen verwenden, um dasselbe zu erreichen. Ich werde weiter erklären:
In Java können die innere Klasse UND die äußere Klasse auf private Mitglieder zugreifen, was absolut sinnvoll ist, da die Klassen sehr eng miteinander verbunden sind. Sie befinden sich in derselben Codedatei und werden wahrscheinlich von demselben Entwickler entwickelt. Dies bedeutet, dass die Fabrik weiterhin auf private Felder und Methoden in der inneren Klasse zugreifen kann, um deren Werte zu ändern. Externe Klassen können jedoch nur über ihre öffentlichen Getter auf diese Felder zugreifen.
In C # können äußere Klassen jedoch nicht auf private Mitglieder innerer Klassen zugreifen, sodass das Konzept nicht direkt anwendbar ist. Ich habe eine explizite Schnittstelle als Problemumgehung verwendet, indem ich eine private Schnittstelle in der äußeren Klasse definiert und explizit in der inneren Klasse implementiert habe. Auf diese Weise kann nur die äußere Klasse auf die Methoden in dieser Schnittstelle zugreifen, wie dies in Java der Fall ist (es müssen jedoch Methoden sein, keine Felder).
Beispiel:
public class Factory
{
// factory method to create a hard-coded Mazda Tribute car.
public static Car CreateCar()
{
Car car = new Car();
// the Factory class can modify the model because it has access to
// the private ICarSetters interface
((ICarSetters)car).model = "Mazda Tribute";
return car;
}
// define a private interface containing the setters.
private interface ICarSetters
{
// define the setter in the private interface
string model { set; }
}
// This is the inner class. It has a member "model" that should not be modified
// but clients, but should be modified by the factory.
public class Car: ICarSetters
{
// explicitly implement the setter
string ICarSetters.model { set; }
// create a public getter
public string model { get; }
}
}
class Client
{
public Client()
{
Factory.Car car = Factory.CreateCar();
// can only read model because only the getter is public
// and ICarSetters is private to Factory
string model = car.model;
}
}
Dafür würde ich explizite Schnittstellen verwenden.