O que é injeção de dependência e por que ela importa?

Desvendando os conceitos fundamentais

• Dependência: é um objeto que uma classe precisa para funcionar.

• Acoplamento: refere-se ao nível de interdependência entre módulos de um sistema. Um acoplamento forte indica que as classes estão fortemente ligadas, dificultando alterações e testes.

• Inversão de controle (IoC): é um princípio onde o controle do fluxo do programa é invertido, ou seja, em vez de a própria classe gerenciar suas dependências, um contêiner externo faz isso. A DI é uma forma de implementar o IoC.

• Contêiner de injeção de dependência: é um framework que gerencia a criação e o ciclo de vida das dependências, injetando-as onde são necessárias.

Mãos à obra: injeção de dependência no .NET

1. Injeção via construtor

// Interface que define o contrato para o serviço de notificação
public interface INotificador
{
    void EnviarMensagem(string mensagem);
}

// Implementação da interface INotificador
public class EmailNotificador : INotificador
{
    public void EnviarMensagem(string mensagem)
    {
        // Lógica para enviar e-mail
    }
}

// Classe Pedido que depende de um serviço de notificação
public class Pedido
{
    private readonly INotificador _notificador;

    public Pedido(INotificador notificador)
    {
        _notificador = notificador;
    }

    public void Processar()
    {
        _notificador.EnviarMensagem("Pedido processado com sucesso.");
    }
}

2. Injeção de propriedade

// Definição da classe Pedido com injeção por propriedade
public class Pedido
{
    public INotificador Notificador { get; set; }

    public void Processar()
    {
        Notificador?.EnviarMensagem("Pedido processado com sucesso.");
    }
}

// Exemplo prático de utilização
var pedido = new Pedido();
pedido.Notificador = new EmailNotificador();
pedido.Processar();

3. Injeção de método

public class Pedido
{
    public void Processar(INotificador notificador)
    {
        notificador.EnviarMensagem("Pedido processado com sucesso.");
    }
}

Como escolher a técnica ideal para seu contexto?

• Injeção via construtor:
Recomendado para dependências obrigatórias. Garante que todos os objetos necessários sejam fornecidos já na criação da classe, tornando claro quais dependências a classe precisa para funcionar corretamente. É a técnica mais indicada na maioria dos casos.

• Injeção de propriedade:
Indicada especialmente para dependências opcionais. Se sua classe pode funcionar sem uma determinada dependência ou se essa dependência pode mudar dinamicamente em tempo de execução, essa pode ser a melhor opção.

• Injeção de método:
Ideal quando a dependência é utilizada apenas em métodos específicos, geralmente de forma pontual ou temporária. Evita que a dependência fique associada à classe por mais tempo que o necessário.

Se você tem uma classe Pedido que sempre precisa enviar notificações ao processar um pedido, a melhor escolha é a injeção via construtor. Já se precisar gerar notificações apenas ocasionalmente ou em situações específicas, use a injeção por método.

Como registrar dependências no contêiner do .NET

var builder = WebApplication.CreateBuilder(args);

// Registro de dependências
builder.Services.AddTransient<INotificador, EmailNotificador>();

var app = builder.Build();
app.Run();

• AddTransient: Uma nova instância da dependência (EmailNotificador) é criada sempre que solicitada. Indicado para serviços leves e sem estado específico.

• Outras opções comuns incluem:
• AddScoped: Uma instância por requisição. Ideal para aplicações web onde o contexto é mantido por requisição (ex.: conexões com bancos de dados).
• AddSingleton: Uma única instância durante toda a vida útil da aplicação. Indicado para serviços que armazenam estados compartilhados ou configurações globais.

Desta forma, o .NET gerencia automaticamente as dependências para você.

Cuidados ao utilizar a injeção de dependência

• Em sistemas muito pequenos ou simples, a DI pode introduzir complexidade desnecessária, aumentando a quantidade de código e dificultando o entendimento inicial.

• O uso abusivo pode levar à criação de classes com muitas dependências, gerando problemas como o anti-pattern conhecido como "constructor over-injection" (excesso de parâmetros no construtor).

• Avalie cuidadosamente se cada dependência realmente é necessária ou se pode ser simplificada.

Sempre busque equilíbrio: use DI para facilitar, não complicar, seu código

Conclusão

Lembre-se: o futuro da programação pertence a quem se mantém atualizado e pratica constantemente. Bora codar?