Czym dokładnie są "informacje", które są podręczne w pamięci podręcznej?

Question

na dokumentacji Dapper znalazł here stwierdza:.

"ograniczeń i zastrzeżeń

Wytworny buforuje informacje o każdym zapytaniu to działa, to pozwoli mu szybko materializować przedmioty szybko i parametry przetworzyć obecna implementacja buforuje te informacje w obiekcie ConcurrentDictionary. "

Co to dokładnie oznacza? Np .: czy buforuje zwrócone dane, czy samo zapytanie, czy też bity obu?

Mówi także, że "to [buforowane] dane nigdy nie są przepłukiwane". W jaki sposób wpływa to na "informacje z pamięci podręcznej", jeśli zmienia się schemat projektu tabeli (tabel)

Answer 1

O ile mi wiadomo, każde zapytanie wydaje się Identity, w zależności od zapytania sql, jego typu polecenia i jego parametrów. Pamięć podręczna to słownik z równoczesnym dostępem.

Dictionary<Identity, CacheInfo> _queryCache 

Ten CacheInfo obiekt zawiera IDataReader i IDBCommand funkcje i niektóre liczniki kontrolne, które ograniczą ilość pamięci podręcznej.

Ponieważ żadna strona serwera (schemat bazy danych itp.) Nie jest buforowana, w rzeczywistości nie ma żadnego wpływu.

Edytuj: Tak wygląda klasa tożsamości używana do buforowania.

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

A oto 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); } 
     } 

i wreszcie pojemnik z pamięci podręcznej.

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

Zapoznaj się z kodem źródłowym, bardzo dobrze napisanym i łatwym do śledzenia/debugowania. Po prostu przeciągnij plik do swojego projektu.