Skip to content
CodeDesignPlus

RedisServiceFactory

El servicio RedisServiceFactory proporciona una fábrica para crear y gestionar instancias de IRedis. Su propósito principal es abstraer la creación de los servicios Redis, permitiendo que la aplicación pueda solicitar instancias específicas de IRedis basadas en nombres configurados, facilitando el uso de múltiples conexiones a Redis en la misma aplicación.

namespace CodeDesignPlus.Net.Redis.Abstractions;


/// <summary>
/// Defines a factory for creating and initializing instances of <see cref="IRedis"/> based on a provided instance name.
/// </summary>
public interface IRedisFactory
{
    /// <summary>
    /// Creates and initializes an instance of <see cref="IRedis"/> based on the provided instance name.
    /// </summary>
    /// <param name="name">The name of the Redis instance to create.</param>
    /// <returns>An initialized <see cref="IRedis"/> instance.</returns>
    /// <exception cref="ArgumentNullException">Thrown when the name is null or empty.</exception>
    IRedis Create(string name);
}

¿Cómo Funciona?

RedisServiceFactory funciona como un punto central para la creación de servicios Redis (IRedis). La fábrica toma un nombre como entrada, busca la configuración correspondiente en las opciones de Redis (configuradas a través de RedisOptions), y crea una instancia de IRedis con esa configuración. Esto permite gestionar múltiples conexiones a Redis con diferentes configuraciones, todo gestionado centralmente por la fábrica. La creación de cada instancia es controlada por la fábrica, asegurando que los servicios Redis sean inicializados correctamente antes de ser utilizados por la aplicación.

Métodos

RedisServiceFactory proporciona un único método para crear instancias de IRedis basadas en un nombre específico.

Create

Type: public IRedis Create(string name)

Este método es responsable de crear y devolver una instancia de IRedis. Toma como parámetro el nombre de la instancia de Redis que se desea crear. El método realiza los siguientes pasos:

  1. Validación del nombre: Verifica que el nombre proporcionado no sea nulo o vacío.
  2. Obtención de la configuración: Busca en las opciones de Redis la configuración de instancia con el nombre proporcionado.
  3. Creación de RedisService: Crea una instancia de RedisService, que es la implementación concreta de IRedis.
  4. Inicialización de la instancia: Llama al método Initialize de RedisService con la configuración de la instancia.
  5. Retorno de la instancia: Retorna la instancia creada y configurada de IRedis.

Implementación

La implementación de RedisServiceFactory se encarga de la lógica de creación e inicialización de las instancias de IRedis. Internamente, utiliza las opciones de configuración registradas en el contenedor de inyección de dependencias (IOptions<RedisOptions>) para recuperar la configuración de la instancia Redis requerida. El método Create busca la configuración por nombre y crea una instancia del RedisService correspondiente, pasando la configuración de instancia que corresponda.

namespace CodeDesignPlus.Net.Redis.Services;


/// <summary>
/// Factory for creating and managing Redis services.
/// </summary>
public class RedisServiceFactory : IRedisFactory
{
    private readonly IServiceProvider serviceProvider;
    private readonly RedisOptions options;
    private readonly ILogger<RedisServiceFactory> logger;
    private readonly ConcurrentDictionary<string, Abstractions.IRedis> instances = new();


    /// <summary>
    /// Initializes a new instance of the <see cref="RedisServiceFactory"/> class.
    /// </summary>
    /// <param name="serviceProvider">The service provider.</param>
    /// <param name="options">The Redis options.</param>
    /// <param name="logger">The logger instance.</param>
    /// <exception cref="ArgumentNullException">Thrown when <paramref name="serviceProvider"/>, <paramref name="options"/>, or <paramref name="logger"/> is null.</exception>
    public RedisServiceFactory(IServiceProvider serviceProvider, IOptions<RedisOptions> options, ILogger<RedisServiceFactory> logger)
    {
        ArgumentNullException.ThrowIfNull(serviceProvider);
        ArgumentNullException.ThrowIfNull(options);
        ArgumentNullException.ThrowIfNull(logger);


        this.serviceProvider = serviceProvider;
        this.options = options.Value;
        this.logger = logger;


        this.logger.LogInformation("RedisServiceFactory has been initialized");
    }


    /// <summary>
    /// Creates a Redis service for the specified instance name.
    /// </summary>
    /// <param name="name">The name of the Redis instance.</param>
    /// <returns>The Redis service.</returns>
    /// <exception cref="ArgumentNullException">Thrown when <paramref name="name"/> is null or empty.</exception>
    /// <exception cref="Exceptions.RedisException">Thrown when the Redis instance with the specified name is not registered.</exception>
    public Abstractions.IRedis Create(string name)
    {
        if (string.IsNullOrEmpty(name))
            throw new ArgumentNullException(nameof(name));


        if (!options.Instances.TryGetValue(name, out Instance value))
            throw new Exceptions.RedisException($"The redis instance with the name {name} has not been registered");


        if (this.instances.TryGetValue(name, out var service))
            return service;


        service = this.serviceProvider.GetRequiredService<Abstractions.IRedis>();


        service.Initialize(value);


        this.instances.TryAdd(name, service);


        this.logger.LogInformation("Redis instance {Name} has been added to the factory", name);


        return service;
    }
}

Ejemplo de Uso

Este ejemplo muestra cómo inicializar y utilizar IRedis en una aplicación de consola a través de IRedisFactory y la inyección de dependencias de .NET.

using CodeDesignPlus.Net.Redis.Abstractions;
using CodeDesignPlus.Net.Redis.Extensions;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;


var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .Build();


var serviceCollection = new ServiceCollection();


serviceCollection.AddLogging();
serviceCollection.AddRedis(configuration);


var serviceProvider = serviceCollection.BuildServiceProvider();


var factory = serviceProvider.GetRequiredService<IRedisFactory>();


var service = factory.Create(FactoryConst.RedisCore);


var item = new {
    Id = 1,
    Name = "CodeDesignPlus"
};


await service.Database.StringSetAsync("item", JsonConvert.SerializeObject(item));


var result = await service.Database.StringGetAsync("item");


Console.WriteLine(result);

Conclusiones

RedisServiceFactory centraliza la creación de instancias de IRedis, permitiendo manejar múltiples conexiones a Redis dentro de la aplicación de manera organizada. Al desacoplar la creación de los servicios Redis, la fábrica facilita la gestión de configuraciones y promueve la reutilización de código. Es un componente fundamental para las aplicaciones que necesitan conectarse a múltiples instancias de Redis, o cuando se requiere un nivel de abstracción en la creación de los servicios de Redis.

Referencias Adicionales