Quelle est exactement la "information" qui cache les caches?

caching dapper

Question

Sur la documentation de Dapper trouvée ici, il est écrit:

" Limitations et avertissements

Dapper met en cache les informations relatives à chaque requête exécutée , ce qui lui permet de matérialiser rapidement les objets et de traiter rapidement les paramètres. L'implémentation actuelle met en cache ces informations dans un objet ConcurrentDictionary. "

Qu'est-ce que cela signifie exactement? Ex: Est-ce la mise en cache des données renvoyées, ou la requête elle-même, ou des bits des deux?

Il dit également que " ces données [en cache] ne sont jamais vidées ". Comment cela affecte-t-il les "informations mises en cache" si le schéma de conception de la ou des tables que vous interrogez est modifié?

Réponse acceptée

Pour autant que je sache, chaque requête émet une Identity , en fonction de la requête SQL, de son type de commande et de ses paramètres. Le cache est un dictionnaire avec accès simultané.

Dictionary<Identity, CacheInfo> _queryCache

Cet objet CacheInfo contient les fonctions IDataReader et IDBCommand et certains compteurs de contrôle qui limitent la quantité mise en cache.

Comme aucun côté serveur (schéma de base de données, etc.) n'est mis en cache, cela n'a aucune influence.

Edit: À quoi ressemble la classe Identity utilisée pour la mise en cache.

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());
            }
        }

Et voici le 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); }
        }

Et enfin le conteneur du cache.

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

Jetez un oeil sur le code source, son très bien écrit et facile à suivre / déboguer. Faites simplement glisser le fichier dans votre projet.




Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi