C# Design Pattern: Abstract Factory (Portugues)

O padrão Abstract Factory é útil quando você deseja criar famílias de objetos relacionados, sem especificar as classes concretas diretamente. Ele fornece uma interface para criar diferentes objetos de uma mesma família. Esse padrão é comum em situações onde você quer garantir que diferentes produtos funcionem bem juntos, como criar interfaces gráficas que dependem do sistema operacional ou criar diferentes tipos de veículos, cada um com peças específicas que precisam ser compatíveis entre si.

Exemplo de Código em C#:

// Produto abstrato 1
public abstract class Carro
{
    public abstract void ExibirDetalhes();
}

// Produto concreto 1A
public class Sedan : Carro
{
    public override void ExibirDetalhes()
    {
        Console.WriteLine("Carro Sedan");
    }
}

// Produto concreto 1B
public class SUV : Carro
{
    public override void ExibirDetalhes()
    {
        Console.WriteLine("Carro SUV");
    }
}

// Produto abstrato 2
public abstract class Motor
{
    public abstract void ExibirTipo();
}

// Produto concreto 2A
public class MotorCombustao : Motor
{
    public override void ExibirTipo()
    {
        Console.WriteLine("Motor a combustão");
    }
}

// Produto concreto 2B
public class MotorEletrico : Motor
{
    public override void ExibirTipo()
    {
        Console.WriteLine("Motor elétrico");
    }
}

// Fábrica abstrata
public abstract class VeiculoFactory
{
    public abstract Carro CriarCarro();
    public abstract Motor CriarMotor();
}

// Fábrica concreta 1
public class SedanCombustaoFactory : VeiculoFactory
{
    public override Carro CriarCarro()
    {
        return new Sedan();
    }

    public override Motor CriarMotor()
    {
        return new MotorCombustao();
    }
}

// Fábrica concreta 2
public class SUVEletricoFactory : VeiculoFactory
{
    public override Carro CriarCarro()
    {
        return new SUV();
    }

    public override Motor CriarMotor()
    {
        return new MotorEletrico();
    }
}

class Program
{
    static void Main(string[] args)
    {
        VeiculoFactory factory = new SedanCombustaoFactory();
        Carro carro = factory.CriarCarro();
        Motor motor = factory.CriarMotor();

        carro.ExibirDetalhes(); // Saída: Carro Sedan
        motor.ExibirTipo();     // Saída: Motor a combustão

        factory = new SUVEletricoFactory();
        carro = factory.CriarCarro();
        motor = factory.CriarMotor();

        carro.ExibirDetalhes(); // Saída: Carro SUV
        motor.ExibirTipo();     // Saída: Motor elétrico
    }
}

Explicação do Código:

Neste exemplo, a fábrica abstrata VeiculoFactory define dois métodos para criar objetos relacionados: um carro e um motor. Cada fábrica concreta (SedanCombustaoFactory e SUVEletricoFactory) cria uma combinação específica de carro e motor que são compatíveis entre si. No código principal, você pode alternar entre as fábricas para criar diferentes combinações de carros e motores, como um Sedan com motor a combustão ou um SUV com motor elétrico.

Conclusão:

O Abstract Factory é útil quando você quer criar famílias de objetos que funcionem juntos. Ele ajuda a manter a consistência entre os produtos criados, já que as fábricas concretas garantem que cada combinação de objetos seja compatível. Esse padrão é ideal para cenários onde diferentes configurações de objetos precisam ser criadas de forma modular, sem expor os detalhes de implementação.

Código fonte: GitHub