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