/// <summary> /// Get the object from the cache for the key. /// </summary> /// <param name="key"> /// The key whose value to get. /// </param> /// <returns> /// The value associated with the specified key. /// </returns> public object GetData(string key) { ValidateKey(key); CacheItem cacheItemBeforeLock = null; bool lockWasSuccessful = false; do { lock (inMemoryCache.SyncRoot) { cacheItemBeforeLock = (CacheItem)inMemoryCache[key]; if (IsObjectInCache(cacheItemBeforeLock)) { instrumentationProvider.FireCacheAccessed(key, false); return(null); } lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock); } if (lockWasSuccessful == false) { Thread.Sleep(0); } } while (lockWasSuccessful == false); try { if (cacheItemBeforeLock.HasExpired()) { cacheItemBeforeLock.TouchedByUserAction(true); backingStore.Remove(key); // Does exception safety matter here? We're removing it due to expiration or scavenging... inMemoryCache.Remove(key); RefreshActionInvoker.InvokeRefreshAction(cacheItemBeforeLock, CacheItemRemovedReason.Expired, instrumentationProvider); instrumentationProvider.FireCacheAccessed(key, false); instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count); instrumentationProvider.FireCacheExpired(1); return(null); } backingStore.UpdateLastAccessedTime(cacheItemBeforeLock.Key, DateTime.Now); // Does exception safety matter here? cacheItemBeforeLock.TouchedByUserAction(false); instrumentationProvider.FireCacheAccessed(key, true); return(cacheItemBeforeLock.Value); } finally { Monitor.Exit(cacheItemBeforeLock); } }
public bool HasExpired() { if (item.LastAccessedTime.Add(slidingexpiredtime) <= DateTime.Now) { item.TouchedByUserAction(false); return(false); } else { return(true); } }
public void Remove(string key, CacheItemRemovedReason removalReason) { ValidateKey(key); CacheItem cacheItemBeforeLock = null; bool lockWasSuccessful; do { lock (inMemoryCache.SyncRoot) { cacheItemBeforeLock = (CacheItem)inMemoryCache[key]; if (IsObjectInCache(cacheItemBeforeLock)) { return; } lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock); } if (lockWasSuccessful == false) { Thread.Sleep(0); } } while (lockWasSuccessful == false); try { cacheItemBeforeLock.TouchedByUserAction(true); backingStore.Remove(key); // Does exception safety matter here? We're removing it due to expiration or scavenging... inMemoryCache.Remove(key); RefreshActionInvoker.InvokeRefreshAction(cacheItemBeforeLock, removalReason); CachingServiceItemTurnoverEvent.FireRemoveItems(1); CachingServiceItemTurnoverEvent.SetItemsTotal(inMemoryCache.Count); } finally { Monitor.Exit(cacheItemBeforeLock); } }
/// <devdoc> /// There may still be thread safety issues in this class with respect to expirations /// and scavenging, but I really doubt that either of those will be happening while /// a Flush is in progress. It seems that the most likely scenario for a flush /// to be called is at the very start of a program, or when absolutely nothing else /// is going on. Calling flush in the middle of an application would seem to be /// an "interesting" thing to do in normal circumstances. /// </devdoc> public void Flush() { RestartFlushAlgorithm: lock (inMemoryCache.SyncRoot) { foreach (string key in inMemoryCache.Keys) { bool lockWasSuccessful = false; CacheItem itemToRemove = (CacheItem)inMemoryCache[key]; try { if (lockWasSuccessful = Monitor.TryEnter(itemToRemove)) { itemToRemove.TouchedByUserAction(true); } else { goto RestartFlushAlgorithm; } } finally { if (lockWasSuccessful) { Monitor.Exit(itemToRemove); } } } int countBeforeFlushing = inMemoryCache.Count; backingStore.Flush(); inMemoryCache.Clear(); CachingServiceItemTurnoverEvent.FireRemoveItems(countBeforeFlushing); CachingServiceItemTurnoverEvent.SetItemsTotal(0); CachingServiceCacheFlushedEvent.FireEvent(); } }
/// <summary> /// Flush the cache. /// </summary> /// <remarks> /// There may still be thread safety issues in this class with respect to cacheItemExpirations /// and scavenging, but I really doubt that either of those will be happening while /// a Flush is in progress. It seems that the most likely scenario for a flush /// to be called is at the very start of a program, or when absolutely nothing else /// is going on. Calling flush in the middle of an application would seem to be /// an "interesting" thing to do in normal circumstances. /// </remarks> public void Flush() { RestartFlushAlgorithm: lock (inMemoryCache.SyncRoot) { foreach (string key in inMemoryCache.Keys) { bool lockWasSuccessful = false; CacheItem itemToRemove = (CacheItem)inMemoryCache[key]; try { if (lockWasSuccessful = Monitor.TryEnter(itemToRemove)) { itemToRemove.TouchedByUserAction(true); } else { goto RestartFlushAlgorithm; } } finally { if (lockWasSuccessful) { Monitor.Exit(itemToRemove); } } } int countBeforeFlushing = inMemoryCache.Count; backingStore.Flush(); inMemoryCache.Clear(); instrumentationProvider.FireCacheUpdated(countBeforeFlushing, 0); } }
public void Initialize(Microsoft.Practices.EnterpriseLibrary.Caching.CacheItem owningCacheItem) { owningCacheItem.TouchedByUserAction(false); }