C# 4.0 MemoryCache - jak usunąć zależne wpisy pamięci podręcznej po wprowadzeniu zmian w ich zależnościach

Question

Próbuję eksmitować wpisy z MemoryCache po wprowadzeniu zmian w innych wpisach, na których są one zależne. To jest ustanowiony przez tworzenie monitorów Zmiana wpisu cache dla zależnościami na klawiszach zależnych:

public bool AddToCache(string key, object dataItem, 
    DateTimeOffset absoluteExpiration, IEnumerable<string> dependencyKeys) 
{ 
    bool result = false; 

    if (!string.IsNullOrWhiteSpace(key) && dataItem != null) 
    { 
     CacheItemPolicy policy = new CacheItemPolicy { 
      AbsoluteExpiration = absoluteExpiration 
     }; 

     if (masterKeys != null && masterKeys.Any()) 
     { 
      policy.ChangeMonitors.Add(
       this.provider.Cache. 
        CreateCacheEntryChangeMonitor(dependencyKeys)); 

      foreach (ChangeMonitor monitor in policy.ChangeMonitors) 
      { 
       monitor.NotifyOnChanged(this.OnDependencyChanged); 
      } 
     } 

     result = this.provider.Cache.Add(key, dataItem, policy); 
    } 

    return result; 
} 

Sposób OnChangedCallBack to:

private void OnDependencyChanged(object state) 
{ 
    // what do I do here as "state" is always null? 
} 

Elementy są dodawane do pamięci podręcznej zgodnie z przeznaczeniem, a metoda OnDependencyChanged jest wywoływana zgodnie z oczekiwaniami, gdy wprowadzana jest zmiana w monitorowanym kluczu, jednak przekazana do niej instancja "stanu" ma zawsze wartość null, co oznacza, że ​​nic nie wiem o kluczu pamięci podręcznej, którego zależność uległa zmianie i dlatego nie może wykonać planowana eksmisja.

Czy coś tu przeoczyłem, czy podchodzę do tego w niewłaściwy sposób?

Answer 1

Delegat, który jest używany jako parametr w OnChangedCacheEntry jest:

public delegate void OnChangedCallback(object state); 

Więc trzeba nazwać tak:

monitor.NotifyOnChanged(delegate { 
     OnChangedCacheEntry(OnDependencyChanged(dependencyKeys)); }); 

I wtedy będziesz miał dostęp do kluczy zależność w OnDependencyChanged

private void OnDependencyChanged(object state) 
{ 
    IEnumerable<string> dependencyKeys = (IEnumerable<string>) state; 
} 

Answer 2

wiem, że to stary wątek, ale tutaj jest to, co mam, ale wydaje się, do pracy.

... 

if (dependencies != null) 
{ 
    var monitor = MemoryCache.Default.CreateCacheEntryChangeMonitor(dependencies); 
    monitor.NotifyOnChanged(delegate { OnChangedCallback(dependencies); }); 
    policy.ChangeMonitors.Add(monitor); 
} 

... 

private static void OnChangedCallback(object state) 
{ 
    var keys = (IEnumerable<string>) state; 
    if (keys != null) 
     Logger.InfoFormat("callback - {0}", string.Join("|", keys.ToArray())); 
    else 
     Logger.InfoFormat("callback - null"); 
} 

zależności parametr w OnChangedCallback (zależności) to czego brakuje z oryginalnego postu.