C# Design Pattern: Interpreter (Portugues)

O padrão Interpreter é usado para interpretar ou avaliar expressões em uma linguagem simples. Ele define uma gramática para expressões e um mecanismo para interpretar essas expressões. É útil quando você precisa processar ou avaliar comandos ou regras repetidamente, como em calculadoras ou linguagens de script.

Exemplo de Código em C#:

// Interface para expressões
public interface IExpressao
{
    int Interpretar();
}

// Expressão para números
public class Numero : IExpressao
{
    private int _valor;

    public Numero(int valor)
    {
        _valor = valor;
    }

    public int Interpretar()
    {
        return _valor;
    }
}

// Expressão para adição
public class Adicao : IExpressao
{
    private IExpressao _esquerda;
    private IExpressao _direita;

    public Adicao(IExpressao esquerda, IExpressao direita)
    {
        _esquerda = esquerda;
        _direita = direita;
    }

    public int Interpretar()
    {
        return _esquerda.Interpretar() + _direita.Interpretar();
    }
}

// Expressão para subtração
public class Subtracao : IExpressao
{
    private IExpressao _esquerda;
    private IExpressao _direita;

    public Subtracao(IExpressao esquerda, IExpressao direita)
    {
        _esquerda = esquerda;
        _direita = direita;
    }

    public int Interpretar()
    {
        return _esquerda.Interpretar() - _direita.Interpretar();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Criar expressões: (10 + 5) - 3
        IExpressao expressao = new Subtracao(
            new Adicao(new Numero(10), new Numero(5)),
            new Numero(3)
        );

        // Interpretar e exibir o resultado
        int resultado = expressao.Interpretar();
        Console.WriteLine($"Resultado da expressão: {resultado}"); // Saída: Resultado da expressão: 12
    }
}

Explicação do Código:

Neste exemplo, temos uma interface IExpressao, que define o método Interpretar. As classes Numero, Adicao e Subtracao implementam essa interface para representar diferentes tipos de expressões. O código cria uma expressão que soma 10 e 5, depois subtrai 3, e então interpreta o resultado. O padrão Interpreter permite que você construa e avalie expressões de forma flexível.

Conclusão:

O padrão Interpreter é útil quando você precisa definir uma gramática e interpretar expressões repetidamente. Ele é aplicado em situações como calculadoras, processadores de linguagens de script ou sistemas que precisam avaliar regras ou comandos.

Código fonte: GitHub