Réutilisation d’objets avec ObjectPool dans ASP.NET Core

Par Günther Foidl, Steve Gordon et Samson Amaugo

Microsoft.Extensions.ObjectPool fait partie de l’infrastructure ASP.NET Core qui prend en charge la conservation d’un groupe d’objets en mémoire à des fins de réutilisation au lieu de permettre le nettoyage de la mémoire des objets. Toutes les méthodes statiques et instance dans Microsoft.Extensions.ObjectPool sont thread-safe.

Les applications peuvent souhaiter utiliser le pool d’objets si les objets gérés rencontrent les situations suivantes :

• L’allocation/l’initialisation est coûteuse.
• Les objets gérés représentent une ressource limitée.
• Ils sont utilisés de manière prévisible et fréquemment.

Par exemple, l’infrastructure ASP.NET Core utilise le pool d’objets à certains endroits pour réutiliser les instances StringBuilder. StringBuilder alloue et gère ses propres mémoires tampons pour contenir les données caractères. ASP.NET Core utilise régulièrement StringBuilder pour implémenter des fonctionnalités, et les réutiliser offre un avantage en matière de performances.

La mise en pool d’objets n’améliore pas toujours les performances :

• Sauf si le coût d’initialisation d’un objet est élevé, il est généralement plus lent d’obtenir l’objet à partir du pool.
• Les objets gérés par le pool ne sont pas désalloués tant que le pool n’est pas désalloué.

Utilisez le regroupement d’objets uniquement après avoir collecté des données de performances à l’aide de scénarios réalistes pour votre application ou bibliothèque.

REMARQUE : Le pool d’objets ne limite pas le nombre d’objets qu’il alloue, il place une limite sur le nombre d’objets qu’il conserve.

Concepts d’ObjectPool

Quand DefaultObjectPoolProvider est utilisé et T implémente IDisposable :

• Les éléments qui ne sont pas retournés au pool seront supprimés.
• Lorsque le pool est supprimé par DI, tous les éléments du pool sont supprimés.

REMARQUE : Une fois le pool supprimé :

• L’appel Get lève un ObjectDisposedException.
• L’appel Return supprime l’élément donné.

Types et interfaces ObjectPool importants :

• ObjectPool<T> : abstraction du pool d’objets de base. Utilisé pour obtenir et retourner des objets.
• PooledObjectPolicy<T> : implémentez ceci pour personnaliser la façon dont un objet est créé et comment il est réinitialisé quand il est retourné au pool. Ceci peut être passé dans un pool d’objets qui est construit directement.
• IResettable : réinitialise automatiquement l’objet lorsqu’il est retourné à un pool d’objets.

Le pool d’objets peut être utilisé de plusieurs façons dans une application :

• Instanciation d’un pool.
• Inscription d’un pool dans l’injection de dépendances (DI) en tant qu’instance.
• Inscription du ObjectPoolProvider<> dans DI et utilisation de celui-ci en tant que fabrique.

Comment utiliser ObjectPool

Appelez Get pour obtenir un objet et Return pour retourner l’objet. Il n’est pas nécessaire de retourner chaque objet. Si aucun objet n’est retourné, il est récupéré par la mémoire.

Exemple ObjectPool

Le code suivant :

• Ajoute ObjectPoolProvider au conteneur d’injection de dépendances (DI).
• Implémente l’interface IResettable pour effacer automatiquement le contenu de la mémoire tampon lorsqu’elle est retournée au pool d’objets.

using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.ObjectPool;
using System.Security.Cryptography;

var builder = WebApplication.CreateBuilder(args);

builder.Services.TryAddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();

builder.Services.TryAddSingleton<ObjectPool<ReusableBuffer>>(serviceProvider =>
{
    var provider = serviceProvider.GetRequiredService<ObjectPoolProvider>();
    var policy = new DefaultPooledObjectPolicy<ReusableBuffer>();
    return provider.Create(policy);
});

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

// return the SHA256 hash of a word 
// https://localhost:7214/hash/SamsonAmaugo
app.MapGet("/hash/{name}", (string name, ObjectPool<ReusableBuffer> bufferPool) =>
{

    var buffer = bufferPool.Get();
    try
    {
        // Set the buffer data to the ASCII values of a word
        for (var i = 0; i < name.Length; i++)
        {
            buffer.Data[i] = (byte)name[i];
        }

        Span<byte> hash = stackalloc byte[32];
        SHA256.HashData(buffer.Data.AsSpan(0, name.Length), hash);
        return "Hash: " + Convert.ToHexString(hash);
    }
    finally
    {
        // Data is automatically reset because this type implemented IResettable
        bufferPool.Return(buffer); 
    }
});
app.Run();

public class ReusableBuffer : IResettable
{
    public byte[] Data { get; } = new byte[1024 * 1024]; // 1 MB

    public bool TryReset()
    {
        Array.Clear(Data);
        return true;
    }
}

NOTE : Lorsque le type T mis en pool n’implémente pas IResettable, un PooledObjectPolicy<T> personnalisé peut être utilisé pour réinitialiser l’état des objets avant qu’ils ne soient retournés au pool.