lux/EgwCoreLib.Lux.Data/Services/RedisService.cs

using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime;
using System.Text;
using System.Threading.Tasks;

namespace EgwCoreLib.Lux.Data.Services
{
    /// <summary>
    /// Implementazione interfaccia REDIS:
    /// - gestione PubSub
    /// - gestione caching
    /// </summary>
    public class RedisService : IRedisService
    {
        #region Public Constructors

        public RedisService(IConnectionMultiplexer connection)
        {
            _connection = connection;
            _db = connection.GetDatabase();
            _subscriber = connection.GetSubscriber();

            // json serializer... FIX errore loop circolare https://www.ryadel.com/en/jsonserializationexception-self-referencing-loop-detected-error-fix-entity-framework-asp-net-core/
            JSSettings = new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };
            Log.Info("Startup completed");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Recupero stringa da cache REDIS x key indicata in modalità Async
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string? Get(string key)
        {
            Log.Trace($"Get request for {key}");
            var value = _db.StringGet(key);
            return value.HasValue ? value.ToString() : null;
        }

        /// <summary>
        /// Recupero stringa da cache REDIS x key indicata in modalità Async
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<string?> GetAsync(string key)
        {
            Log.Trace($"GetAsync request for {key}");
            var value = await _db.StringGetAsync(key);
            return value.HasValue ? value.ToString() : null;
        }

        /// <summary>
        /// Pubblicazione messaggio su channel
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public long Publish(string channel, string message)
        {
            Log.Trace($"Publish: channel {channel}");
            RedisChannel rChannel = new RedisChannel(channel, RedisChannel.PatternMode.Literal);
            long numCli = _subscriber.Publish(rChannel, message);
            return numCli;
        }

        /// <summary>
        /// Pubblicazione messaggio su channel in modalità async
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public async Task<long> PublishAsync(string channel, string message)
        {
            Log.Trace($"PublishAsync: channel {channel}");
            RedisChannel rChannel = new RedisChannel(channel, RedisChannel.PatternMode.Literal);
            long numCli = await _subscriber.PublishAsync(rChannel, message);
            return numCli;
        }

        /// <summary>
        /// Scrittura string su cache REDIS in modalità Async
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool Set(string key, string value, TimeSpan? expiry = null)
        {
            Log.Trace($"Set request for {key}");
            return _db.StringSet(key, value, expiry);
        }

        /// <summary>
        /// Scrittura string su cache REDIS in modalità Async
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<bool> SetAsync(string key, string value, TimeSpan? expiry = null)
        {
            Log.Trace($"SetAsync request for {key}");
            return await _db.StringSetAsync(key, value, expiry);
        }

        /// <summary>
        /// Sottoscrizione canale REDIS + handler esecuzione
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="handler"></param>
        public void Subscribe(string channel, Action<RedisChannel, RedisValue> handler)
        {
            Log.Trace($"Subscribed to channel {channel}");
            RedisChannel rChannel = new RedisChannel(channel, RedisChannel.PatternMode.Literal);
            _subscriber.Subscribe(rChannel, handler);
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// conf speciale serializzatore  JSON
        /// </summary>
        protected JsonSerializerSettings? JSSettings;

        #endregion Protected Fields

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private readonly IConnectionMultiplexer _connection;
        private readonly IDatabase _db;
        private readonly ISubscriber _subscriber;

        #endregion Private Fields
    }
}