C# - Design Patterns - Strategy

Olá! Seguindo a proposta de padrões de projeto com C#, falaremos hoje sobre o padrão comportamental Strategy. Para ver outros padrões que já visitamos por aqui consulte esse link. Esse tema foi tratado de forma brilhante aqui.

Introdução

É muito comum no dia dia nos depararmos com necessidades que executam ações de formas diferentes, ou seja, apesar do trabalho ser o mesmo a forma de execução é distinta, exemplos clássicos são a cobrança de impostos (ICMS e ISS são impostos porém cada um tem seu próprio cálculo), cálculos de descontos entre outros. 

Nos exemplos citados anteriormente o que temos é uma mesma tarefa que, em determinado fluxo da aplicação deverá ter um comportamento com um resultado e em outro fluxo teremos comportamentos e resultados diferentes.

Uma situação muito comum é simplesmente separar o fluxo em "ifs" e em cada bloco codificar o que precisamos, no exemplo dos impostos bastaria um: 

        
            if (imposto = ICSMS) { tratamento ICMS ... } else { tratamento ISS ... }
        
    

Num primeiro momento essa abordagem parece bem plausível, afinal temos apenas dois impostos, mas se pensarmos que a quantidade de impostos pode aumentar, ou pior, que poderemos usar esses mesmos cálculos em diversas partes do código acabaremos nos deparando com métodos excessivamente grandes, com mais de um propósito, código duplicado e por ai vai.

Strategy

Para nos ajudar com situações como as descritas anteriormente podemos usar o Strategy, com ele podemos ter variações de um mesmo algoritmo e usar cada uma dessas variações em tempo de execução conforme a necessidade.

Esse padrão nos permite isolar as características de cada implementação, o que simplifica a manutenção e isola o código, o que nos permite criar novas estratégias sem medo de quebrar outras que já estão em funcionamento.

Para usar o Strategy precisaremos basicamente de:

• Uma interface que determine o que todas as estratégias deverão implementar/expor, geralmente um método de execução da tarefa;
• Implementações das estratégias, com base na interface definida;
• Uma classe de contexto, que conhece apenas a interface da estratégia, o contexto recebe a estratégia a ser executada sem saber o que ela faz, a única preocupação do contexto é receber a estratégia e chamar seu método de execução (conhecido devido a interface);
• Uma classe que define a estratégia a ser usada que é passada para o contexto executar;

Exemplo

Neste exemplo, temos três classes: ICMS e ISS implementam a interface IImpostoStrategy e tem o método CalcularImposto que é responsável pela execução do cálculo. A classe CalculadoraDeImpostos tem uma propriedade privada _estrategia que é do tipo IImpostoStrategy e no construtor é passado uma instância do tipo IImpostoStrategy. A classe CalculadoraDeImpostos tem um método CalcularImposto que retorna o valor calculado da estratégia atual. O método MudarStrategy é usado para trocar a estratégia atual de calculo de impostos:

        
            interface IImpostoStrategy
            {
                double CalcularImposto(double valor);
            }
        
            class ICMS : IImpostoStrategy
            {
                public double CalcularImposto(double valor)
                {
                    return valor * 0.2;
                }
            }
        
            class ISS : IImpostoStrategy
            {
                public double CalcularImposto(double valor)
                {
                    return valor * 0.1;
                }
            }
        
            class CalculadoraDeImpostos
            {
                private IImpostoStrategy _estrategia;
        
                public CalculadoraDeImpostos(IImpostoStrategy estrategia)
                {
                    _estrategia = estrategia;
                }
        
                public void MudarStrategy(IImpostoStrategy estrategia)
                {
                    _estrategia = estrategia;
                }
        
                public double CalcularImposto(double valor)
                {
                    return _estrategia.CalcularImposto(valor);
                }
            }
        
            class Program
            {
                static void Main(string[] args)
                {
                    var calculadora = new CalculadoraDeImpostos(new ICMS());
                    var valor = 10000.0;
                    var imposto = calculadora.CalcularImposto(valor);
                    Console.WriteLine($"Valor: {valor}, Imposto: {imposto}");
        
                    calculadora.MudarStrategy(new ISS());
                    imposto = calculadora.CalcularImposto(valor);
                    Console.WriteLine($"Valor: {valor}, Imposto: {imposto}");
                }
            }
        
    

Conclusão

Hoje vimos uma forma bem simples de se pensar um problema (impostos) de maneira única usando uma o padrão "Strategy", de modo que todos os impostos são tratados de maneira uniforme respeitando as suas impementações que são distintas.

• Documentação do C#
• No Wikipédia
• Strategy