Injeção de dependência versus métodos estáticos

Hoje tive uma discussão interessante com outro desenvolvedor sobre como abordar uma classe com um método que aceita uma string e gera uma string.

Imagine algo como o seguinte, que é completamente composto com o propósito de exemplo

public string GetStringPart(string input)
{ 
   //Some input validation which is removed for clarity

   if(input.Length > 5)
        return input.Substring(0,1);

   if(input.Substring(0,1) == "B")
        return input.Substring(0,3);

   return string.empty;
}

Uma função que possui alguma lógica baseada em sua entrada de string é adicionada a um projeto usando DI e tem um Contêiner DI instalado. Você adicionaria essa nova classe com uma interface e a injetaria onde necessário, ou a tornaria uma classe estática? Quais são os prós e os contras de cada um? Por que você (ou não) deseja fazer disso algo usado com injeção de construtor, e não apenas acessado quando necessário em qualquer lugar.

Não há razão para que isso precise ser injetado. Esta é apenas uma função, não possui dependências, então chame-a. Pode até ser estático, se você quiser que pareça puro. Pode-se escrever testes de unidade contra isso sem dificuldade. Se for usado em outras classes, os testes de unidade ainda poderão ser gravados.

Não há necessidade de abstrair funções sem dependências, é um exagero.

Se isso se tornar mais complexo, talvez seja necessário transmitir uma interface para um construtor ou método. Mas eu não seguiria esse caminho a menos que tivesse GetStringPartlógica complexa com base na localização etc.

Aqui está o porquê

class DOSClient {
    OrderParser orderParser;
    string orderCode;

    DOSClient(OrderParser orderParser, string ordercode) { 
        this.orderParser = orderParser; 
        this.ordercode = ordercode;
    }
    void DisplayOrderCode() {
        Console.Write( "Prefix: " + orderParser.GetStringPart(ordercode) ); 
        ...
    }
}

class GUIClient {
    OrderParser orderParser;
    string orderCode;
    GUI gui;

    GUIClient(OrderParser orderParser, string ordercode, GUI gui) { 
        this.orderParser = orderParser; 
        this.ordercode = ordercode;
        this.gui = gui;
    }

    void DisplayOrderCode() {
        gui.Prefix( orderParser.GetStringPart(ordercode) ); 
        ...
    }
}

class OrderParserUS : IOrderParser {

    public string GetStringPart(string input)
    { 
        //Some input validation which is removed for clarity

        if(input.Length > 5)
            return input.Substring(0,1);

        if(input.Substring(0,1) == "B")
            return input.Substring(0,3);

        return string.empty;
    }
}

class OrderParserEU : IOrderParser {

    public string GetStringPart(string input)
    { 
        //Some input validation which is removed for clarity

        if(input.Length > 6)
            return input.Substring(0,1);

        if(input.Substring(0,1) == "#")
            return input.Substring(0,3);

        return string.empty;
    }
}

Se você tivesse adotado um método estático, não haveria maneira de alterar o comportamento GetStringPartsem destruir o antigo comportamento ou poluí-lo com lógica condicional. É verdade que as estáticas são máscaras globais disfarçadas, mas o fato de desabilitarem o polimorfismo é minha principal reclamação sobre elas. Métodos estáticos não são de primeira classe em idiomas OOP. Ao dar ao método um objeto para morar, mesmo um sem estado, tornamos o método portátil. Seu comportamento pode ser transmitido como o valor de uma variável.

Aqui eu imaginei um sistema que precisa se comportar de maneira um pouco diferente quando implantado na Europa e depois nos EUA. Em vez de forçar um sistema a conter o código necessário apenas pelo outro, podemos alterar o comportamento controlando qual objeto de análise de ordem é injetado nos clientes. Isso nos permite conter a propagação dos detalhes da região. Também facilita a adição do OrderParserCanada sem a necessidade de tocar nos analisadores existentes.

Se isso não significa nada para você, então realmente não há um bom argumento para isso.

BTW, GetStringPart é um nome terrível.