Mapo-IOB-WIN/IOB-UT-NEXT/DataQueue.cs

using StackExchange.Redis;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;

namespace IOB_UT_NEXT
{
    /// <summary>
    /// Classe gestione code, a seconda della conf come LIST redis o come concurrent queue in memoria
    /// </summary>
    public class DataQueue
    {
        #region Public Constructors

        public DataQueue(string codIOB, string qName, bool useRedis)
        {
            UseRedis = useRedis;
            CodIOB = codIOB;
            QueueName = qName;
            //redisMan = new RedisIobCache();
            KeyName = redisMan.redHash($"IOB:QUEUE:{CodIOB}:{QueueName}");
        }

        #endregion Public Constructors

        #region Public Methods

        public int Count
        {
            get
            {
                int answ = 0;
                if (UseRedis)
                {
                    answ = (int)redisMan.redQueueCount(KeyName);
                }
                else
                {
                    answ = MemQueue.Count;
                }
                return answ;
            }
        }

        /// <summary>
        /// Accodamento elemento
        /// </summary>
        /// <param name="item"></param>
        public void Enqueue(string item)
        {
            if (UseRedis)
            {
                redisMan.redQueuePush(KeyName, item);
            }
            else
            {
                MemQueue.Enqueue(item);
            }
        }

        /// <summary>
        /// Lista string degli elementi in coda
        /// </summary>
        /// <returns></returns>
        public List<string> ToList()
        {
            List<string> answ = new List<string>();
            if (UseRedis)
            {
                // ciclo x prendere tutti...
                while (redisMan.redQueueCount(KeyName) > 0)
                {
                    answ.Add(redisMan.redQueuePop(KeyName));
                }
            }
            else
            {
                answ = MemQueue.ToList();
            }

            return answ;
        }

        /// <summary>
        /// Recupera 1 record dalla coda...
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool TryDequeue(out string result)
        {
            bool fatto = false;
            if (UseRedis)
            {
                result = redisMan.redQueuePop(KeyName);
                fatto = true;
            }
            else
            {
                fatto = MemQueue.TryDequeue(out result);
            }
            return fatto;
        }

        #endregion Public Methods

        #region Private Fields

        private string CodIOB = "NA";

        private RedisKey KeyName = "NA";

        /// <summary>
        /// Coda modalità memoria locale
        /// </summary>
        private ConcurrentQueue<string> MemQueue = new ConcurrentQueue<string>();

        private string QueueName = "NA";

        /// <summary>
        /// Indica se usare redis come datastore vs memoria
        /// </summary>
        private bool UseRedis = false;

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Oggetto connessione REDIS
        /// </summary>
        private RedisIobCache redisMan { get; set; } = new RedisIobCache();

        #endregion Private Properties
    }
}