Factory Method: Flexibilidade na Criação de Objetos em C#

O Factory Method é um padrão de design criacional que resolve um problema🤝 GitHub Básico: Versionamento para Iniciantes!Descubra como o GitHub facilita colaboração, versionamento e organização de código com este tutorial prático e essencial para desenvolvedores iniciantes. comum: como criar objetos sem precisar conhecer detalhes específicos de suas classes concretas. Ele permite que uma classe delegue a criação de objetos para subclasses, tornando o código mais flexível e mantendo a abstração. Imagine uma fábrica em que cada linha de produção é capaz de produzir um tipo diferente de produto🔢 Operadores Aritméticos: Faça Cálculos como uma Calculadora Humana!Aprenda a dominar operadores aritméticos em C# com exemplos práticos, técnicas de cálculo e dicas para evitar erros e maximizar resultados., mas quem decide qual tipo será produzido é a própria fábrica, em vez de quem faz o pedido. É exatamente essa ideia que o Factory Method traz para nossos projetos🌐 LinkedIn para Devs .NET: Perfil que Atrai Recrutadores!Aprenda a otimizar seu perfil LinkedIn com dicas essenciais para devs .NET. Conquiste oportunidades e destaque suas habilidades! de software.

Tabela de Conteúdo

O que é Factory Method?🔗

O Factory Method é um padrão criacional que sugere a criação de um método (ou métodos🧠 Métodos em C#: Como Criar Funções que Não São Só Enfeites!Otimize seu código em C# com métodos inteligentes. Aprenda práticas de reutilização, sobrecarga e escopo para melhorar a clareza e a eficiência.) dedicados à instanciação de objetos de subclasses específicas. Em vez do seu código depender de uma classe concreta, ele chama o método🧠 Métodos em C#: Como Criar Funções que Não São Só Enfeites!Otimize seu código em C# com métodos inteligentes. Aprenda práticas de reutilização, sobrecarga e escopo para melhorar a clareza e a eficiência. de criação, que faz a escolha de qual tipo concreto será instanciado.

Evita acoplamento rígido: O cliente do objeto não precisa saber qual classe🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara. está sendo criada.
Melhora a extensibilidade: É fácil adicionar📦 List<T>: Dinamismo além dos Arrays!Descubra como utilizar List<T> em C# de forma eficiente. Aprenda a criar, manipular e otimizar listas para diferentes cenários com exemplos práticos. novos tipos de produtos sem modificar muito código existente.

Quando Usar e Benefícios🔗

Você pode aproveitar esse padrão em situações como:

1. Várias subclasses possíveis, mas📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. você não quer expor seus detalhes: Você pode ter diferentes classes concretas para um mesmo contrato (interface ou classe base🧬 Herança: Reutilize Código sem Copiar e Colar (como um Jedi)!Aprenda a utilizar herança em C# para criar hierarquias de classes, reaproveitar código e manter projetos organizados de forma simples e escalável.), mas não deseja que o cliente saiba qual delas será usada.

2. Processos de criação complexos: Se a criação dos objetos precisa de configuraçõesGerenciando Secrets e Configs em Docker SwarmAprenda a proteger credenciais, chaves e tokens com Docker Swarm. Gerencie Secrets e Configs de forma segura, garantindo integridade dos dados críticos. ou pré-processamentos, o Factory Method organiza essa lógica num ponto central.

3. Flexibilidade na hora de adicionar📦 List<T>: Dinamismo além dos Arrays!Descubra como utilizar List<T> em C# de forma eficiente. Aprenda a criar, manipular e otimizar listas para diferentes cenários com exemplos práticos. novos “produtos”: Cada tipo de produto herda a mesma interface/classe abstrata🧪 Classes Abstratas: Moldes para Criar Objetos Perfeitos!Aprenda a utilizar classes abstratas em C# através de exemplos práticos e desafios, garantindo código organizado e consistente em seus projetos., mas a decisão de qual instanciação usar vem do factory method.

Benefícios de usar Factory Method:

Centralização das instâncias: Permite padronizar como e onde🎲 Desafio: Analise Dados de Vendas com LINQ e Coleções!Aprenda a usar coleções e LINQ em C# para analisar vendas, filtrar dados e extrair insights estratégicos que otimizem decisões e impulsionem seu negócio. os objetos são criados.
Organização de código: Mantém o código de criação de objetos isolado, facilitando a manutenção.
Subclasses podem estender comportamentos: Cada fábrica concreta criará os objetos do jeito que for🔄 Loops em C#: Repita Tarefas sem Enlouquecer (Com for e while!)Descubra como automatizar repetições em C# utilizando loops for e while com exemplos práticos que evitam erros e otimizam seu código. Aprenda mais! necessário.

Exemplo Prático: Montadora de Veículos🔗

Vamos imaginar que temos uma montadora de veículos que pode produzir tanto carros quanto motos. Em vez de o código que solicita um veículo ter que saber como esses veículos são construídos, podemos criar uma classe🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara. Montadora (fábrica) que decide se instancia Carro ou Moto.

Fábricas	Produtos
`MontadoraCarros`	`Carro`
`MontadoraMotos`	`Moto`

No mundo real, a fábrica de carros sabe quais componentes são usados, qual a sequência de montagem etc. Já a fábrica de motos tem um processo diferente. Ainda assim, o “cliente” só precisa saber que quer um veículo, não como ele é feito.

Implementação em C#🔗

A base do Factory Method em C# envolve a definição de uma classe base🧬 Herança: Reutilize Código sem Copiar e Colar (como um Jedi)!Aprenda a utilizar herança em C# para criar hierarquias de classes, reaproveitar código e manter projetos organizados de forma simples e escalável. ou interface para o “produto” e outra para a “fábrica”. Cada fábrica concreta implementa seu próprio método para criar o produto desejado.

// Produto (interface ou classe abstrata)
public interface IVeiculo
{
    void Acelerar();
}
// Produtos concretos
public class Carro : IVeiculo
{
    public void Acelerar()
    {
        Console.WriteLine("Carro acelerando!");
    }
}
public class Moto : IVeiculo
{
    public void Acelerar()
    {
        Console.WriteLine("Moto acelerando!");
    }
}
// Fábrica (classe abstrata ou interface)
public abstract class Montadora
{
    // Método Fábrica
    public abstract IVeiculo CriarVeiculo();
    // Lógica comum chamada após criar o veículo
    public void EntregarVeiculo()
    {
        IVeiculo veiculo = CriarVeiculo();
        Console.WriteLine("Veículo criado e pronto para entrega.");
        veiculo.Acelerar();
    }
}
// Fábricas concretas
public class MontadoraCarros : Montadora
{
    public override IVeiculo CriarVeiculo()
    {
        // Poderia ter lógica adicional para criar o veículo
        return new Carro();
    }
}
public class MontadoraMotos : Montadora
{
    public override IVeiculo CriarVeiculo()
    {
        return new Moto();
    }
}
// Uso
public class Program
{
    public static void Main()
    {
        Montadora montadora = null;
        // Exemplo de escolha dinâmica
        Console.WriteLine("Qual veículo deseja montar? (carro/moto)");
        string opcao = Console.ReadLine().ToLower();
        if (opcao == "carro")
            montadora = new MontadoraCarros();
        else if (opcao == "moto")
            montadora = new MontadoraMotos();
        else
            Console.WriteLine("Opção inválida!");
        if (montadora != null)
        {
            // Chamamos um método geral, sem saber se é carro ou moto
            montadora.EntregarVeiculo();
        }
    }
}

Nesse exemplo:

1. Montadora é a classe base🧬 Herança: Reutilize Código sem Copiar e Colar (como um Jedi)!Aprenda a utilizar herança em C# para criar hierarquias de classes, reaproveitar código e manter projetos organizados de forma simples e escalável. com um método abstrato🧪 Classes Abstratas: Moldes para Criar Objetos Perfeitos!Aprenda a utilizar classes abstratas em C# através de exemplos práticos e desafios, garantindo código organizado e consistente em seus projetos. CriarVeiculo().

2. MontadoraCarros e📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. MontadoraMotos implementam esse método retornando o produto🔢 Operadores Aritméticos: Faça Cálculos como uma Calculadora Humana!Aprenda a dominar operadores aritméticos em C# com exemplos práticos, técnicas de cálculo e dicas para evitar erros e maximizar resultados. concreto.

3. O método🧠 Métodos em C#: Como Criar Funções que Não São Só Enfeites!Otimize seu código em C# com métodos inteligentes. Aprenda práticas de reutilização, sobrecarga e escopo para melhorar a clareza e a eficiência. EntregarVeiculo() é um template: chama o método fábrica, faz configuraçõesGerenciando Secrets e Configs em Docker SwarmAprenda a proteger credenciais, chaves e tokens com Docker Swarm. Gerencie Secrets e Configs de forma segura, garantindo integridade dos dados críticos. genéricas e depois usa o veículo criado.

Vantagens e Desvantagens🔗

Vantagens

Baixo acoplamento: O código chamador não depende de classes🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara. concretas.
Facilidade em expandir: Para criar novos tipos de veículos, basta criar📡 RESTful 101: Princípios que Todo Dev API Precisa Saber!Descubra os fundamentos do REST e boas práticas para criar APIs simples, escaláveis e eficientes. Domine métodos HTTP e status codes com exemplos práticos. outra fábrica concreta.
Organização do código de criação: Centraliza a lógica de construção em um “ponto de verdade”.

Desvantagens

Complexidade extra: A criação de subclasses de fábrica acaba aumentando o número de classes🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara..
Excesso de abstração: Em projetos🌐 LinkedIn para Devs .NET: Perfil que Atrai Recrutadores!Aprenda a otimizar seu perfil LinkedIn com dicas essenciais para devs .NET. Conquiste oportunidades e destaque suas habilidades! muito simples, pode ser um “exagero”.

Resumo🔗

O Factory Method é um padrão poderoso para cenários em que você não quer ou não pode expor a lógica de criação de objetos concretos. Ele traz maior organização, flexibilidade e facilidade de manutenção, pois cada tipo de produto fica encapsulado em sua própria “fábrica”. Em cenários📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. mais complexos, essa abordagem faz diferença na clareza e extensibilidade do código.

❌ Problema: Acoplamento Indesejado🔗

// Código frágil - alterações afetam todo o sistema
public class Client
{
    public void Main()
    {
        // Criação direta - alto acoplamento!
        IVehicle vehicle = new Truck();
        vehicle.Deliver();
    }
}

O que há de errado aqui?

🛠️ Solução: A Fábrica Inteligente🔗

Diagrama UML Simplificado

|----------------|          |----------------|
|   ICreator     |          |   IProduct     |
|----------------|          |----------------|
| +FactoryMethod()| <------ | +Operation()   |
|----------------|          |----------------|
       ^                            ^
       |                            |
|----------------|          |----------------|
| ConcreteCreator|          | ConcreteProduct|
|----------------|          |----------------|
| +FactoryMethod()|         | +Operation()   |
|----------------|          |----------------|

Componentes-chave🗂️ Dicionários: Acesse Dados por Chaves como um Mestre dos HashMaps!Aprenda a usar dicionários em C# de modo prático e eficiente. Nosso tutorial mostra criação, acesso e otimização para manipular dados com segurança.:

ICreator: Define a interface📜 Interfaces: Contratos que Garantem a Ordem no Universo OOP!Descubra como as interfaces em C# funcionam como contratos que garantem implementações flexíveis e robustas, facilitando o design e testes de sistemas. da fábrica
ConcreteCreator: Implementa a lógica de criação
IProduct: Interface📜 Interfaces: Contratos que Garantem a Ordem no Universo OOP!Descubra como as interfaces em C# funcionam como contratos que garantem implementações flexíveis e robustas, facilitando o design e testes de sistemas. dos objetos a serem criados
ConcreteProduct: Implementações específicas

🔧 Implementação Passo a Passo🔗

1. Defina a Interface📜 Interfaces: Contratos que Garantem a Ordem no Universo OOP!Descubra como as interfaces em C# funcionam como contratos que garantem implementações flexíveis e robustas, facilitando o design e testes de sistemas. do Produto:

public interface IVehicle
{
    void Deliver();
}

2. Crie Implementações Concretas:

public class Truck : IVehicle
{
    public void Deliver() => Console.WriteLine("Entrega terrestre!");
}
public class Drone : IVehicle
{
    public void Deliver() => Console.WriteLine("Entrega aérea!");
}

3. Implemente a Fábrica Abstrata:

public abstract class Logistics
{
    // Factory Method
    public abstract IVehicle CreateVehicle();
    public void PlanDelivery()
    {
        var vehicle = CreateVehicle();
        vehicle.Deliver();
    }
}

4. Crie Fábricas Concretas:

public class RoadLogistics : Logistics
{
    public override IVehicle CreateVehicle() => new Truck();
}
public class AirLogistics : Logistics
{
    public override IVehicle CreateVehicle() => new Drone();
}

Uso no Cliente:

var logistics = new AirLogistics();
logistics.PlanDelivery(); // Cria drone automaticamente

🔄 Variações Comuns🔗

Factory com Parâmetros

public class VehicleCreator
{
    public IVehicle CreateVehicle(string type)
    {
        return type switch
        {
            "road" => new Truck(),
            "sea" => new Ship(),
            "air" => new Drone(),
            _ => throw new ArgumentException("Tipo inválido")
        };
    }
}

Método Estático

public static class StaticVehicleFactory
{
    public static IVehicle CreateTruck() => new Truck();
    public static IVehicle CreateShip() => new Ship();
}

🎯 Quando Usar?🔗

Scenario	Benefício
Bibliotecas/Frameworks	Permite extensão sem modificar código existente
Sistemas com múltiplas implementações	Isola conhecimento das classes concretas
Testes unitários	Facilita mock de dependências
Complex object creation	Encapsula lógica de criação complexa

Comparação com Padrões Similares:

Abstract Factory: Cria famílias de objetos relacionados
Builder: Focado em construção passo-a-passo complexa
Factory Method: Focado em herança🧬 Herança: Reutilize Código sem Copiar e Colar (como um Jedi)!Aprenda a utilizar herança em C# para criar hierarquias de classes, reaproveitar código e manter projetos organizados de forma simples e escalável. para delegação

💡 Exemplo Prático: Sistema de Log🔗

public interface ILogger
{
    void Log(string message);
}
public class FileLogger : ILogger
{
    public void Log(string message) => File.AppendAllText("log.txt", message);
}
public class CloudLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"Enviando para nuvem: {message}");
}
public abstract class LoggerFactory
{
    public abstract ILogger CreateLogger();
    public void LogError(string message)
    {
        var logger = CreateLogger();
        logger.Log($"[ERRO] {DateTime.Now}: {message}");
    }
}
// Uso:
var factory = new CloudLoggerFactory();
factory.LogError("Erro crítico detectado!");

Benefícios na Vida Real:

Trocar destino de logs📝 Logging com Serilog: Registre Tudo como um Detetive de Bugs!Aprenda a usar Serilog em .NET para registrar logs estruturados, identificar erros e enriquecer informações, transformando seu código num enigma solucionável. sem alterar código cliente
Adicionar📦 List<T>: Dinamismo além dos Arrays!Descubra como utilizar List<T> em C# de forma eficiente. Aprenda a criar, manipular e otimizar listas para diferentes cenários com exemplos práticos. novos tipos (ex: DatabaseLogger) facilmente
Unificar formatação de mensagens

Conclusão🔗

O Factory Method é uma ferramenta essencial para projetos🌐 LinkedIn para Devs .NET: Perfil que Atrai Recrutadores!Aprenda a otimizar seu perfil LinkedIn com dicas essenciais para devs .NET. Conquiste oportunidades e destaque suas habilidades! que precisam de flexibilidade na criação de objetos. Ele permite que você decida em tempo de execução qual tipo de objeto será criado, sem que o cliente precise conhecer os detalhes de implementação. Isso resulta em um código mais limpo, desacoplado e fácil de manter. Seja em sistemas de logística, veículos ou logs, o Factory Method é um padrão que vale a pena dominar! 🚀