using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Web;

namespace SteamWare
{
  /// <summary>
  /// layer gestione vari tipi di memoria: cache, session...
  /// </summary>
  public class memLayer
  {
    #region oggetti protected utilizzati

    /// <summary>
    /// lettore file configurazione
    /// </summary>
    protected AppSettingsReader configAppSetReader;

    #endregion                                  

    /// <summary>
    /// Table adapter accesso conf parameters
    /// </summary>
    public DS_UtilityTableAdapters.ConfigTableAdapter taConfig;

    /// <summary>
    /// Table adapter accesso conf parameters TMP (x import/check)
    /// </summary>
    public DS_UtilityTableAdapters.ConfigTmpTableAdapter taConfigTmp;

    /// <summary>
    /// oggetto singleton x accesso al layer di memoria
    /// </summary>
    public static memLayer ML = new memLayer();
    /// <summary>
    /// Verifica se si debba serializzare ogni valore complesso (tabelle/righe) in sessione (per impiego di sessioni avanzate come Redis)
    /// </summary>
    public bool serializeSession
    {
      get
      {
        return CRB("serializeSession");
      }
    }

    /// <summary>
    /// classe gestione accessi a Session, cache, viewstate, configuration...
    /// </summary>
    protected memLayer()
    {
      // istanzia il conf setting reader...
      configAppSetReader = new AppSettingsReader();
      // avvio e configuro TA
      initTA();
      setupConnectionStringBase();
    }

    /// <summary>
    /// init dei table adapters
    /// </summary>
    protected void initTA()
    {
      taConfig = new DS_UtilityTableAdapters.ConfigTableAdapter();
      taConfigTmp = new DS_UtilityTableAdapters.ConfigTmpTableAdapter();
    }
    /// <summary>
    /// stringa conn x DB CONF
    /// </summary>
    protected string connStringDbConf
    {
      get
      {
        string answ = "";
        answ = confReadString("DbConfConnectionString");
        // se fosse vuota fallback a path dei permessi...
        if (answ == "")
        {
          answ = confReadString("PermessiConnectionString");
        }
        // se ancora vuota --> devAuth
        if (answ == "")
        {
          answ = confReadString("DevicesAuthConnectionString");
        }
        return answ;
      }
    }

    /// <summary>
    /// effettua setup dei connection strings da web.config delal singola applicazione
    /// </summary>
    protected virtual void setupConnectionStringBase()
    {
      // connections del db                                        
      taConfig.Connection.ConnectionString = connStringDbConf;
      taConfigTmp.Connection.ConnectionString = connStringDbConf;
    }

    #region area gestione config su DB

    /// <summary>
    /// Nome della variabile AppConf da utilizzare...
    /// </summary>
    public string ACBH
    {
      get
      {
        string answ = "AppConf";
        try
        {
          answ = string.Format("{0}:{1}:{2}:AppConf", confReadString("CodModulo"), taConfig.Connection.DataSource, taConfig.Connection.Database).Replace("\\", "_");
        }
        catch
        { }
        return answ;
      }
    }

    /// <summary>
    /// oggetto dizionario con chiave / valore x configurazioni applicazione
    /// </summary>
    public Dictionary<string, string> AppConf;
    /// <summary>
    /// resetta AppConfig svuotando e rileggendo i dati...
    /// </summary>
    public void resetAppConf()
    {
      redFlushKey(ACBH);
      startupAppConf();
    }
    /// <summary>
    /// avvio oggetto AppConf in ram
    /// </summary>
    protected void startupAppConf()
    {
      // SOLO SE ho la chiave x abilitare config su DB...
      if (confReadString("DbConfConnectionString") != "")
      {
        try
        {
          if (redHashPresent(ACBH))
          {
            AppConf = new Dictionary<string, string>();
            foreach (var item in redGetHash(ACBH))
            {
              AppConf.Add(item.Key, item.Value);
            }
          }
          else
          {
            AppConf = ricaricaAppConf();
            KeyValuePair<string, string>[] valori = new KeyValuePair<string, string>[AppConf.Count];
            int i = 0;
            foreach (var item in AppConf)
            {
              valori[i] = new KeyValuePair<string, string>(item.Key, item.Value);
              i++;
            }
            redSaveHash(ACBH, valori);
            lastUpdateAppConf = DateTime.Now;
          }
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Errore in startupAppConf:{0}{1}", Environment.NewLine, exc));
        }
      }
    }
    /// <summary>
    /// Numero record salvati in AppConf
    /// </summary>
    public int numRecAppConf
    {
      get
      {
        int answ = 0;
        try
        {
          answ = AppConf.Count;
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// carica in ram oggetto AppConf
    /// </summary>
    /// <returns></returns>
    protected Dictionary<string, string> ricaricaAppConf()
    {
      Dictionary<string, string> answ = new Dictionary<string, string>();
      foreach (DS_Utility.ConfigRow riga in taConfig.GetData())
      {
        answ.Add(riga.chiave, riga.valore);
      }
      return answ;
    }
    /// <summary>
    /// ultimo update in cache dei valori di AppConfig
    /// </summary>
    public DateTime lastUpdateAppConf
    {
      get
      {
        DateTime answ = DateTime.Now.AddDays(-1);
        try
        {
          answ = Convert.ToDateTime(objCacheObj("lastUpdateAppConf"));
        }
        catch { }
        return answ;
      }
      set
      {
        setCacheVal("lastUpdateAppConf", value, true);
      }

    }
    /// <summary>
    /// Configurations da tabella DB Config
    /// </summary>
    /// <param name="chiave">Valore chiave</param>
    /// <returns></returns>
    public string configDbVal(string chiave)
    {
      string answ = "";
      if (confReadString("DbConfConnectionString") != "")
      {
        // verifico esista oggetto...
        if (AppConf == null)
        {
          resetAppConf();
        }
        if (AppConf != null)
        {
          // controllo se ho dati (sennò rileggo)
          if (AppConf.Count == 0)
          {
            resetAppConf();
          }
          // default 5 minuti x refresh...
          int maxAge = 5;
          try
          {
            maxAge = confReadInt("maxAgeAppConf_min");
          }
          catch
          { }
          // controllo SE è passato più di 5 minuti, nel caso faccio refresh...
          if (DateTime.Now.Subtract(lastUpdateAppConf).TotalMinutes > maxAge)
          {
            resetAppConf();
          }
          // provo a leggere da DICT
          try
          {
            answ = AppConf[chiave];
          }
          catch
          { }
        }
      }
      return answ;
    }
    /// <summary>
    /// Configurations da tabella DB Config (short form wrapper)
    /// </summary>
    /// <param name="chiave">Valore chiave</param>
    /// <returns></returns>
    public string cdv(string chiave)
    {
      return configDbVal(chiave);
    }
    /// <summary>
    /// Configurations da tabella DB Config (short form wrapper) convertito a bOOL
    /// </summary>
    /// <param name="chiave">Valore chiave</param>
    /// <returns></returns>
    public bool cdvb(string chiave)
    {
      bool answ = false;
      try
      {
        answ = Convert.ToBoolean(configDbVal(chiave));
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Configurations da tabella DB Config (short form wrapper) convertito a INT
    /// </summary>
    /// <param name="chiave">Valore chiave</param>
    /// <returns></returns>
    public int cdvi(string chiave)
    {
      int answ = -1;
      try
      {
        answ = Convert.ToInt32(configDbVal(chiave));
      }
      catch
      { }
      return answ;
    }

    #endregion

    #region utility gestione conf settings

    /// <summary>
    /// shot-form di confReadBool: legge dalla config un valore bool
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public bool CRB(string nomeParam)
    {
      bool answ = false;
      // PROVO IN PRIMIS a cercare su DB...
      if (cdv(nomeParam) != "")
      {
        answ = cdvb(nomeParam);
      }
      else
      {
        answ = confReadBool(nomeParam);
      }
      return answ;
    }
    /// <summary>
    /// legge dalla config un valore bool
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public bool confReadBool(string nomeParam)
    {
      bool answ = false;
      try
      {
        answ = (bool)configAppSetReader.GetValue(nomeParam, typeof(bool));
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// shot-form di confReadString: legge dalla config un valore string
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public string CRS(string nomeParam)
    {
      string answ = "";
      // PROVO IN PRIMIS a cercare su DB...
      answ = cdv(nomeParam);
      if (answ == "")
      {
        answ = confReadString(nomeParam);
      }
      return answ;
    }
    /// <summary>
    /// legge dalla config un valore string
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public string confReadString(string nomeParam)
    {
      string answ = "";
      try
      {
        answ = (string)configAppSetReader.GetValue(nomeParam, typeof(string));
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// shot-form di confReadInt: legge dalla config un valore int
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public int CRI(string nomeParam)
    {
      int answ = -1;
      // PROVO IN PRIMIS a cercare su DB...
      answ = cdvi(nomeParam);
      // se non trovato...
      if (answ < 0)
      {
        answ = confReadInt(nomeParam);
      }
      return answ;
    }
    /// <summary>
    /// legge dalla config un valore int
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public int confReadInt(string nomeParam)
    {
      int answ = -1;
      try
      {
        answ = (int)configAppSetReader.GetValue(nomeParam, typeof(int));
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// shot-form di confReadDouble: legge dalla config un valore double
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public double CRD(string nomeParam)
    {
      double answ = -1;
      // PROVO IN PRIMIS a cercare su DB...
      try
      {
        answ = Convert.ToDouble(cdv(nomeParam));
      }
      catch
      { }
      // se non trovato...
      if (answ < 0)
      {
        answ = confReadDouble(nomeParam);
      }
      return answ;
    }
    /// <summary>
    /// legge dalla config un valore int
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public double confReadDouble(string nomeParam)
    {
      double answ = -1;
      try
      {
        answ = Convert.ToDouble(configAppSetReader.GetValue(nomeParam, typeof(double)));
      }
      catch
      { }
      return answ;
    }


    #endregion

    #region utility gestione querystring, cookie, session e cache

    #region querystring

    /// <summary>
    /// recupera valore querystring STRING
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore string</returns>
    public string QSS(string nome)
    {
      string answ = "";
      try
      {
        answ = HttpContext.Current.Request.QueryString[nome].ToString().Trim();
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring INT
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore INT</returns>
    public int QSI(string nome)
    {
      int answ = 0;
      try
      {
        answ = Convert.ToInt32(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring BOOL
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore string</returns>
    public bool QSB(string nome)
    {
      bool answ = false;
      try
      {
        answ = Convert.ToBoolean(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring DATE
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore DATE</returns>
    public DateTime QSD(string nome)
    {
      DateTime answ = DateTime.Now;
      try
      {
        answ = Convert.ToDateTime(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }

    #endregion

    #region session

    /// <summary>
    /// carica dalla sessione un dato di tipo DataSet NON Tipizzato
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public DataSet dsSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        string valSer = ML.StringSessionObj(nomeVar);
        DataSet dataSet = JsonConvert.DeserializeObject<DataSet>(valSer);
        return dataSet;
      }
      else
      {
        return null;
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo object generico
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public object objSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return HttpContext.Current.Session[nomeVar];
      }
      else
      {
        return "";
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo boolean (se vuoto false)
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool BoolSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return (bool)HttpContext.Current.Session[nomeVar];
      }
      else
      {
        return false;
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo string
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public string StringSessionObj(string nomeVar)
    {
      string answ = "";
      try
      {
        if (HttpContext.Current.Session[nomeVar] != null)
        {
          answ = HttpContext.Current.Session[nomeVar].ToString();
        }
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo DateTime
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public DateTime DateTimeSessionObj(string nomeVar)
    {
      DateTime answ = DateTime.Now;
      // se li ho in sessione ricarico valori...
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        try
        {
          answ = Convert.ToDateTime(memLayer.ML.objSessionObj(nomeVar));
        }
        catch
        {
          answ = DateTime.Now;
        }
      }
      return answ;
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo long
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public long LongSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
      }
      else
      {
        return 0;
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo int
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public int IntSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
      }
      else
      {
        return -1;
      }
    }

    /// <summary>
    /// inserisce in session un valore
    /// </summary>
    /// <param name="nome"></param>
    /// <param name="valore"></param>
    public bool setSessionVal(string nome, object valore)
    {
      bool _done = false;
      try
      {
        HttpContext.Current.Session[nome] = valore;
        _done = true;
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// inserisce in session un valore
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="valore">valore associato</param>
    /// <param name="surviveUpdate">indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)</param>
    /// <returns></returns>
    public bool setSessionVal(string nome, object valore, bool surviveUpdate)
    {
      bool _done = false;
      try
      {
        HttpContext.Current.Session[nome] = valore;
        if (surviveUpdate)
        {
          addValInSession(nome, valore.ToString());
        }
        _done = true;
      }
      catch
      { }
      return _done;
    }

    /// <summary>
    /// inserisce in session un DataSet (serializzandolo)
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="dTable">DataTable da salvare</param>
    public bool setSessionDataTable(string nome, DataTable dTable)
    {
      bool _done = false;
      try
      {
        DataSet dataSet = new DataSet("dataSet");
        dataSet.Tables.Add(dTable);
        string dataSer = JsonConvert.SerializeObject(dataSet);
        _done = setSessionVal(nome, dataSer);
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// inserisce in session un DataSet (serializzandolo)
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="dTable">DataTable da salvare</param>
    /// <param name="surviveUpdate">indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)</param>
    public bool setSessionDataTable(string nome, DataTable dTable, bool surviveUpdate)
    {
      bool _done = false;
      try
      {
        DataSet dataSet = new DataSet("dataSet");
        dataSet.Tables.Add(dTable);
        string dataSer = JsonConvert.SerializeObject(dataSet);
        _done = setSessionVal(nome, dataSer, surviveUpdate);
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// inserisce in session un DataSet (serializzandolo)
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="dSet">DataSet da salvare</param>
    public bool setSessionDataSet(string nome, DataSet dSet)
    {
      bool _done = false;
      try
      {
        string dataSer = JsonConvert.SerializeObject(dSet);
        _done = setSessionVal(nome, dataSer);
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// inserisce in session un DataSet (serializzandolo)
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="dSet">DataSet da salvare</param>
    /// <param name="surviveUpdate">indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)</param>
    /// <returns></returns>
    public bool setSessionDataSet(string nome, DataSet dSet, bool surviveUpdate)
    {
      bool _done = false;
      try
      {
        string dataSer = JsonConvert.SerializeObject(dSet);
        _done = setSessionVal(nome, dataSer, surviveUpdate);
      }
      catch
      { }
      return _done;
    }

    /// <summary>
    /// svuota una variabile dalla session
    /// </summary>
    /// <param name="nome"></param>
    public bool emptySessionVal(string nome)
    {
      bool _done = false;
      try
      {
        HttpContext.Current.Session.Remove(nome);
        _done = true;
      }
      catch
      { }
      return _done;
    }

    /// <summary>
    /// restituisce true se è presente in session l'oggetto richiesto
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool isInSessionObject(string nomeVar)
    {
      bool answ = false;
      bool stringAnsw = false;
      // cerco se ci sia...
      try
      {
        //stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
        stringAnsw = HttpContext.Current.Session[nomeVar] != null;
      }
      catch
      { }
      // infine condizione doppia...
      try
      {
        answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
      }
      catch
      { }
      return answ;
    }

    #endregion

    #region cookie


    /// <summary>
    /// restituisco se ci sia un dato cookie
    /// </summary>
    /// <param name="nome"></param>
    /// <returns></returns>
    public bool hasCookieVal(string nome)
    {
      bool answ = false;
      try
      {
        answ = HttpContext.Current.Request.Cookies[nome].Value != "";
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// restituisco un valore da cookie
    /// </summary>
    /// <param name="nome"></param>
    /// <returns></returns>
    public string getCookieVal(string nome)
    {
      string answ = "";
      try
      {
        answ = HttpContext.Current.Request.Cookies[nome].Value;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// salvo un valore come cookie
    /// </summary>
    /// <param name="nome"></param>
    /// <param name="valore"></param>
    /// <returns></returns>
    public bool setCookieVal(string nome, string valore)
    {
      bool _done = false;
      try
      {
        HttpCookie newCookie = new HttpCookie(nome, valore);
        HttpContext.Current.Response.AppendCookie(newCookie);
        _done = true;
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// salvo un valore come cookie con expiry date esplicita
    /// </summary>
    /// <param name="nome"></param>
    /// <param name="valore"></param>
    /// <param name="expiryDate"></param>
    /// <returns></returns>
    public bool setCookieVal(string nome, string valore, DateTime expiryDate)
    {
      bool _done = false;
      try
      {
        // rimuovo vecchio cookie
        emptyCookieVal(nome);
        // creo nuovo cookie
        HttpCookie newCookie = new HttpCookie(nome, valore);
        newCookie.Expires = expiryDate;
        HttpContext.Current.Response.AppendCookie(newCookie);
        _done = true;
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// elimina un cookie
    /// </summary>
    /// <param name="nome"></param>
    public bool emptyCookieVal(string nome)
    {
      bool _done = false;
      HttpCookie aCookie;
      try
      {
        aCookie = new HttpCookie(nome);
        aCookie.Expires = DateTime.Now.AddDays(-1);
        HttpContext.Current.Response.Cookies.Add(aCookie);
        _done = true;
      }
      catch
      { }
      return _done;
    }

    #endregion

    #region cache

    /// <summary>
    /// Indica se usare la cache su REDIS (true) oppure cache applicativo IIS (false)
    /// </summary>
    protected bool cacheOnRedis
    {
      get
      {
        bool answ = confReadBool("cacheOnRedis");
        return answ;
      }
    }
    /// <summary>
    /// carica dalla Cache un dato di tipo object generico
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public object objCacheObj(string nomeVar)
    {
      object answ = null;
      // ...se uso redis...
      if (cacheOnRedis)
      {
        answ = JsonConvert.DeserializeObject(getRSV(redHash(nomeVar)));
      }
      else
      {
        if (HttpContext.Current.Cache[nomeVar] != null)
        {
          answ = HttpContext.Current.Cache[nomeVar];
        }
        else
        {
          answ = "";
        }
      }
      return answ;
    }
    /// <summary>
    /// carica dalla Cachee un dato di tipo boolean (se vuoto false)
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool BoolCacheObj(string nomeVar)
    {
      bool answ = false;
      // ...se uso redis...
      if (cacheOnRedis)
      {
        string redVal = JsonConvert.DeserializeObject(getRSV(redHash(nomeVar))).ToString();
        bool.TryParse(redVal, out answ);
      }
      else
      {
        if (HttpContext.Current.Cache[nomeVar] != null)
        {
          answ = (bool)HttpContext.Current.Cache[nomeVar];
        }
        else
        {
          answ = false;
        }
      }
      return answ;
    }
    /// <summary>
    /// carica dalla Cachee un dato di tipo string
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public string StringCacheObj(string nomeVar)
    {
      string answ = "";
      // ...se uso redis...
      if (cacheOnRedis)
      {
        answ = JsonConvert.DeserializeObject(getRSV(redHash(nomeVar))).ToString();
      }
      else
      {
        if (HttpContext.Current.Cache[nomeVar] != null)
        {
          answ = HttpContext.Current.Cache[nomeVar].ToString();
        }
        else
        {
          answ = "";
        }
      }
      return answ;
    }
    /// <summary>
    /// inserisce in Cache un valore
    /// </summary>
    /// <param name="nomeVar">nome della variabile</param>
    /// <param name="valore">valore</param>
    public bool setCacheVal(string nomeVar, object valore)
    {
      bool _done = false;
      if (cacheOnRedis)
      {
        // serializzo
        string serVal = JsonConvert.SerializeObject(valore);
        setRSV(redHash(nomeVar), serVal);
        _done = true;
      }
      else
      {
        try
        {
          HttpContext.Current.Cache[nomeVar] = valore;
          _done = true;
        }
        catch
        { }
      }
      return _done;
    }
    /// <summary>
    /// inserisce in Cache un valore e su richiesta regitra tra le tab in cache da svuotare on update..
    /// </summary>
    /// <param name="nome">nome della variabile</param>
    /// <param name="valore">valore</param>
    /// <param name="setInTabInCache">da registrare come tabella da svuotare on update</param>
    /// <returns></returns>
    public bool setCacheVal(string nome, object valore, bool setInTabInCache)
    {
      bool _done = setCacheVal(nome, valore);
      if (setInTabInCache)
      {
        addTabInCache(nome);
      }
      return _done;
    }
    /// <summary>
    /// svuota una variabile dalla Cache
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <param name="nome"></param>
    public bool emptyCacheVal(string nomeVar)
    {
      bool _done = false;
      if (cacheOnRedis)
      {
        redDelKey(redHash(nomeVar));
      }
      else
      {
        try
        {
          HttpContext.Current.Cache.Remove(nomeVar);
          _done = true;
        }
        catch
        { }
      }
      return _done;
    }

    /// <summary>
    /// restituisce true se è presente in cache l'oggetto richiesto
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool isInCacheObject(string nomeVar)
    {
      bool answ = false;
      bool stringAnsw = false;
      if (cacheOnRedis)
      {
        answ = redHashPresent(redHash(nomeVar));
      }
      else
      {
        // cerco di fare cast a stringa...
        try
        {
          stringAnsw = HttpContext.Current.Cache[nomeVar].ToString() != "";
        }
        catch
        { }
        // infine condizione doppia...
        try
        {
          answ = (HttpContext.Current.Cache[nomeVar] != null && stringAnsw);
        }
        catch
        { }
      }
      return answ;
    }
    /// <summary>
    /// elenco dictionary delle tab in cache da aggiornare con update svuotando da cache...
    /// </summary>
    public Dictionary<string, string> tabelleInCache
    {
      get
      {
        try
        {
          return (Dictionary<string, string>)objCacheObj("tabelleInCache");
        }
        catch
        {
          return new Dictionary<string, string>();
        }
      }
      set
      {
        setCacheVal("tabelleInCache", value);
      }
    }
    /// <summary>
    /// aggiunge la stringa corrente nel dictionary delle tabelle messe in cache e da aggiornare su comando update
    /// </summary>
    /// <param name="nuovaTab"></param>
    public void addTabInCache(string nuovaTab)
    {
      // provo ad aggiungere nuova tab  in elenco...
      Dictionary<string, string> _tabelleInCache = tabelleInCache;
      try
      {
        _tabelleInCache.Add(nuovaTab, nuovaTab);
        tabelleInCache = _tabelleInCache;
      }
      catch
      { }
    }

    /// <summary>
    /// elenco dictionary dei valori in session da NON aggiornare con update...
    /// </summary>
    public Dictionary<string, string> valSess2SurvUpd
    {
      get
      {
        try
        {
          return (Dictionary<string, string>)objSessionObj("valoriInSession2Survive");
        }
        catch
        {
          return new Dictionary<string, string>();
        }
      }
      set
      {
        setSessionVal("valoriInSession2Survive", value);
      }
    }
    /// <summary>
    /// aggiunge la stringa corrente nel dictionary delle tabelle messe in session che vanno preservate da comando update (es: oggetto selezionato...)
    /// </summary>
    /// <param name="nomePar"></param>
    /// <param name="valore"></param>
    public void addValInSession(string nomePar, string valore)
    {
      // provo ad aggiungere nuova tab  in elenco...
      Dictionary<string, string> _valoriInSession2Survive = valSess2SurvUpd;
      // verifico se fare update o insert...
      if (_valoriInSession2Survive.ContainsKey(nomePar))
      {
        // update, rimuovo vecchio valore...
        try
        {
          _valoriInSession2Survive.Remove(nomePar);
        }
        catch
        { }
      }
      // insert
      try
      {
        _valoriInSession2Survive.Add(nomePar, valore);
        valSess2SurvUpd = _valoriInSession2Survive;
      }
      catch
      { }
    }
    /// <summary>
    /// forza lo svuotamento delle tabelle indicate come in cache...
    /// </summary>
    public void flushRegisteredCache()
    {
      // elimino tutte le tab nella pos tabInCache...
      foreach (KeyValuePair<string, string> kvp in tabelleInCache)
      {
        if (cacheOnRedis)
        {
          redDelKey(redHash(kvp.Value));
        }
        else
        {
          HttpContext.Current.Cache.Remove(kvp.Value);
        }
      }
      if (cacheOnRedis)
      {
        redDelKey(redHash("tabelleInCache"));
      }
      else
      {
        HttpContext.Current.Cache.Remove("tabelleInCache");
      }
    }

    #endregion

    #endregion

    #region gestione valori in RedisCache

    /// <summary>
    /// Nome della variabile HASH da utilizzare (dato CodModulo / Server / DB impiegato da funzionalita' DbConfig) + keyName richiesto...
    /// </summary>
    public string redHash(string keyName)
    {
      string answ = keyName;
      try
      {
        answ = string.Format("{0}:{1}:{2}:{3}", confReadString("CodModulo"), taConfig.Connection.DataSource, taConfig.Connection.Database, keyName).Replace("\\", "_");
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// Connessione lazy a redis...
    /// </summary>
    private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
    {
      return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false");
    });
    /// <summary>
    /// Connessione lazy a redis...
    /// </summary>
    private static Lazy<ConnectionMultiplexer> lazyConnectionAdmin = new Lazy<ConnectionMultiplexer>(() =>
    {
      return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false,allowAdmin=true");
    });
    /// <summary>
    /// Oggetto statico connessione redis
    /// </summary>
    public static ConnectionMultiplexer connRedis
    {
      get
      {
        return lazyConnection.Value;
      }
    }
    /// <summary>
    /// Oggetto statico connessione redis
    /// </summary>
    public static ConnectionMultiplexer connRedisAdmin
    {
      get
      {
        return lazyConnectionAdmin.Value;
      }
    }
    /// <summary>
    /// Restituisce info dei server connessi...
    /// </summary>
    /// <returns></returns>
    public IServer[] redServInfo()
    {
      IServer[] answ = new IServer[1];
      try
      {
        answ = new IServer[connRedisAdmin.GetEndPoints().Length];
        int i = 0;
        foreach (var ep in connRedisAdmin.GetEndPoints())
        {
          var server = connRedisAdmin.GetServer(ep);
          answ[i] = server;
          i++;
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
      }
      return answ;
    }

    /// <summary>
    /// Restituisce una chiave salvata in RedisCache
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public string getRSV(string chiave)
    {
      string answ = "";
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.StringGet(chiave);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Salva una chiave in RedisCache
    /// </summary>
    /// <param name="chiave"></param>
    /// <param name="valore"></param>
    /// <returns></returns>
    public bool setRSV(string chiave, string valore)
    {
      bool answ = false;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        cache.StringSet(chiave, valore);
        answ = true;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Salva una chiave in RedisCache
    /// </summary>
    /// <param name="chiave"></param>
    /// <param name="valore"></param>
    /// <param name="TTL_sec">in secondi</param>
    /// <returns></returns>
    public bool setRSV(string chiave, string valore, int TTL_sec)
    {
      bool answ = false;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
        // salvo con expyry...
        cache.StringSet(chiave, valore, expT);
        answ = true;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Incrementa un contatore in Redis
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public long setRCntI(string chiave)
    {
      long answ = 0;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.StringIncrement(chiave, 1);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in setRCI:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Decrementa un contatore in Redis
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public long setRCntD(string chiave)
    {
      long answ = 0;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.StringDecrement(chiave, 1);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in setRCD:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Restituisce una chiave COUNTER in RedisCache
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public int getRCnt(string chiave)
    {
      int answInt = 0;
      string answ = "";
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.StringGet(chiave);
        answInt = Convert.ToInt32(answ);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
      }
      return answInt;
    }
    /// <summary>
    /// Resetta (elimina) un contatore in Redis
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public bool resetRCnt(string chiave)
    {
      bool answ = false;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.KeyDelete(chiave);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in resetRCnt:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Restituisce un set KVP (Key Value Pair) salvati in RedisCache
    /// </summary>
    /// <param name="chiavi"></param>
    /// <returns></returns>
    public RedisValue[] getRKeys(RedisKey[] chiavi)
    {
      RedisValue[] answ = null;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        answ = cache.StringGet(chiavi);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in getRKeys:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Salva  un set KVP (Key Value Pair) in RedisCache
    /// </summary>
    /// <param name="valori">Set KVP chiave-valore da salvare</param>
    /// <returns></returns>
    public bool setRKeys(KeyValuePair<RedisKey, RedisValue>[] valori)
    {
      bool answ = false;
      try
      {
        IDatabase cache = connRedis.GetDatabase();
        cache.StringSet(valori);
        answ = true;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in setRKeys:{0}{1}", Environment.NewLine, exc));
      }
      return answ;
    }
    /// <summary>
    /// Verifica se ci siano valori nella hash indicata...
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public bool redHashPresent(RedisKey key)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        answ = cache.HashGetAll(key).Length > 0;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Verifica se ci siano valori nella hash indicata (string)
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public bool redHashPresentSz(string key)
    {
      bool answ = false;
      try
      {
        RedisKey chiave = key;
        answ = redHashPresent(chiave);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Recupera tutti i valori dalla hash
    /// </summary>
    /// <param name="hashKey"></param>
    /// <returns></returns>
    public KeyValuePair<string, string>[] redGetHash(string hashKey)
    {
      KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        HashEntry[] valori = cache.HashGetAll(chiave);
        answ = new KeyValuePair<string, string>[valori.Length];
        int i = 0;
        foreach (HashEntry item in valori)
        {
          answ[i] = new KeyValuePair<string, string>(item.Name, item.Value);
          i++;
        }
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Recupera tutti i valori dalla hash in formato Dictionary
    /// </summary>
    /// <param name="hashKey"></param>
    /// <returns></returns>
    public Dictionary<string, string> redGetHashDict(string hashKey)
    {
      Dictionary<string, string> answ = new Dictionary<string, string>();
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        HashEntry[] valori = cache.HashGetAll(chiave);
        foreach (HashEntry item in valori)
        {
          answ.Add(item.Name, item.Value);
        }
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Recupera UN SINGOLO VALORE dalla hash per un dato field
    /// </summary>
    /// <param name="hashKey"></param>
    /// <param name="hashField"></param>
    /// <returns></returns>
    public string redGetHashField(string hashKey, string hashField)
    {
      string answ = "";
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        RedisValue campo = hashField;
        RedisValue valOut = cache.HashGet(chiave, campo);
        answ = valOut.ToString();
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Salvataggio di una hash di valori
    /// </summary> 
    /// <param name="hashKey">chiave</param>
    /// <param name="hashFields">valori</param>
    /// <returns></returns>
    public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        HashEntry[] valori = new HashEntry[hashFields.Length];
        int i = 0;
        foreach (KeyValuePair<string, string> kvp in hashFields)
        {
          valori[i] = new HashEntry(kvp.Key, kvp.Value);
          i++;
        }
        cache.HashSet(chiave, valori);
        answ = true;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Salvataggio di una hash di valori in formato Dictionary
    /// </summary> 
    /// <param name="hashKey">chiave</param>
    /// <param name="hashFields">valori</param>
    /// <returns></returns>
    public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        HashEntry[] valori = new HashEntry[hashFields.Count];
        int i = 0;
        foreach (KeyValuePair<string, string> kvp in hashFields)
        {
          valori[i] = new HashEntry(kvp.Key, kvp.Value);
          i++;
        }
        cache.HashSet(chiave, valori);
        answ = true;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Salvataggio di una hash di valori
    /// </summary> 
    /// <param name="hashKey">chiave</param>
    /// <param name="hashFields">valori</param>
    /// <param name="expireSeconds">scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)</param>
    /// <returns></returns>
    public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields, double expireSeconds = -1)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        answ = redSaveHash(hashKey, hashFields);
        if (expireSeconds > 0)
        {
          cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
        }
        //answ = true;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Salvataggio di una hash di valori in formato Dictionary
    /// </summary> 
    /// <param name="hashKey">chiave</param>
    /// <param name="hashFields">valori</param>
    /// <param name="expireSeconds">scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)</param>
    /// <returns></returns>
    public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields, double expireSeconds = -1)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = hashKey;
        answ = redSaveHashDict(hashKey, hashFields);
        if (expireSeconds > 0)
        {
          cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
        }
        //answ = true;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Elimina una key (hash, string)
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public bool redDelKey(string key)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      try
      {
        RedisKey chiave = key;
        cache.KeyDelete(chiave);
        answ = true;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Flush completo cache redis
    /// </summary>
    /// <param name="keyPattern">** = tutti</param>
    /// <returns></returns>
    public bool redFlushKey(string keyPattern)
    {
      bool answ = false;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      // se vuoto = ALL...
      keyPattern = keyPattern == "" ? "**" : keyPattern;
      try
      {
        foreach (var ep in connRedis.GetEndPoints())
        {
          var server = connRedis.GetServer(ep);
          foreach (var key in server.Keys(pattern: keyPattern))
          {
            cache.KeyDelete(key);
          }
        }
        answ = true;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
      }
      return answ;
    }
    /// <summary>
    /// Conta num oggetti cache redis che rispondono a pattern
    /// </summary>
    /// <param name="keyPattern">** = tutti</param>
    /// <returns></returns>
    public int redCountKey(string keyPattern)
    {
      int answ = 0;
      // cerco se ci sia valore in redis...
      IDatabase cache = connRedis.GetDatabase();
      // se vuoto = ALL...
      keyPattern = keyPattern == "" ? "**" : keyPattern;
      try
      {
        foreach (var ep in connRedis.GetEndPoints())
        {
          var server = connRedis.GetServer(ep);
          foreach (var key in server.Keys(pattern: keyPattern))
          {
            answ++;
          }
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
      }
      return answ;
    }

    /// <summary>
    /// Restituisce numero record in Redis DB
    /// </summary>
    public long numRecRedis
    {
      get
      {
        long answ = 0;
        try
        {
          foreach (var ep in connRedis.GetEndPoints())
          {
            var server = connRedis.GetServer(ep);
            answ += server.DatabaseSize();
          }
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// Restituisce oggetti cache redis che rispondono a pattern
    /// </summary>
    /// <param name="keyPattern">** = tutti</param>
    /// <param name="orderBy">Tipo di ordinamento per kvp</param>
    /// <returns></returns>
    public List<KeyValuePair<string, int>> redGetCounterByKey(string keyPattern, kvpOrderBy orderBy)
    {
      int numAnsw = redCountKey(keyPattern);
      RedisKey[] chiavi = new RedisKey[numAnsw];
      List<KeyValuePair<string, int>> answ = new List<KeyValuePair<string, int>>();
      // se vuoto = ALL...
      keyPattern = keyPattern == "" ? "**" : keyPattern;

      // recupero in primis elenco chiavi
      try
      {
        int i = 0;
        foreach (var ep in connRedis.GetEndPoints())
        {
          var server = connRedis.GetServer(ep);
          foreach (var key in server.Keys(pattern: keyPattern))
          {
            chiavi[i] = key;
            i++;
          }
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
      }
      // ora recupero valori!
      var valori = getRKeys(chiavi);
      int currVal = 0;
      // popolo rispsota
      try
      {
        for (int i = 0; i < numAnsw; i++)
        {
          Int32.TryParse(valori[i], out currVal);
          answ.Add(new KeyValuePair<string, int>(chiavi[i], currVal));
        }
      }
      catch
      { }
      // se richiesto riordino...
      switch (orderBy)
      {
        case kvpOrderBy.KeyAsc:
          answ.Sort(CompareKey);
          break;
        case kvpOrderBy.KeyDesc:
          answ.Sort(CompareKeyDesc);
          break;
        case kvpOrderBy.ValAsc:
          answ.Sort(CompareVal);
          break;
        case kvpOrderBy.ValDesc:
          answ.Sort(CompareValDesc);
          break;
        default:
          break;
      }
      return answ;
    }
    /// <summary>
    /// Effettua comaprazione x CHIAVE in KVP ASC
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    private int CompareKey(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
      return x.Key.CompareTo(y.Key);
    }
    /// <summary>
    /// Effettua comaprazione x VALORE in KVP ASC
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    public int CompareVal(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
      return x.Value.CompareTo(y.Value);
    }
    /// <summary>
    /// Effettua comaprazione x CHIAVE in KVP DESC
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    private int CompareKeyDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
      return y.Key.CompareTo(x.Key);
    }
    /// <summary>
    /// Effettua comaprazione x VALORE in KVP DESC
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    public int CompareValDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
      return y.Value.CompareTo(x.Value);
    }

    /// <summary>
    /// Tipologia di ordinamento x liste KVP
    /// </summary>
    public enum kvpOrderBy
    {
      /// <summary>
      /// Ordinamento ASCending per KEY
      /// </summary>
      KeyAsc,
      /// <summary>
      /// Ordinamento DESCending per KEY
      /// </summary>
      KeyDesc,
      /// <summary>
      /// Ordinamento ASCending per VAL
      /// </summary>
      ValAsc,
      /// <summary>
      /// Ordinamento DESCending per VAL
      /// </summary>
      ValDesc
    }



    #endregion

    #region URL corretti immagini

    /// <summary>
    /// Formattazione stringa URL immagini con gestione "base url"
    /// </summary>
    /// <param name="urlRelPath"></param>
    /// <returns></returns>
    public static string imgUrl(string urlRelPath)
    {
      return string.Format("{0}/{1}", SteamWare.memLayer.ML.CRS("baseUrl"), urlRelPath);
    }

    #endregion

  }
}