Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

System.Func em C#: fábricas do contentor, predicados e seletores

Regista fábricas que devolvem serviços de tipos diferentes num contentor personalizado e usa o mesmo tipo de delegado para filtrar e transformar uma sequência com LINQ.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

// C# 12 / .NET 8
using System;
using System.Collections.Generic;

// System.Func<T,TResult> declaration (API reference):
// public delegate TResult Func<in T, out TResult>(T arg);

// Factory registration and storage in the example's custom Container (Get omitted).
sealed class Container
{
    private readonly Dictionary<Type, Func<Container, object>> factories = new();

    public void Add<TService>(Func<Container, TService> factory) where TService : class
    {
        ArgumentNullException.ThrowIfNull(factory);
        Func<Container, object> stored = factory;
        factories.Add(typeof(TService), stored);
    }
}

// System.Linq.Enumerable extension method signatures (API reference):
// public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
// public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
// public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
// public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector);

Em C# 12 e .NET 8, System.Func<T,TResult> é um delegado que recebe um argumento do tipo T e devolve um valor do tipo TResult. Numa lambda como x => ..., => separa o parâmetro do corpo. Atribuir a lambda não executa o seu corpo; a chamada f(x) executa-o se f referenciar essa lambda.

O Container personalizado aceita Func<Container,TService> e guarda a fábrica como Func<Container,object> com a chave typeof(TService). A fábrica recebe o contentor atual e pode usá-lo para resolver dependências. out TResult permite a conversão implícita para o tipo de referência de retorno mais geral object (covariância), mas não a conversão inversa. in T permite usar um delegado que aceita um tipo de referência mais geral em vez de um que aceita um tipo mais específico (contravariância); aqui a entrada continua a ser Container. A variância não converte um resultado de tipo valor como int para object. O exemplo limita TService com where TService : class; fora dessa restrição, uma lambda adaptadora como c => intFactory(c) atribuída a Func<Container,object> poderia fazer boxing do resultado.

Get<TService>() invoca a fábrica em cada chamada, verifica o tipo do resultado e rejeita também null. Um registo em falta ou um resultado inválido lança InvalidOperationException, um registo duplicado lança ArgumentException e uma fábrica null lança ArgumentNullException. Este exemplo didático não é o contentor de injeção de dependências integrado no .NET: não tem cache, âmbitos, libertação de recursos ou deteção de ciclos. O tempo de vida depende do comportamento da fábrica e das regras do contentor, não de Func. Regista apenas fábricas de confiança: um delegado executa código sem o isolar.

Em System.Linq, Enumerable.Where sobre IEnumerable<TSource> usa Func<T,bool> com T igual a TSource: true conserva o elemento e false ignora-o. Enumerable.Select usa Func<TSource,TResult> para produzir um resultado por elemento de entrada, possivelmente de outro tipo. As sobrecargas indexadas acrescentam um segundo argumento int: o índice a partir de zero na entrada do próprio operador. A execução é adiada até à enumeração; uma origem ou um delegado null lança ArgumentNullException logo na chamada do método. System.Predicate<T> tem a mesma assinatura de predicado, mas é um tipo de delegado distinto. Os equivalentes de Queryable para IQueryable<T> recebem árvores de expressão Expression<Func<...>> em vez de instâncias de delegado; as expressões suportadas dependem do fornecedor de consultas.

Exemplos

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

var container = new Container();
container.Add<string>(_ => "item-");
Func<Container, Labels> makeLabels = c => new Labels(c.Get<string>());
container.Add(makeLabels);

var labels = container.Get<Labels>();
Func<int, bool> keep = n => n % 2 == 0;
Func<int, string> label = n => labels.Prefix + n.ToString(CultureInfo.InvariantCulture);

foreach (string text in new[] { 1, 2, 3, 4 }.Where(keep).Select(label))
    Console.WriteLine(text);

Console.WriteLine(object.ReferenceEquals(labels, container.Get<Labels>()) ? "same" : "different");

sealed record Labels(string Prefix);

sealed class Container
{
    private readonly Dictionary<Type, Func<Container, object>> factories = new();

    public void Add<TService>(Func<Container, TService> factory) where TService : class
    {
        ArgumentNullException.ThrowIfNull(factory);
        Func<Container, object> stored = factory;
        factories.Add(typeof(TService), stored);
    }

    public TService Get<TService>() where TService : class
    {
        if (!factories.TryGetValue(typeof(TService), out var factory))
            throw new InvalidOperationException($"No factory for {typeof(TService).Name}.");

        return factory(this) is TService service
            ? service
            : throw new InvalidOperationException($"Invalid result for {typeof(TService).Name}.");
    }
}

Resultado

item-2
item-4
different

A fábrica de `Labels` obtém o prefixo a partir do mesmo contentor. `Where` conserva os números pares e `Select` produz `item-2` e `item-4`. A linha `different` indica que voltar a resolver `Labels` devolveu uma instância diferente.

Lições relacionadas

  • C# · Lição 44 · Avançado · Versão: 3
  • C# · Lição 9 · Intermédio · Versão: 2

Fontes