CKTIS / C#
System.Func en C#: fábricas del contenedor, predicados y selectores
Registra fábricas con distintos tipos de servicio como resultado en un contenedor propio y usa el mismo tipo de delegado para filtrar y transformar una secuencia con LINQ.
Versión: C# 12 and .NET 8; later runtimes may add compatible features
Sintaxis
// 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);En C# 12 y .NET 8, System.Func<T,TResult> es un delegado que recibe un argumento de tipo T y devuelve un valor de tipo TResult. En una lambda como x => ..., => separa el parámetro del cuerpo. Asignar la lambda no ejecuta su cuerpo; invocar f(x) sí lo ejecuta si f hace referencia a esa lambda.
El Container personalizado acepta Func<Container,TService> y almacena la fábrica como Func<Container,object> bajo la clave typeof(TService). La fábrica recibe el contenedor actual y puede resolver dependencias a través de él. out TResult permite la conversión implícita al tipo de referencia de retorno más general object (covarianza), pero no a la inversa. in T permite que un delegado que recibe un tipo de referencia más general sustituya a otro que recibe uno más específico (contravarianza); aquí la entrada sigue siendo Container. La varianza no convierte un resultado de tipo valor como int en object. El ejemplo restringe TService mediante where TService : class; fuera de esa restricción, una lambda adaptadora como c => intFactory(c) asignada a Func<Container,object> podría aplicar boxing al resultado.
Get<TService>() invoca la fábrica en cada llamada, comprueba el tipo del resultado y rechaza también null. Un registro ausente o un resultado no válido provoca InvalidOperationException, un registro duplicado ArgumentException y una fábrica null ArgumentNullException. Este ejemplo didáctico no es el contenedor de inyección de dependencias integrado en .NET: no incorpora caché, ámbitos, liberación de recursos ni detección de ciclos. El ciclo de vida depende de la fábrica y de las reglas del contenedor, no de Func. Registra solo fábricas de confianza: un delegado ejecuta código sin aislarlo.
En System.Linq, Enumerable.Where sobre IEnumerable<TSource> usa Func<T,bool> con T igual a TSource: true conserva el elemento y false lo omite. Enumerable.Select usa Func<TSource,TResult> y produce un resultado por elemento de entrada, que puede ser de otro tipo. Las sobrecargas indexadas añaden un segundo argumento int: el índice desde cero en la entrada de ese operador. La ejecución se difiere hasta la enumeración; un origen o delegado null provoca ArgumentNullException al llamar al método. System.Predicate<T> tiene la misma firma de predicado, pero es un tipo de delegado distinto. Los equivalentes de Queryable para IQueryable<T> reciben árboles de expresión Expression<Func<...>> en lugar de instancias de delegado; las expresiones admitidas dependen del proveedor de consultas.
Ejemplos
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
La fábrica de `Labels` obtiene su prefijo del mismo contenedor. `Where` conserva los números pares y `Select` produce `item-2` y `item-4`. La línea `different` indica que volver a resolver `Labels` devolvió una instancia distinta.
Lecciones relacionadas
- C# · Lección 44 · Avanzado · Versión: 3
- C# · Lección 9 · Intermedio · Versión: 2