CKTIS / C#
System.Func in C#: factory del contenitore, predicati e selettori
Registra factory che restituiscono tipi di servizio diversi in un contenitore personalizzato e usa lo stesso tipo di delegato per filtrare e trasformare una sequenza con LINQ.
Versione: C# 12 and .NET 8; later runtimes may add compatible features
Sintassi
// 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);In C# 12 e .NET 8, System.Func<T,TResult> è un delegato che accetta un argomento di tipo T e restituisce un valore di tipo TResult. In una lambda come x => ..., => separa il parametro dal corpo. Assegnare la lambda non ne esegue il corpo; l’invocazione f(x) lo esegue se f si riferisce a quella lambda.
Il Container personalizzato accetta Func<Container,TService> e memorizza la factory come Func<Container,object> con chiave typeof(TService). La factory riceve il contenitore corrente e può usarlo per risolvere le dipendenze. out TResult consente la conversione implicita al tipo di riferimento di ritorno più generico object (covarianza), ma non quella inversa. in T consente di sostituire un delegato che accetta un tipo di riferimento più specifico con uno che accetta un tipo più generico (controvarianza); qui l’input resta di tipo Container. La varianza non converte un risultato di tipo valore come int in object. L’esempio impone where TService : class; senza questo vincolo, una lambda di adattamento come c => intFactory(c) assegnata a Func<Container,object> potrebbe eseguire il boxing del risultato.
Get<TService>() invoca la factory a ogni chiamata, controlla il tipo del risultato e rifiuta anche null. Una registrazione mancante o un risultato non valido genera InvalidOperationException, una registrazione duplicata ArgumentException e una factory null ArgumentNullException. Questo esempio didattico non è il contenitore DI integrato in .NET: non gestisce cache, ambiti, rilascio delle risorse o rilevamento dei cicli. Il ciclo di vita dipende dal comportamento della factory e dalle regole del contenitore, non da Func. Registra solo factory attendibili: un delegato esegue codice senza isolarlo.
In System.Linq, Enumerable.Where su IEnumerable<TSource> usa Func<T,bool> con T uguale a TSource: true mantiene l’elemento e false lo salta. Enumerable.Select usa Func<TSource,TResult> per produrre un risultato per ogni elemento in ingresso, eventualmente di tipo diverso. Gli overload indicizzati aggiungono un secondo argomento int: l’indice a partire da zero nell’input di quell’operatore. L’esecuzione è differita fino all’enumerazione; un’origine o un delegato null genera ArgumentNullException già alla chiamata. System.Predicate<T> ha la stessa firma del predicato, ma è un tipo di delegato distinto. Gli equivalenti Queryable per IQueryable<T> accettano alberi di espressione Expression<Func<...>> anziché istanze di delegato; le espressioni supportate dipendono dal provider di query.
Esempi
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}.");
}
}Risultato
item-2 item-4 different
La factory di `Labels` recupera il prefisso dallo stesso contenitore. `Where` mantiene i numeri pari e `Select` produce `item-2` e `item-4`. La riga `different` indica che una seconda risoluzione di `Labels` ha restituito un’istanza distinta.
Lezioni correlate
- C# · Lezione 44 · Avanzato · Versione: 3
- C# · Lezione 9 · Intermedio · Versione: 2