Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C#

System.Func v C#: továrne kontajnera, predikáty a selektory

Zaregistrujte továrne s rôznymi návratovými typmi služieb vo vlastnom kontajneri a použite rovnaký typ delegáta na filtrovanie a transformáciu postupnosti v LINQ.

Verzia: C# 12 and .NET 8; later runtimes may add compatible features

Syntax

// 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);

V C# 12 a .NET 8 je System.Func<T,TResult> delegát, ktorý prijíma jeden argument typu T a vracia hodnotu typu TResult. V lambda výraze x => ... oddeľuje => parameter od tela. Priradenie lambdy nevykoná jej telo; vykoná ho volanie f(x), ak f odkazuje na túto lambdu.

Vlastný Container prijíma Func<Container,TService> a ukladá továreň ako Func<Container,object> pod kľúčom typeof(TService). Továreň dostane aktuálny kontajner a môže z neho získať závislosti. out TResult umožňuje implicitný prevod na všeobecnejší referenčný návratový typ object (kovariancia), nie však opačne. in T umožňuje použiť delegáta prijímajúceho všeobecnejší referenčný typ namiesto delegáta pre konkrétnejší typ (kontravariancia); tu vstup zostáva typu Container. Variancia neprevádza výsledok hodnotového typu, napríklad int, na object. Príklad obmedzuje TService pomocou where TService : class; mimo tohto obmedzenia môže adaptačná lambda c => intFactory(c) priradená k Func<Container,object> zabaliť výsledok do objektu (boxing).

Get<TService>() pri každom volaní spustí továreň, skontroluje typ výsledku a odmietne aj null. Chýbajúca registrácia alebo neplatný výsledok vyvolá InvalidOperationException, duplicitná registrácia ArgumentException a továreň s hodnotou null ArgumentNullException. Tento výučbový príklad nie je vstavaný kontajner DI v .NET: nemá vyrovnávaciu pamäť, rozsahy, uvoľňovanie prostriedkov ani detekciu cyklov. Životnosť závisí od správania továrne a pravidiel kontajnera, nie od typu Func. Registrujte len dôveryhodné továrne: delegát vykonáva kód bez izolácie.

V System.Linq používa Enumerable.Where nad IEnumerable<TSource> delegáta Func<T,bool>, kde T je TSource: true prvok ponechá, false ho vynechá. Enumerable.Select používa Func<TSource,TResult> a vytvára jeden výsledok na vstupný prvok, prípadne iného typu. Indexované preťaženia pridávajú druhý argument typu int: index od nuly vo vstupe daného operátora. Vykonanie je odložené do enumerácie; zdroj alebo delegát s hodnotou null vyvolá ArgumentNullException už pri volaní metódy. System.Predicate<T> má rovnakú signatúru predikátu, ale je to iný typ delegáta. Náprotivky z Queryable pre IQueryable<T> prijímajú stromy výrazov Expression<Func<...>>, nie inštancie delegátov; podpora výrazov závisí od poskytovateľa dotazu.

Príklady

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}.");
    }
}

Výsledok

item-2
item-4
different

Továreň `Labels` získa predponu z toho istého kontajnera. `Where` ponechá párne čísla a `Select` vytvorí `item-2` a `item-4`. Riadok `different` znamená, že ďalšie získanie `Labels` vrátilo inú inštanciu.

Súvisiace lekcie

  • C# · Lekcia 44 · Pokročilá · Verzia: 3
  • C# · Lekcia 9 · Stredne pokročilá · Verzia: 2

Zdroje