Estou começando a aplicar os princípios do SOLID e os considero um pouco contraditórios. Meu problema é o seguinte:

Meu entendimento do princípio da inversão de dependência é que as classes devem depender de abstrações. Na prática, isso significa que as classes devem ser derivadas de interfaces. Tudo bem até agora.

A seguir, meu entendimento do princípio de aberto / fechado é que, após um certo ponto de corte, você não deve alterar o conteúdo de uma classe, mas deve estender e substituir. Isso faz sentido até agora para mim.

Dado o exposto, eu terminaria com algo assim:

public interface IAbstraction
{
    string method1(int example);
}

public Class Abstraction : IAbstraction
{
   public virtual string method1(int example)
   {
       return example.toString();
   }
}

e, no momento T, o método1 agora precisa adicionar "ExtraInfo" ao seu valor retornado. Em vez de alterar a implementação atual, eu criaria uma nova classe que estendeAbstraction e faça o que eu precisava, da seguinte maneira.

public Class AbstractionV2 : Abstraction 
{
   public override string method1(int example)
   {
       return example.toString() + " ExtraInfo";
   }
}

E eu posso ver o motivo para fazer isso é que apenas o código que eu quero chamar esse método atualizado o chamará e o restante do código chamará o método antigo.

Tudo faz sentido para mim - e eu assumo que meu entendimento está correto?

No entanto, também estou usando injeção de dependência (injetor simples), portanto, minhas implementações nunca passam por uma classe concreta, mas pela configuração de DI, da seguinte maneira:

container.Register<IAbstraction, Abstraction>();

O problema aqui é que, sob essa configuração, eu posso atualizar minha configuração de DI para:

container.Regis,ter<IAbstraction, AbstractionV2>();

Nesse caso, todas as instâncias agora chamarão o novo método, o que significa que não consegui alterar o método original.

OU

Eu crio uma nova interfaceIAbstractionV2 e implemente a funcionalidade atualizada, o que significa duplicação da declaração da interface.

Não consigo ver nenhuma maneira de contornar isso - o que me leva a pensar se a injeção de dependência e o SOLID são compatíveis? Ou estou faltando alguma coisa aqui?