Por que padrões de design importam?

• Organização e reutilização: permitem criar soluções modulares e reutilizáveis.

• Facilidade de manutenção: tornam o código mais limpo e fácil de modificar.

• Escalabilidade: facilitam o crescimento de aplicações complexas.

No contexto do C#, esses padrões são fundamentais para lidar com a criação de objetos, a comunicação entre componentes e a atribuição clara de responsabilidades.

1. Padrão Singleton: o poder do um

• Evita conflitos no acesso a recursos compartilhados, como logs ou configurações globais.

• Centraliza o controle de algo que precisa ser único.

public class GerenciadorEventos
{
    private static readonly GerenciadorEventos _instancia = new GerenciadorEventos();

    private GerenciadorEventos() { }

    public static GerenciadorEventos Instancia
    {
        get { return _instancia; }
    }

    public void ExibirMensagem()
    {
        Console.WriteLine("Gerenciando os eventos da Rocketseat!");
    }
}

• Controle de eventos globais.

• Sistemas de log centralizado, como o que Diego utilizaria para monitorar as trilhas de aprendizado.

public class GerenciadorEventos
{
    private static GerenciadorEventos _instancia;
    private static readonly object _lock = new object();

    private GerenciadorEventos() { }

    public static GerenciadorEventos Instancia
    {
        get
        {
            lock (_lock)
            {
                if (_instancia == null)
                {
                    _instancia = new GerenciadorEventos();
                }
                return _instancia;
            }
        }
    }

    public void ExibirMensagem()
    {
        Console.WriteLine("Gerenciando os eventos da Rocketseat com segurança em threads!");
    }
}

2. Padrão Factory: sua fábrica de objetos

• Facilita a criação de objetos complexos, como desafios de diferentes níveis de dificuldade.

• Oferece flexibilidade para mudar a lógica de criação sem afetar outras partes do código.

public interface IDesafio
{
    void Exibir();
}

public class DesafioFacil : IDesafio
{
    public void Exibir() => Console.WriteLine("Desafio fácil: Hello World!");
}

public class DesafioIntermediario : IDesafio
{
    public void Exibir() => Console.WriteLine("Desafio intermediário: Criar uma API simples.");
}

public class FabricaDesafios
{
    public static IDesafio CriarDesafio(string tipo)
    {
        return tipo switch
        {
            "Fácil" => new DesafioFacil(),
            "Intermediário" => new DesafioIntermediario(),
            _ => throw new ArgumentException("Tipo de desafio desconhecido")
        };
    }
}

• Criação dinâmica de desafios em trilhas de aprendizado.

• Ferramentas para personalizar cursos ou formações.

3. Padrão Observer: mantendo todos informados

• Facilita a implementação de sistemas de notificações, como alertas para alunos.

• Reduz o acoplamento entre componentes.

public class Trilha
{
    public delegate void Notificacao(string mensagem);
    public event Notificacao OnNovaTrilha;

    public void LançarNova(string nome)
    {
        OnNovaTrilha?.Invoke($"Nova trilha lançada: {nome}");
    }
}

public class Aluno
{
    public void ReceberNotificacao(string mensagem)
    {
        Console.WriteLine($"Notificação recebida: {mensagem}");
    }
}

• Sistemas de notificações para novos cursos ou desafios.

• Atualizações em tempo real na plataforma.

4. Padrão Decorator: adicionando funcionalidades dinamicamente

• Adiciona flexibilidade para incluir funcionalidades incrementais.

• Evita criar subclasses para cada combinação de funcionalidades.

public interface ITrilha
{
    string Descricao();
}

public class TrilhaBasica : ITrilha
{
    public string Descricao() => "Trilha básica de programação.";
}

public class TrilhaAvancada : ITrilha
{
    private readonly ITrilha _trilha;

    public TrilhaAvancada(ITrilha trilha)
    {
        _trilha = trilha;
    }

    public string Descricao() => _trilha.Descricao() + " Inclui projetos avançados.";
}

• Personalização de trilhas educacionais.

• Sistemas que permitem upgrades dinâmicos.

5. Padrão Strategy: mudando de estratégia com algoritmos

• Facilita a troca de algoritmos sem alterar o código principal.

• Promove código limpo e organizado.

public interface ICalculoDesempenho
{
    double Calcular(int pontos, int total);
}

public class CalculoSimples : ICalculoDesempenho
{
    public double Calcular(int pontos, int total) => (double)pontos / total * 100;
}

public class CalculoAvancado : ICalculoDesempenho
{
    public double Calcular(int pontos, int total) => ((double)pontos / total * 100) + 5;
}

public class Avaliacao
{
    private ICalculoDesempenho _calculo;

    public void DefinirCalculo(ICalculoDesempenho calculo)
    {
        _calculo = calculo;
    }

    public double Avaliar(int pontos, int total)
    {
        return _calculo.Calcular(pontos, total);
    }
}

• Sistemas de avaliação de desempenho.

• Ferramentas de análise de progresso.

Conclusão: aprenda mais com a formação C# da Rocketseat