0Pricing
C# Academy · Aula

Padrões Factory e Options

Use delegados de fábrica, IServiceProvider e o padrão Options para lidar com dependências condicionais ou configuráveis.

Padrões Factory e Options é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Quando a injeção pelo construtor não é suficiente

Às vezes, é necessário criar serviços condicionalmente, com base em dados de tempo de execução, ou configurá-los de forma diferente para cada caso de uso. É nesse ponto que os padrões de fábrica e de opções se destacam.

Delegados de fábrica com AddTransient

Você pode passar um delegado de fábrica para AddTransient, AddScoped ou AddSingleton. O delegado recebe IServiceProvider, permitindo resolver outros serviços.

builder.Services.AddTransient<IPaymentGateway>(sp =>
{
    var config = sp.GetRequiredService<IOptions<PaymentConfig>>().Value;
    return config.Provider == "stripe"
        ? new StripeGateway(config.ApiKey)
        : new PayPalGateway(config.ClientId, config.Secret);
});

Opções nomeadas com IOptionsSnapshot

O padrão de opções associa seções de configuração a classes fortemente tipadas. Use IOptions<T> para serviços de instância única e IOptionsSnapshot<T> para valores atualizados por solicitação.

public class SmtpSettings
{
    public string Host { get; set; } = "";
    public int Port { get; set; } = 587;
    public string Username { get; set; } = "";
}

// Registration
builder.Services.Configure<SmtpSettings>(
    builder.Configuration.GetSection("Smtp"));

// Consumption
public class EmailService
{
    private readonly SmtpSettings _settings;
    public EmailService(IOptions<SmtpSettings> opts)
        => _settings = opts.Value;
}

IOptionsMonitor para recarregamento em tempo real

IOptionsMonitor<T> fornece o valor atual da opção no momento do acesso e notifica você quando a configuração muda — perfeito para serviços de instância única que precisam de atualizações de configuração em tempo real.

public class FeatureFlagService
{
    private readonly IOptionsMonitor<FeatureFlags> _monitor;

    public FeatureFlagService(IOptionsMonitor<FeatureFlags> monitor)
        => _monitor = monitor;

    public bool IsEnabled(string flag)
    {
        // Always reads the latest config value
        return _monitor.CurrentValue.Flags.GetValueOrDefault(flag);
    }
}

Opções nomeadas

As opções nomeadas permitem registrar várias configurações do mesmo tipo. Use Configure<T>(name, ...) e resolva com IOptionsSnapshot<T>.Get(name).

builder.Services.Configure<S3Settings>("primary",
    builder.Configuration.GetSection("S3:Primary"));
builder.Services.Configure<S3Settings>("backup",
    builder.Configuration.GetSection("S3:Backup"));

public class S3Service
{
    public S3Service(IOptionsSnapshot<S3Settings> opts)
    {
        var primary = opts.Get("primary");
        var backup  = opts.Get("backup");
    }
}

Validando opções na inicialização

Use ValidateDataAnnotations() ou um validador personalizado para garantir que a configuração esteja correta antes da inicialização do aplicativo. Combine isso com ValidateOnStart() para obter um comportamento de falha rápida.

public class SmtpSettings
{
    [Required] public string Host { get; set; } = "";
    [Range(1, 65535)] public int Port { get; set; } = 587;
}

builder.Services
    .AddOptions<SmtpSettings>()
    .Bind(builder.Configuration.GetSection("Smtp"))
    .ValidateDataAnnotations()
    .ValidateOnStart();

Padrão de fábrica abstrata

Uma interface de fábrica abstrata permite injetar uma fábrica nos serviços, adiando a construção até que os dados de tempo de execução estejam disponíveis — sem depender diretamente de IServiceProvider.

public interface IReportFactory
{
    IReport Create(string reportType);
}

public class ReportFactory : IReportFactory
{
    private readonly IServiceProvider _sp;
    public ReportFactory(IServiceProvider sp) => _sp = sp;

    public IReport Create(string reportType) => reportType switch
    {
        "pdf"  => _sp.GetRequiredService<PdfReport>(),
        "excel"=> _sp.GetRequiredService<ExcelReport>(),
        _      => throw new ArgumentException("Unknown type")
    };
}

builder.Services.AddTransient<IReportFactory, ReportFactory>();

Serviços com chave (.NET 8)

O .NET 8 introduz serviços com chave: registre várias implementações com chaves diferentes e resolva a correta usando [FromKeyedServices] ou GetKeyedService.

builder.Services.AddKeyedScoped<IPaymentGateway, StripeGateway>("stripe");
builder.Services.AddKeyedScoped<IPaymentGateway, PayPalGateway>("paypal");

// Resolve in a class:
public class CheckoutService(
    [FromKeyedServices("stripe")] IPaymentGateway stripe,
    [FromKeyedServices("paypal")]  IPaymentGateway paypal) { }

PostConfigure para substituições

PostConfigure é executado depois de todas as chamadas a Configure. Use-o para aplicar substituições nos testes ou impor invariantes, independentemente da configuração carregada.

// In integration tests: force test values after real config
builder.Services.PostConfigure<SmtpSettings>(opts =>
{
    opts.Host = "smtp.test.local";
    opts.Port = 25;
});

Métodos de extensão de IServiceCollection

Agrupe seus registros em métodos de extensão para manter Program.cs limpo e tornar os módulos reutilizáveis em diferentes projetos.

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddPaymentServices(
        this IServiceCollection services,
        IConfiguration config)
    {
        services.Configure<PaymentConfig>(config.GetSection("Payment"));
        services.AddScoped<IPaymentGateway, StripeGateway>();
        services.AddScoped<PaymentService>();
        return services;
    }
}

// Usage in Program.cs:
builder.Services.AddPaymentServices(builder.Configuration);

Na prática: notificações com vários provedores

Usando uma fábrica e opções nomeadas em conjunto, você pode selecionar o provedor de notificações correto em tempo de execução, com base na preferência do usuário armazenada no banco de dados.

builder.Services.AddKeyedScoped<INotifier, EmailNotifier>("email");
builder.Services.AddKeyedScoped<INotifier, SmsNotifier>("sms");
builder.Services.AddKeyedScoped<INotifier, PushNotifier>("push");

public class NotificationService
{
    private readonly IServiceProvider _sp;
    public NotificationService(IServiceProvider sp) => _sp = sp;

    public Task SendAsync(string channel, string message)
    {
        var notifier = _sp.GetRequiredKeyedService<INotifier>(channel);
        return notifier.SendAsync(message);
    }
}

Verificação rápida

Qual interface fornece o valor atual das opções AND notifica sobre mudanças na configuração, sendo adequada para serviços de instância única?

Recapitulação: padrões de fábrica e de opções

Principais conclusões:

  • Delegados de fábrica nos métodos Add* permitem a criação condicional ou configurada em tempo de execução de serviços
  • O padrão de opções associa seções de configuração a POCOs fortemente tipados
  • IOptions = estático, IOptionsSnapshot = por solicitação, IOptionsMonitor = atualizações em tempo real
  • Valide as opções na inicialização com ValidateDataAnnotations().ValidateOnStart()
  • Os serviços com chave (.NET 8) substituem soluções alternativas baseadas em fábricas para implementações nomeadas

Perguntas Frequentes

A aula “Padrões Factory e Options” é grátis?

Sim — o texto completo de “Padrões Factory e Options” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Padrões Factory e Options”?

Use delegados de fábrica, IServiceProvider e o padrão Options para lidar com dependências condicionais ou configuráveis. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Padrões Factory e Options”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Fundamentos do contêiner de DI
  2. Ciclos de vida dos serviços: Transient, Scoped e Singleton
  3. Injeção pelo construtor e interfaces
  4. Padrões Factory e Options
← Voltar para C# Academy