internal MemoryCacheEntry AddOrGetExisting(MemoryCacheKey key, MemoryCacheEntry entry) { if (this._useInsertBlock && entry.HasUsage()) { this.WaitInsertBlock(); } MemoryCacheEntry entry2 = null; MemoryCacheEntry entry3 = null; bool flag = false; lock (this._entriesLock) { if (this._disposed == 0) { entry2 = this._entries[key] as MemoryCacheEntry; if ((entry2 != null) && (entry.UtcAbsExp <= DateTime.UtcNow)) { entry3 = entry2; entry3.State = EntryState.RemovingFromCache; entry2 = null; } if (entry2 == null) { entry.State = EntryState.AddingToCache; flag = true; this._entries[key] = entry; } } } bool delayRelease = true; this.RemoveFromCache(entry3, CacheEntryRemovedReason.Expired, delayRelease); if (flag) { this.AddToCache(entry); } this.UpdateExpAndUsage(entry2); if (entry3 != null) { entry3.Release(this._cache, CacheEntryRemovedReason.Expired); } return entry2; }
internal MemoryCacheEntry RemoveEntry(string key, MemoryCacheEntry entry, CacheEntryRemovedReason reason) { MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); return store.Remove(cacheKey, entry, reason); }
internal MemoryCacheEntry GetEntry(String key) { if (IsDisposed) { return null; } MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); return store.Get(cacheKey); }
private object AddOrGetExistingInternal(string key, object value, CacheItemPolicy policy) { if (key == null) { throw new ArgumentNullException("key"); } DateTimeOffset absExp = ObjectCache.InfiniteAbsoluteExpiration; TimeSpan slidingExp = ObjectCache.NoSlidingExpiration; CacheItemPriority priority = CacheItemPriority.Default; Collection<ChangeMonitor> changeMonitors = null; CacheEntryRemovedCallback removedCallback = null; if (policy != null) { ValidatePolicy(policy); if (policy.UpdateCallback != null) { throw new ArgumentException(R.Update_callback_must_be_null, "policy"); } absExp = policy.AbsoluteExpiration; slidingExp = policy.SlidingExpiration; priority = policy.Priority; changeMonitors = policy.ChangeMonitors; removedCallback = policy.RemovedCallback; } if (IsDisposed) { if (changeMonitors != null) { foreach (ChangeMonitor monitor in changeMonitors) { if (monitor != null) { monitor.Dispose(); } } } return null; } MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); MemoryCacheEntry entry = store.AddOrGetExisting(cacheKey, new MemoryCacheEntry(key, value, absExp, slidingExp, priority, changeMonitors, removedCallback, this)); return (entry != null) ? entry.Value : null; }
internal MemoryCacheEntry Remove(MemoryCacheKey key, MemoryCacheEntry entryToRemove, CacheEntryRemovedReason reason) { MemoryCacheEntry objA = null; lock (this._entriesLock) { if (this._disposed == 0) { objA = this._entries[key] as MemoryCacheEntry; if ((entryToRemove == null) || object.ReferenceEquals(objA, entryToRemove)) { if (objA != null) { objA.State = EntryState.RemovingFromCache; } this._entries.Remove(key); } else { objA = null; } } } this.RemoveFromCache(objA, reason, false); return objA; }
public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null) { if (regionName != null) { throw new NotSupportedException(R.RegionName_not_supported); } if (key == null) { throw new ArgumentNullException("key"); } DateTimeOffset infiniteAbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration; TimeSpan noSlidingExpiration = ObjectCache.NoSlidingExpiration; CacheItemPriority priority = CacheItemPriority.Default; Collection<ChangeMonitor> dependencies = null; CacheEntryRemovedCallback removedCallback = null; if (policy != null) { this.ValidatePolicy(policy); if (policy.UpdateCallback != null) { this.Set(key, value, policy.ChangeMonitors, policy.AbsoluteExpiration, policy.SlidingExpiration, policy.UpdateCallback); return; } infiniteAbsoluteExpiration = policy.AbsoluteExpiration; noSlidingExpiration = policy.SlidingExpiration; priority = policy.Priority; dependencies = policy.ChangeMonitors; removedCallback = policy.RemovedCallback; } if (this.IsDisposed) { if (dependencies != null) { foreach (ChangeMonitor monitor in dependencies) { if (monitor != null) { monitor.Dispose(); } } } } else { MemoryCacheKey key2 = new MemoryCacheKey(key); this.GetStore(key2).Set(key2, new MemoryCacheEntry(key, value, infiniteAbsoluteExpiration, noSlidingExpiration, priority, dependencies, removedCallback, this)); } }
internal MemoryCacheStore GetStore(MemoryCacheKey cacheKey) { int index = Math.Abs(cacheKey.Hash) & this._storeMask; return this._stores[index]; }
private object AddOrGetExistingInternal(string key, object value, CacheItemPolicy policy) { if (key == null) { throw new ArgumentNullException("key"); } DateTimeOffset infiniteAbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration; TimeSpan noSlidingExpiration = ObjectCache.NoSlidingExpiration; CacheItemPriority priority = CacheItemPriority.Default; Collection<ChangeMonitor> dependencies = null; CacheEntryRemovedCallback removedCallback = null; if (policy != null) { this.ValidatePolicy(policy); if (policy.UpdateCallback != null) { throw new ArgumentException(R.Update_callback_must_be_null, "policy"); } infiniteAbsoluteExpiration = policy.AbsoluteExpiration; noSlidingExpiration = policy.SlidingExpiration; priority = policy.Priority; dependencies = policy.ChangeMonitors; removedCallback = policy.RemovedCallback; } if (this.IsDisposed) { if (dependencies != null) { foreach (ChangeMonitor monitor in dependencies) { if (monitor != null) { monitor.Dispose(); } } } return null; } MemoryCacheKey key2 = new MemoryCacheKey(key); MemoryCacheEntry entry = this.GetStore(key2).AddOrGetExisting(key2, new MemoryCacheEntry(key, value, infiniteAbsoluteExpiration, noSlidingExpiration, priority, dependencies, removedCallback, this)); if (entry == null) { return null; } return entry.Value; }
internal MemoryCacheEntry AddOrGetExisting(MemoryCacheKey key, MemoryCacheEntry entry) { if (_useInsertBlock && entry.HasUsage()) { WaitInsertBlock(); } MemoryCacheEntry existingEntry = null; MemoryCacheEntry toBeReleasedEntry = null; bool added = false; lock (_entriesLock) { if (_disposed == 0) { existingEntry = _entries[key] as MemoryCacheEntry; // has it expired? if (existingEntry != null && existingEntry.UtcAbsExp <= DateTime.UtcNow) { toBeReleasedEntry = existingEntry; toBeReleasedEntry.State = EntryState.RemovingFromCache; existingEntry = null; } // can we add entry to the cache? if (existingEntry == null) { entry.State = EntryState.AddingToCache; added = true; _entries[key] = entry; } } } // release outside of lock RemoveFromCache(toBeReleasedEntry, CacheEntryRemovedReason.Expired, delayRelease:true); if (added) { // add outside of lock AddToCache(entry); } // update outside of lock UpdateExpAndUsage(existingEntry); // Dev10 861163: Call Release after the new entry has been completely added so // that the CacheItemRemovedCallback can take a dependency on the newly inserted item. if (toBeReleasedEntry != null) { toBeReleasedEntry.Release(_cache, CacheEntryRemovedReason.Expired); } return existingEntry; }
int IEqualityComparer.GetHashCode(object obj) { MemoryCacheKey cacheKey = (MemoryCacheKey)obj; return(cacheKey.Hash); }
// DevDiv Bugs 162763: // Add a an event that fires *before* an item is evicted from the ASP.NET Cache internal void Set(string key, object value, Collection <ChangeMonitor> changeMonitors, DateTimeOffset absoluteExpiration, TimeSpan slidingExpiration, CacheEntryUpdateCallback onUpdateCallback) { if (key == null) { throw new ArgumentNullException("key"); } if (changeMonitors == null && absoluteExpiration == ObjectCache.InfiniteAbsoluteExpiration && slidingExpiration == ObjectCache.NoSlidingExpiration) { throw new ArgumentException(R.Invalid_argument_combination); } if (onUpdateCallback == null) { throw new ArgumentNullException("onUpdateCallback"); } if (IsDisposed) { if (changeMonitors != null) { foreach (ChangeMonitor monitor in changeMonitors) { if (monitor != null) { monitor.Dispose(); } } } return; } // Insert updatable cache entry MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); MemoryCacheEntry cacheEntry = new MemoryCacheEntry(key, value, ObjectCache.InfiniteAbsoluteExpiration, ObjectCache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null, null, this); store.Set(cacheKey, cacheEntry); // Ensure the sentinel depends on its updatable entry string[] cacheKeys = { key }; ChangeMonitor expensiveObjectDep = CreateCacheEntryChangeMonitor(cacheKeys); if (changeMonitors == null) { changeMonitors = new Collection <ChangeMonitor>(); } changeMonitors.Add(expensiveObjectDep); // Insert sentinel entry for the updatable cache entry MemoryCacheKey sentinelCacheKey = new MemoryCacheKey("OnUpdateSentinel" + key); MemoryCacheStore sentinelStore = GetStore(sentinelCacheKey); MemoryCacheEntry sentinelCacheEntry = new MemoryCacheEntry(sentinelCacheKey.Key, new SentinelEntry(key, expensiveObjectDep, onUpdateCallback), absoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, changeMonitors, s_sentinelRemovedCallback, this); sentinelStore.Set(sentinelCacheKey, sentinelCacheEntry); cacheEntry.ConfigureUpdateSentinel(sentinelStore, sentinelCacheEntry); }
internal MemoryCacheEntry RemoveEntry(string key, MemoryCacheEntry entry, CacheEntryRemovedReason reason) { MemoryCacheKey key2 = new MemoryCacheKey(key); return(this.GetStore(key2).Remove(key2, entry, reason)); }
internal MemoryCacheStore GetStore(MemoryCacheKey cacheKey) { int index = Math.Abs(cacheKey.Hash) & this._storeMask; return(this._stores[index]); }
internal void Set(MemoryCacheKey key, MemoryCacheEntry entry) { if (this._useInsertBlock && entry.HasUsage()) { this.WaitInsertBlock(); } MemoryCacheEntry entry2 = null; bool flag = false; lock (this._entriesLock) { if (this._disposed == 0) { entry2 = this._entries[key] as MemoryCacheEntry; if (entry2 != null) { entry2.State = EntryState.RemovingFromCache; } entry.State = EntryState.AddingToCache; flag = true; this._entries[key] = entry; } } CacheEntryRemovedReason removed = CacheEntryRemovedReason.Removed; if (entry2 != null) { if (entry2.UtcAbsExp <= DateTime.UtcNow) { removed = CacheEntryRemovedReason.Expired; } bool delayRelease = true; this.RemoveFromCache(entry2, removed, delayRelease); } if (flag) { this.AddToCache(entry); } if (entry2 != null) { entry2.Release(this._cache, removed); } }
public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null) { if (regionName != null) { throw new NotSupportedException(R.RegionName_not_supported); } if (key == null) { throw new ArgumentNullException("key"); } DateTimeOffset absExp = ObjectCache.InfiniteAbsoluteExpiration; TimeSpan slidingExp = ObjectCache.NoSlidingExpiration; CacheItemPriority priority = CacheItemPriority.Default; Collection<ChangeMonitor> changeMonitors = null; CacheEntryRemovedCallback removedCallback = null; if (policy != null) { ValidatePolicy(policy); if (policy.UpdateCallback != null) { Set(key, value, policy.ChangeMonitors, policy.AbsoluteExpiration, policy.SlidingExpiration, policy.UpdateCallback); return; } absExp = policy.AbsoluteExpiration; slidingExp = policy.SlidingExpiration; priority = policy.Priority; changeMonitors = policy.ChangeMonitors; removedCallback = policy.RemovedCallback; } if (IsDisposed) { if (changeMonitors != null) { foreach (ChangeMonitor monitor in changeMonitors) { if (monitor != null) { monitor.Dispose(); } } } return; } MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); store.Set(cacheKey, new MemoryCacheEntry(key, value, absExp, slidingExp, priority, changeMonitors, removedCallback, this)); }
internal MemoryCacheEntry Get(MemoryCacheKey key) { MemoryCacheEntry entry = _entries[key] as MemoryCacheEntry; // has it expired? if (entry != null && entry.UtcAbsExp <= DateTime.UtcNow) { Remove(key, entry, CacheEntryRemovedReason.Expired); entry = null; } // update outside of lock UpdateExpAndUsage(entry); return entry; }
// DevDiv Bugs 162763: // Add a an event that fires *before* an item is evicted from the ASP.NET Cache internal void Set(string key, object value, Collection<ChangeMonitor> changeMonitors, DateTimeOffset absoluteExpiration, TimeSpan slidingExpiration, CacheEntryUpdateCallback onUpdateCallback) { if (key == null) { throw new ArgumentNullException("key"); } if (changeMonitors == null && absoluteExpiration == ObjectCache.InfiniteAbsoluteExpiration && slidingExpiration == ObjectCache.NoSlidingExpiration) { throw new ArgumentException(R.Invalid_argument_combination); } if (onUpdateCallback == null) { throw new ArgumentNullException("onUpdateCallback"); } if (IsDisposed) { if (changeMonitors != null) { foreach (ChangeMonitor monitor in changeMonitors) { if (monitor != null) { monitor.Dispose(); } } } return; } // Insert updatable cache entry MemoryCacheKey cacheKey = new MemoryCacheKey(key); MemoryCacheStore store = GetStore(cacheKey); MemoryCacheEntry cacheEntry = new MemoryCacheEntry(key, value, ObjectCache.InfiniteAbsoluteExpiration, ObjectCache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null, null, this); store.Set(cacheKey, cacheEntry); // Ensure the sentinel depends on its updatable entry string[] cacheKeys = { key }; ChangeMonitor expensiveObjectDep = CreateCacheEntryChangeMonitor(cacheKeys); if (changeMonitors == null) { changeMonitors = new Collection<ChangeMonitor>(); } changeMonitors.Add(expensiveObjectDep); // Insert sentinel entry for the updatable cache entry MemoryCacheKey sentinelCacheKey = new MemoryCacheKey("OnUpdateSentinel" + key); MemoryCacheStore sentinelStore = GetStore(sentinelCacheKey); MemoryCacheEntry sentinelCacheEntry = new MemoryCacheEntry(sentinelCacheKey.Key, new SentinelEntry(key, expensiveObjectDep, onUpdateCallback), absoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, changeMonitors, s_sentinelRemovedCallback, this); sentinelStore.Set(sentinelCacheKey, sentinelCacheEntry); cacheEntry.ConfigureUpdateSentinel(sentinelStore, sentinelCacheEntry); }
internal MemoryCacheEntry Remove(MemoryCacheKey key, MemoryCacheEntry entryToRemove, CacheEntryRemovedReason reason) { MemoryCacheEntry entry = null; lock (_entriesLock) { if (_disposed == 0) { // get current entry entry = _entries[key] as MemoryCacheEntry; // remove if it matches the entry to be removed (but always remove if entryToRemove is null) if (entryToRemove == null || Object.ReferenceEquals(entry, entryToRemove)) { // Dev10 865887: MemoryCache.Remove("\ue637\ud22a\u3e17") causes NullReferenceEx if (entry != null) { entry.State = EntryState.RemovingFromCache; _entries.Remove(key); } } else { entry = null; } } } // release outside of lock RemoveFromCache(entry, reason); return entry; }
internal MemoryCacheEntry GetEntry(string key) { if (this.IsDisposed) { return null; } MemoryCacheKey key2 = new MemoryCacheKey(key); return this.GetStore(key2).Get(key2); }
internal void Set(MemoryCacheKey key, MemoryCacheEntry entry) { if (_useInsertBlock && entry.HasUsage()) { WaitInsertBlock(); } MemoryCacheEntry existingEntry = null; bool added = false; lock (_entriesLock) { if (_disposed == 0) { existingEntry = _entries[key] as MemoryCacheEntry; if (existingEntry != null) { existingEntry.State = EntryState.RemovingFromCache; } entry.State = EntryState.AddingToCache; added = true; _entries[key] = entry; } } CacheEntryRemovedReason reason = CacheEntryRemovedReason.Removed; if (existingEntry != null) { if (existingEntry.UtcAbsExp <= DateTime.UtcNow) { reason = CacheEntryRemovedReason.Expired; } RemoveFromCache(existingEntry, reason, delayRelease:true); } if (added) { AddToCache(entry); } // Dev10 861163: Call Release after the new entry has been completely added so // that the CacheItemRemovedCallback can take a dependency on the newly inserted item. if (existingEntry != null) { existingEntry.Release(_cache, reason); } }
internal MemoryCacheEntry RemoveEntry(string key, MemoryCacheEntry entry, CacheEntryRemovedReason reason) { MemoryCacheKey key2 = new MemoryCacheKey(key); return this.GetStore(key2).Remove(key2, entry, reason); }
// private and internal internal MemoryCacheStore GetStore(MemoryCacheKey cacheKey) { // Dev10 865907: Math.Abs throws OverflowException for Int32.MinValue int hashCode = cacheKey.Hash; if (hashCode < 0) { hashCode = (hashCode == Int32.MinValue) ? 0 : -hashCode; } int idx = hashCode & _storeMask; return _stores[idx]; }
internal void Set(string key, object value, Collection<ChangeMonitor> changeMonitors, DateTimeOffset absoluteExpiration, TimeSpan slidingExpiration, CacheEntryUpdateCallback onUpdateCallback) { if (key == null) { throw new ArgumentNullException("key"); } if (((changeMonitors == null) && (absoluteExpiration == ObjectCache.InfiniteAbsoluteExpiration)) && (slidingExpiration == ObjectCache.NoSlidingExpiration)) { throw new ArgumentException(R.Invalid_argument_combination); } if (onUpdateCallback == null) { throw new ArgumentNullException("onUpdateCallback"); } if (this.IsDisposed) { if (changeMonitors != null) { foreach (ChangeMonitor monitor in changeMonitors) { if (monitor != null) { monitor.Dispose(); } } } } else { MemoryCacheKey key2 = new MemoryCacheKey(key); this.GetStore(key2).Set(key2, new MemoryCacheEntry(key, value, ObjectCache.InfiniteAbsoluteExpiration, ObjectCache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null, null, this)); string[] keys = new string[] { key }; ChangeMonitor item = this.CreateCacheEntryChangeMonitor(keys, null); if (changeMonitors == null) { changeMonitors = new Collection<ChangeMonitor>(); } changeMonitors.Add(item); key2 = new MemoryCacheKey("OnUpdateSentinel" + key); this.GetStore(key2).Set(key2, new MemoryCacheEntry(key2.Key, new SentinelEntry(key, item, onUpdateCallback), absoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, changeMonitors, s_sentinelRemovedCallback, this)); } }
internal MemoryCacheEntry Get(MemoryCacheKey key) { MemoryCacheEntry entryToRemove = this._entries[key] as MemoryCacheEntry; if ((entryToRemove != null) && (entryToRemove.UtcAbsExp <= DateTime.UtcNow)) { this.Remove(key, entryToRemove, CacheEntryRemovedReason.Expired); entryToRemove = null; } this.UpdateExpAndUsage(entryToRemove); return entryToRemove; }