A aplicação mais útil que encontrei é na implementação de fábricas. Em muitos casos, é útil criar classes mutáveis dentro da fábrica, mas imutáveis para classes externas. Isso pode ser facilmente implementado em Java usando classes internas, tornando os campos e seus setters privados e apenas expondo os getters como membros públicos. No entanto, em C #, eu tive que usar interfaces explícitas para conseguir a mesma coisa. Vou explicar melhor:
Em Java, a classe interna AND e a classe externa podem acessar membros privados um do outro, o que faz total sentido, pois as classes estão intimamente relacionadas. Eles estão no mesmo arquivo de código e provavelmente são desenvolvidos pelo mesmo desenvolvedor. Isso significa que os campos e métodos privados da classe interna ainda podem ser acessados pela fábrica para modificar seus valores. Mas as classes externas não poderão acessar esses campos, exceto por meio de getters públicos.
No entanto, em C #, as classes externas não podem acessar membros particulares de classes internas, para que o conceito não seja diretamente aplicável. Eu usei uma interface explícita como solução alternativa, definindo uma interface privada na classe externa e implementando-a explicitamente na classe interna. Dessa forma, somente a classe externa pode acessar os métodos nessa interface da mesma maneira que é feita em Java (mas eles devem ser métodos, não campos).
Exemplo:
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;
}
}
É para isso que eu usaria interfaces explícitas.