DBQueryCache.cs

//#define PoCv2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
using System.Diagnostics;
using System.Windows.Forms;

namespace sage.ew.db
{

    public static class QueryCache
    {
        #region Variables

        private static readonly int MAX_LEGHT_TRACE = 200;

        private static List<string> _cUpdateTableWords = new List<string>() { " UPDATE ", "INSERT", "DELETE", "DROP", "TRUNCATE" };
        
        private static List<string> lisTablasSistema = new List<string>() { "[LOG_ANALISIS]", ".LOG_ANALISIS", "[CONNECT], [LOG_ERROR]" };

        private static List<string> lisIdentificadoresTablas = new List<string>() { ".DBO.", ".INFORMATION_SCHEMA.", ".SYS." };

        private static ulong TotalPeticiones = 0;
        private static ulong RespuestasDeCache = 0;
        private static ulong InsercionesEnCache = 0;
#if PoCv2
        private static int MaximoDeTablas = 0;
        private static ulong EliminacionesItemsDeCache = 0;
        private static ulong EliminacionesTablasDeCache = 0;
        private static List<string> ListaClavesFallidas = new List<string>();

        static Dictionary<string, List<string>> _IndiceTablas = new Dictionary<string, List<string>>();
        static Dictionary<string, long> _CosteConsulta = new Dictionary<string, long>();
        private static long AhorroCoste = 0;
#endif

        #endregion Variables

        public static T GetObjectFromCache<T>(string tcNomItem, int tnTiempoEnCache, Func<T> toFuncionObtencionDatos)
        {
            TotalPeticiones++;

            ObjectCache loCache = MemoryCache.Default;
            var objetoDeCache = (T)loCache[tcNomItem];
            if (objetoDeCache == null)
            {
                //Trace.WriteLineIf(Debugger.IsAttached, tcNomItem);

                CacheItemPolicy policy = new CacheItemPolicy
                {
                    AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(tnTiempoEnCache)
                };
#if PoCv2
                Stopwatch timer = new Stopwatch();
                timer.Start();
#endif
                objetoDeCache = toFuncionObtencionDatos();
#if PoCv2
                timer.Stop();
                var coste = timer.ElapsedMilliseconds;
#endif
                loCache.Set(tcNomItem, objetoDeCache, policy);

                InsercionesEnCache++;
#if PoCv2
                var tablasAfectadas = ObtenerTablasDelQuery(tcNomItem);
                tablasAfectadas.ForEach(t => RegistrarQuerys(t, tcNomItem));
                RegistrarCoste(tcNomItem, coste);
#endif
            }
            else
            {
                RespuestasDeCache++;
#if PoCv2
                AhorroCoste += ObtenerCoste(tcNomItem);
#endif
            }


            //Si se modifican datos hago saltar la cache
            ComprobarSiHayModificacionDeDatos(tcNomItem);

            return objetoDeCache;
        }

        private static bool elQueryModificaDatos(string tcQuery)
        {
            if (!string.IsNullOrWhiteSpace(tcQuery) && _cUpdateTableWords.Any(lcWord => tcQuery.ToUpper().Contains(lcWord.ToUpper())))
                return true;
            else
                return false;
        }

#if PoCv2
        private static bool elQueryModificaDatos(string tcQuery, out List<string> tablasAfectadas)
        {
            tablasAfectadas = new List<string>();
            if (elQueryModificaDatos(tcQuery))
            {
                tablasAfectadas = ObtenerTablasDelQuery(tcQuery);
                return true;
            }
            else
            {
                return false;
            }
        }

        private static List<string> ObtenerTablasDelQuery(string tcQuery)
        {
            //Los querys que modifican datos suelen afecta únicamente a una tabla pe. insert, update
            var partesDelQuery = tcQuery.ToUpper().Split(' ');

            var listaTablas = partesDelQuery.Where(p => lisIdentificadoresTablas.Any(ident => p.ToUpper().Contains(ident))).ToList();
            if (listaTablas.Count > MaximoDeTablas)
                MaximoDeTablas = listaTablas.Count;

            if (!listaTablas.Any())
                ListaClavesFallidas.Add(tcQuery);

            return listaTablas;
        }
#endif

        public static void ComprobarSiHayModificacionDeDatos(string tcQuery)
        {
#if PoCv2           //Si se modifican datos hago saltar la cache
            if (elQueryModificaDatos(tcQuery, out List<string> tablasAfectadas))
            {
                if (lisTablasSistema.Any(lcWord => tcQuery.ToUpper().Contains(lcWord.ToUpper())))
                {
                    Trace.WriteLineIf(Debugger.IsAttached, " => Evitar que el query haga saltar la cache => " + queryToTrace(tcQuery), "Cache"); //Operación de sistema
                }
                else
                {
                    tablasAfectadas.ForEach(t => BorrarQuerysCacheTabla(t));
                    Trace.WriteLineIf(Debugger.IsAttached, "Query que modifica datos => " + queryToTrace(tcQuery), "Cache");
                }
            }
#else
            //Si se modifican datos hago saltar la cache
            if (elQueryModificaDatos(tcQuery))
            {
                if (lisTablasSistema.Any(lcWord => tcQuery.ToUpper().Contains(lcWord.ToUpper())))
                    Trace.WriteLineIf(Debugger.IsAttached, " => Evitar que el query haga saltar la cache => " + queryToTrace(tcQuery), "Cache");
                else
                {
                    ResetCache();
                    Trace.WriteLineIf(Debugger.IsAttached, "Query que hace saltar la cache => " + queryToTrace(tcQuery), "Cache");
                }
            }
#endif
        }

#if PoCv2
        private static void BorrarQuerysCacheTabla(string tabla)
        {
            if (_IndiceTablas.ContainsKey(tabla))
            {
                EliminacionesTablasDeCache++;

                ObjectCache loCache = MemoryCache.Default;

                foreach (string key in _IndiceTablas[tabla])
                {
                    EliminacionesItemsDeCache++;
                    loCache.Remove(key);
                }

                Trace.WriteLineIf(Debugger.IsAttached, $"Eliminar tabla de la cache {tabla} con {_IndiceTablas[tabla].Count} items registrados", "Cache");

                _IndiceTablas[tabla].Clear();
                _IndiceTablas.Remove(tabla);
            }
        }

        private static void RegistrarQuerys(string tabla, string key)
        {
            if (_IndiceTablas.ContainsKey(tabla))
            {
                if (!_IndiceTablas[tabla].Contains(key))
                {
                    _IndiceTablas[tabla].Add(key);
                }
            }
            else
            {
                _IndiceTablas.Add(tabla, new List<string>() { key });
            }
        }

        private static void RegistrarCoste(string key, long coste)
        {
            if (_CosteConsulta.ContainsKey(key))
                _CosteConsulta[key] = coste;
            else
                _CosteConsulta.Add(key, coste);
        }

        private static long ObtenerCoste(string key)
        {
            if (_CosteConsulta.ContainsKey(key))
            {
                return _CosteConsulta[key];
            }

            return 0;
        }
#endif

        private static string queryToTrace(string tcQuery)
        {
            if (tcQuery.Length > MAX_LEGHT_TRACE)
                return tcQuery.Substring(0, MAX_LEGHT_TRACE) + "*** TRUNCADO ***";
            else
                return tcQuery;
        }

        public static bool ContaninsKey(string tcKey)
        {
            ObjectCache cache = MemoryCache.Default;
            return cache.Contains(tcKey);
        }

        internal static void VaciarCache()
        {
#if PoCv2
            EstadoDeLaCache("Vaciado final");
            _IndiceTablas.Clear();
            ReiniciarEstadisticas();
#else
            Trace.WriteLineIf(Debugger.IsAttached, "*********** Vaciado final de cache *************", "Cache");
#endif

            ObjectCache loCache = MemoryCache.Default;
            loCache.__Clear();
            GC.Collect();
        }

        internal static void ResetCache()
        {
#if PoCv2
            EstadoDeLaCache("Reset de cache");
            _IndiceTablas.Clear();
            ReiniciarEstadisticas();
#else
            Trace.WriteLineIf(Debugger.IsAttached, "*********** Reset de cache *************", "Cache");
#endif


            ObjectCache loCache = MemoryCache.Default;
            loCache.__Clear();
        }

#if PoCv2
        private static void ReiniciarEstadisticas()
        {
            TotalPeticiones = 0;
            RespuestasDeCache = 0;
            AhorroCoste = 0;
            EliminacionesTablasDeCache = 0;
            EliminacionesItemsDeCache = 0;
            InsercionesEnCache = 0;
            MaximoDeTablas = 0;
            ListaClavesFallidas.Clear();
        }

        public static void EstadoDeLaCache(string momento = "sin especificar")
        {
            ObjectCache loCache = MemoryCache.Default;
            var items = loCache.Count();

            var tablas = _IndiceTablas.Count;
            var listaTablas = new List<string>();
            var claves = 0;
            foreach (var tabla in _IndiceTablas.Keys)
            {
                claves += _IndiceTablas[tabla].Count;
                listaTablas.Add(tabla);
            }

            //Debugger.Launch();

            if (Debugger.IsAttached)
            {
                Trace.WriteLineIf(Debugger.IsAttached, $"*********** ESTADO DE LA CACHE ({momento}) *************", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Items {items}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Total peticiones al motor SQL {TotalPeticiones}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Peticiones atendidas con elementos de cache {RespuestasDeCache}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $" * Estimación de coste ahorrado acumulado con cache {AhorroCoste} ms.", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Máximo de tablas de un elemento de cache {MaximoDeTablas}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Diccionario con {tablas} tablas y {claves} claves", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Inserciones en cache {InsercionesEnCache}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Eliminaciones de indices {EliminacionesTablasDeCache}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Eliminaciones de elementos {EliminacionesItemsDeCache}", "Cache");
                Trace.WriteLineIf(Debugger.IsAttached, $"Memoria (del proceso, no de la cache): ", "Cache");
                traceUsoDeMemoria();

                //var detalleTablas = string.Join(" || ", listaTablas);
                //Trace.WriteLineIf(Debugger.IsAttached, $"Tablas: ", "Cache");
                //Trace.WriteLineIf(Debugger.IsAttached, $"{detalleTablas} ", "Cache");

                //Trace.WriteLineIf(Debugger.IsAttached, $"Claves fallidas: ", "Cache");
                //ListaClavesFallidas.ForEach(cf => Trace.WriteLineIf(Debugger.IsAttached, $"Fallo de clave con: {cf}", "Cache"));
            }
            //else
            //{
            //    var msg = $"*********** ESTADO DE LA CACHE ({momento}) *************" + Environment.NewLine +
            //    $"Items {items}" + Environment.NewLine +
            //    $"Total peticiones al motor SQL {TotalPeticiones}" + Environment.NewLine +
            //    $"Peticiones atendidas con elementos de cache {RespuestasDeCache}" + Environment.NewLine +
            //    $" * Estimación de coste ahorrado acumulado con cache {AhorroCoste} ms." + Environment.NewLine +
            //    $"Máximo de tablas de un elemento de cache {MaximoDeTablas}" + Environment.NewLine +
            //    $"Diccionario con {tablas} tablas y {claves} claves" + Environment.NewLine +
            //    $"Inserciones en cache {InsercionesEnCache}" + Environment.NewLine +
            //    $"Eliminaciones de indices {EliminacionesTablasDeCache}" + Environment.NewLine +
            //    $"Eliminaciones de elementos {EliminacionesItemsDeCache}" + Environment.NewLine +
            //    $"Memoria (del proceso, no de la cache): " + Environment.NewLine;

            //    MessageBox.Show(msg, "Uso de cache");
            //}

        }
#endif

        private static void traceUsoDeMemoria()
        {
            Process currentProcess = System.Diagnostics.Process.GetCurrentProcess();
            long totalBytesOfMemoryUsed = currentProcess.WorkingSet64;
            Trace.WriteLineIf(Debugger.IsAttached, "Total: " + totalBytesOfMemoryUsed + " bytes - " + (totalBytesOfMemoryUsed * 0.000001) + " Mb." , "Cache");
        }
    }

    public static class QueryCacheExtensions
    {
        public static void __Clear(this ObjectCache cache)
        {
            List<string> cacheKeys = cache.Select(kvp => kvp.Key).ToList();
            foreach (string cacheKey in cacheKeys)
            {
                cache.Remove(cacheKey);
            }
        }
    }
}