Reutilización de objetos con ObjectPool en ASP.NET Core

De Günther Foidl, Steve Gordon y Samson Amaugo

Microsoft.Extensions.ObjectPool forma parte de la infraestructura de ASP.NET Core que admite mantener un grupo de objetos en memoria para su reutilización en lugar de permitir que los objetos se recopilen como elementos no utilizados. Todos los métodos estáticos y de instancia de Microsoft.Extensions.ObjectPool son seguros para subprocesos.

Es posible que las aplicaciones quieran usar el grupo de objetos si los objetos que se administran son:

• Costosos de asignar o inicializar.
• Representan un recurso limitado.
• Se usan de forma predecible y frecuente.

Por ejemplo, el marco de ASP.NET Core usa el grupo de objetos en algunos lugares para reutilizar instancias StringBuilder. StringBuilder asigna y administra sus propios búferes para contener datos de caracteres. ASP.NET Core usa StringBuilder periódicamente para implementar características y reutilizarlas proporciona una ventaja de rendimiento.

La agrupación de objetos no siempre mejora el rendimiento:

• A menos que el costo de inicialización de un objeto sea alto, normalmente es más lento obtener el objeto del grupo.
• Los objetos administrados por el grupo no se desasignarán hasta que se desasigne el grupo.

Use la agrupación de objetos solo después de recopilar datos de rendimiento mediante escenarios realistas para la aplicación o biblioteca.

NOTA: ObjectPool no coloca un límite en el número de objetos que asigna, coloca un límite en el número de objetos que conserva.

Conceptos de ObjectPool

Cuando DefaultObjectPoolProvider se usa y T implementa IDisposable:

• Se eliminarán los elementos que no se devuelven al grupo.
• Cuando el grupo se elimina mediante inserción de dependencias, se eliminan todos los elementos del grupo.

NOTA: Después de eliminar el grupo:

• La llamada Get produce un ObjectDisposedException.
• La llamada Return elimina el elemento especificado.

Tipos e interfaces importantes de ObjectPool:

• ObjectPool<T> : abstracción básica del grupo de objetos. Se usa para obtener y devolver objetos.
• PooledObjectPolicy<T> : implemente esto para personalizar cómo se crea un objeto y cómo se restablece cuando se devuelve al grupo. Esto se puede pasar a un grupo de objetos construido directamente.
• IResettable : restablece automáticamente el objeto cuando se devuelve a un grupo de objetos.

ObjectPool se puede usar en una aplicación de varias maneras:

• Creación de instancias de un grupo.
• Registro de un grupo en inserción de dependencias (DI) como instancia.
• Registro en la inserción de dependencias de ObjectPoolProvider<> y usarlo como fábrica.

Cómo usar ObjectPool

Llame a Get para obtener un objeto y a Return para devolver el objeto. No es necesario devolver todos los objetos. Si no se devuelve un objeto, se recopilará como elemento no utilizado.

Muestra de ObjectPool

El código siguiente:

• Agrega ObjectPoolProvider al contenedor de inserción de dependencias (DI).
• Implementa la interfaz IResettable para borrar automáticamente el contenido del búfer cuando se devuelve al grupo de objetos.

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

NOTA: Cuando el tipo agrupado T no implementa IResettable, se puede usar un PooledObjectPolicy<T> personalizado para restablecer el estado de los objetos antes de que se devuelvan al grupo.