Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

System.Func<T> e Action<T>: creazione e ripristino in un pool di oggetti

Usa `Func<T>` come factory senza parametri e `Action<T>` per ripristinare un oggetto restituito al tuo pool.

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

Sintassi

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

In C# 12 e .NET 8, entrambi i tipi delegato appartengono allo spazio dei nomi System. In Func<T>, T è il tipo del risultato: factory() non accetta argomenti e restituisce un T. In Action<T>, T è il tipo del parametro: reset(item) riceve un argomento per valore e restituisce void. Per una classe si copia il riferimento, quindi il ripristino può modificare lo stesso oggetto.

Non confonderli con Func<T, TResult> (un input e un risultato) o con Action non generico (né input né risultato). Passa al costruttore un metodo con nome compatibile o una lambda da invocare in seguito. Per i tipi riferimento, out consente di assegnare Func<Derived> a Func<Base>, mentre in consente di assegnare Action<Base> a Action<Derived>. Questi indicatori esprimono la varianza, non il passaggio degli argomenti per riferimento.

Nell’ObjectPool<T> personalizzato dell’esempio, Rent() chiama la factory solo quando non ci sono oggetti disponibili. Return(item) ripristina l’oggetto prima di conservarlo, se possibile, anche quando l’unico posto è già occupato. Action<T> non restituisce una decisione di accettazione. Se il ripristino genera un’eccezione, questa si propaga al chiamante e quella chiamata non conserva l’oggetto.

Dopo aver restituito un oggetto, non usarlo né restituirlo di nuovo. L’esempio non è thread-safe e non gestisce il rilascio delle risorse tramite Dispose. È un tipo personalizzato, non Microsoft.Extensions.ObjectPool.ObjectPool<T>; quella libreria fornisce PooledObjectPolicy<T> per personalizzare la creazione e la gestione della restituzione.

Esempi

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;
    }
}

Risultato

Same instance: True
Item count: 0

La factory crea una lista al primo prestito. Alla restituzione, `Clear()` rimuove l’elemento. Il secondo prestito recupera la stessa lista, ora vuota.

Lezioni correlate

  • C# · Lezione 13 · Avanzato · Versione: 3

Fonti