Hierarquias de classes seladas em C #

Uma postagem minha recente no Stackoverflow recebeu muita atenção da comunidade. Perguntei como implementar em C # algo que aprendi no Scala .

Por que hierarquias de classes seladas?

Esse padrão se torna útil quando você está projetando uma biblioteca para uso de terceiros. Você deseja codificar um padrão de estratégia em que o número de opções seja limitado. Certamente, você tem enums em C #, mas enums não podem conter código

public interface IService
 {
     int DoSomething();
 }

 public abstract class ServiceProvider
 {
     public abstract IService GetService();
 }

 public class ServiceConsumer
 {
     public int Consume(ServiceProviderserviceFactory)
     {
         return serviceFactory.GetService().DoSomething();
     }
 }

Por que você faria ServiceProvider uma classe abstrata? O ponto crucial aqui é que você deseja disponibilizar apenas um número limitado de Provedores de Serviços. Se você fizer dele uma interface, todos podem implementá-lo

Existem duas abordagens que você pode usar:

• Torne o construtor da classe abstrata privado e implemente os provedores como classes aninhadas
• Torne o construtor da classe abstrata interno e implemente os provedores no mesmo assembly

Por exemplo, eu realmente gosto do seguinte:

public abstract class ServiceProvider
   {
       public abstract IService GetService();

       private ServiceProvider()
       {
       }

       public class CreateNewServiceProvider:ServiceProvider{
           public override IService GetService()
           {
               throw new NotImplementedException();
           }
       }

   }