mapo-core/MP.Data/Services/MonDataFeeder.cs

using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Threading.Tasks;

namespace MP.Data.Services
{
    public class MonDataFeeder : StatusData
    {
        #region Public Constructors

        public MonDataFeeder(IConfiguration configuration, IConnectionMultiplexer redConn) : base(configuration, redConn)
        {
            // setup canali pub/sub
            dataPipe = new MessagePipe(redisConn, Constants.MON_ACT_MSE_DATA_KEY);
            blinkPipe = new MessagePipe(redisConn, Constants.MON_ACT_BLINK_KEY);

            // avvio timers...
            startTimers();
        }

        #endregion Public Constructors

        #region Public Properties

        public MessagePipe blinkPipe { get; set; } = null!;

        public MessagePipe dataPipe { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Impostazione forzata timer refresh
        /// </summary>
        /// <param name="FastTimerMs"></param>
        public void setTimers(int FastTimerMs)
        {
            stopTimers();
            fastRefreshMs = FastTimerMs;
            // avvio timers...
            startTimers();
        }

        public void startTimers()
        {
            fastTimer = new System.Timers.Timer(fastRefreshMs);
            fastTimer.Elapsed += ElapsedFastTimer;
            fastTimer.Enabled = true;
            fastTimer.Start();
        }

        public void stopTimers()
        {
            // stop timers
            if (fastTimer != null)
            {
                fastTimer.Elapsed -= ElapsedFastTimer;
                fastTimer.Enabled = false;
                fastTimer.Stop();
                fastTimer.Dispose();
            }
        }

        #endregion Public Methods

        #region Protected Methods

        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // Free managed resources here
                    stopTimers();
                    dataPipe = null;
                    blinkPipe = null;
                }

                // Free unmanaged resources here
                _disposed = true;
            }

            // Call base class implementation.
            base.Dispose(disposing);
        }

        #endregion Protected Methods

        #region Private Fields

        private static System.Timers.Timer fastTimer = new System.Timers.Timer(4000);
        private static Logger Log = LogManager.GetCurrentClassLogger();
        private bool _disposed = false;
        private int fastRefreshMs = 1000;

        #endregion Private Fields

        #region Private Methods

        private void ElapsedFastTimer(object? source, System.Timers.ElapsedEventArgs e)
        {
            var pUpd = Task.Run(async () =>
            {
                // secondi pari --> blink, secondi dispari --> ricarica
                DateTime adesso = DateTime.Now;
                int resto = 0;
                Math.DivRem(adesso.Second, 2, out resto);
                if (resto == 0)
                {
                    // invio in channel blink il segnale
                    blinkPipe.sendMessage("true");
                    Log.Debug("Elapsed Fast Timer Blink");
                }
                else
                {
                    // invio in channel blink segnale false
                    blinkPipe.sendMessage("false");
                    // rileggo dati...
                    var newData = await MseGetAll();
                    // invio tramite la pipe...
                    dataPipe.sendMessage(JsonConvert.SerializeObject(newData));
                    Log.Debug("Elapsed Fast Timer reload");
                }
            });
            pUpd.Wait();
        }

        #endregion Private Methods
    }
}