¿Cuál es exactamente la "información" que los datiles caché?

caching dapper

Pregunta

En la documentación de Dapper que se encuentra aquí , dice:

" Limitaciones y advertencias

Dapper almacena información en caché sobre cada consulta que ejecuta , esto le permite materializar objetos rápidamente y procesar parámetros rápidamente. La implementación actual almacena en caché esta información en un objeto ConcurrentDictionary ".

¿Qué significa esto exactamente? Ej: ¿Es el caché de datos devueltos, o la consulta en sí, o bits de ambos?

También dice que " estos datos [en caché] nunca se vacían ". ¿Cómo afecta esto a la "información en caché" si se modifica el esquema de diseño de la (s) tabla (s) que está consultando?

Respuesta aceptada

Por lo que sé, cada consulta genera una Identity , dependiendo de la consulta SQL, su tipo de comando y sus parámetros. La memoria caché es un diccionario con acceso concurrente.

Dictionary<Identity, CacheInfo> _queryCache

Este objeto CacheInfo contiene las funciones IDataReader e IDBCommand y algunos contadores de control que limitan la cantidad almacenada en caché.

Como ningún lado del servidor (esquema de base de datos, etc.) está en caché, en realidad no tiene ninguna influencia.

Editar: Así es como se ve la clase de Identidad utilizada para el almacenamiento en caché.

private Identity(string sql, CommandType? commandType, string connectionString, Type type, Type parametersType, Type[] otherTypes, int gridIndex)
        {
            this.sql = sql;
            this.commandType = commandType;
            this.connectionString = connectionString;
            this.type = type;
            this.parametersType = parametersType;
            this.gridIndex = gridIndex;
            unchecked
            {
                hashCode = 17; // we *know* we are using this in a dictionary, so pre-compute this
                hashCode = hashCode * 23 + commandType.GetHashCode();
                hashCode = hashCode * 23 + gridIndex.GetHashCode();
                hashCode = hashCode * 23 + (sql == null ? 0 : sql.GetHashCode());
                hashCode = hashCode * 23 + (type == null ? 0 : type.GetHashCode());
                if (otherTypes != null)
                {
                    foreach (var t in otherTypes)
                    {
                        hashCode = hashCode * 23 + (t == null ? 0 : t.GetHashCode());
                    }
                }
                hashCode = hashCode * 23 + (connectionString == null ? 0 : connectionString.GetHashCode());
                hashCode = hashCode * 23 + (parametersType == null ? 0 : parametersType.GetHashCode());
            }
        }

Y aquí está el CacheInfo

class CacheInfo

        {
            public Func<IDataReader, object> Deserializer { get; set; }
            public Func<IDataReader, object>[] OtherDeserializers { get; set; }
            public Action<IDbCommand, object> ParamReader { get; set; }
            private int hitCount;
            public int GetHitCount() { return Interlocked.CompareExchange(ref hitCount, 0, 0); }
            public void RecordHit() { Interlocked.Increment(ref hitCount); }
        }

Y finalmente el contenedor de la memoria caché.

static readonly System.Collections.Concurrent.ConcurrentDictionary<Identity, CacheInfo> _queryCache = new System.Collections.Concurrent.ConcurrentDictionary<Identity, CacheInfo>();

Eche un vistazo al código fuente, está muy bien escrito y es fácil de seguir / depurar. Simplemente arrastre el archivo a su proyecto.



Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow
Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow