Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C#

System.Func<T> et Action<T> : création et réinitialisation dans un pool d’objets

Utilisez `Func<T>` comme fabrique sans paramètre et `Action<T>` pour réinitialiser un objet rendu à votre propre pool.

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

Syntaxe

// System delegate declarations (.NET 8)
public delegate TResult Func<out TResult>();
public delegate void Action<in T>(T obj);

// In a custom ObjectPool<T> where T : class, with using System;
// Constructor signature: public ObjectPool(Func<T> factory, Action<T> reset)
T item = factory();
reset(item);

En C# 12 et .NET 8, ces deux types délégués appartiennent à l’espace de noms System. Dans Func<T>, T désigne le type du résultat : factory() ne prend aucun argument et renvoie un T. Dans Action<T>, T désigne le type du paramètre : reset(item) reçoit un argument par valeur et renvoie void. Pour une classe, c’est la référence qui est copiée ; la réinitialisation peut donc modifier le même objet.

Ne les confondez pas avec Func<T, TResult> (une entrée et un résultat), ni avec Action non générique (ni entrée ni résultat). Passez une méthode nommée compatible ou une expression lambda au constructeur pour l’appeler plus tard. Pour les types référence, out permet d’affecter un Func<Derived> à un Func<Base>, et in permet d’affecter un Action<Base> à un Action<Derived>. Ces mots-clés expriment la variance, pas le passage d’arguments par référence.

Dans le ObjectPool<T> personnalisé de l’exemple, Rent() n’appelle la fabrique que si aucun objet n’est disponible. Return(item) réinitialise l’objet avant de le conserver éventuellement, même si l’unique emplacement est déjà occupé. Action<T> ne renvoie aucune décision d’acceptation. Si la réinitialisation lève une exception, elle remonte à l’appelant et cet appel ne stocke pas l’objet.

Après avoir rendu un objet, ne l’utilisez plus et ne le rendez pas une seconde fois. L’exemple n’est pas sûr en accès concurrent et ne gère pas la libération des ressources via Dispose. Ce type personnalisé n’est pas Microsoft.Extensions.ObjectPool.ObjectPool<T> ; cette bibliothèque fournit PooledObjectPolicy<T> pour personnaliser la création et le traitement des retours.

Exemples

using System;
using System.Collections.Generic;

var pool = new ObjectPool<List<string>>(
    static () => new List<string>(),
    static list => list.Clear());

var first = pool.Rent();
first.Add("temporary");
pool.Return(first);

var second = pool.Rent();
Console.WriteLine($"Same instance: {object.ReferenceEquals(first, second)}");
Console.WriteLine($"Item count: {second.Count}");
pool.Return(second);

sealed class ObjectPool<T> where T : class
{
    private readonly Func<T> _factory;
    private readonly Action<T> _reset;
    private T? _available;

    public ObjectPool(Func<T> factory, Action<T> reset)
    {
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
        _reset = reset ?? throw new ArgumentNullException(nameof(reset));
    }

    public T Rent()
    {
        if (_available is T item)
        {
            _available = null;
            return item;
        }

        return _factory() ?? throw new InvalidOperationException("The factory returned null.");
    }

    public void Return(T item)
    {
        ArgumentNullException.ThrowIfNull(item);
        _reset(item);
        _available ??= item;
    }
}

Résultat

Same instance: True
Item count: 0

La fabrique crée une liste au premier emprunt. `Clear()` supprime son élément au retour ; le second emprunt récupère la même liste, désormais vide.

Leçons associées

  • C# · Leçon 13 · Avancé · Version : 3

Sources