public static void Add(String key, object value, TimeSpan?slidingExpiration, DateTime?absoluteExpiration) { if (String.IsNullOrWhiteSpace(key)) { throw new ArgumentException("Invalid cache key"); } if (value == null) { throw new ArgumentNullException("Value is not null"); } if (MemoryCache.Default[key] == null) { lock (_locker) { if (MemoryCache.Default[key] == null) { CacheEntryChangeMonitor monitor = MemoryCache.Default.CreateCacheEntryChangeMonitor(new[] { key }); var _policy = new CacheItemPolicy { AbsoluteExpiration = absoluteExpiration.HasValue ? absoluteExpiration.Value : DateTime.MaxValue, SlidingExpiration = slidingExpiration.HasValue ? slidingExpiration.Value : TimeSpan.FromSeconds(60), Priority = System.Runtime.Caching.CacheItemPriority.Default }; _policy.ChangeMonitors.Add(monitor); MemoryCache.Default.Add(key, value, _policy); } } } }
public static bool AddBothExpirations(this ObjectCache instance, string key, object value, DateTimeOffset absoluteExpiration, TimeSpan slidingExpiration, CacheEntryRemovedCallback removedDelegate = null) { if (instance == null) { throw new ArgumentNullException("instance"); } string slidingKey = _slidingKeyPrefix + key; CacheItemPolicy slidingPolicy = new CacheItemPolicy { SlidingExpiration = slidingExpiration }; instance.Set(slidingKey, _placeholder, slidingPolicy); CacheEntryChangeMonitor monitor = instance.CreateCacheEntryChangeMonitor(new string[] { slidingKey }); CacheItemPolicy itemPolicy = new CacheItemPolicy { AbsoluteExpiration = absoluteExpiration, RemovedCallback = (x) => { if (removedDelegate == null) { return; } //HACK: ChangeMonitorChanged is given due to one of the depedent //monitors for an item being removed due to expiry, capture this and re-send as expired. if (x.RemovedReason == CacheEntryRemovedReason.ChangeMonitorChanged) { x = new CacheEntryRemovedArguments(x.Source, CacheEntryRemovedReason.Expired, x.CacheItem); } removedDelegate(x); } }; itemPolicy.ChangeMonitors.Add(monitor); return(instance.Add(key, value, itemPolicy)); }
//Private Methods... private CacheItemPolicy GetCachePolicy(string key, Nullable <TimeSpan> time = null) { key = GetAbsoluteKey(key); string[] absKey = new string[] { key }; MemoryCache.Default.Add(key, new object(), time.HasValue ? DateTime.UtcNow.AddTicks(time.Value.Ticks) : DateTime.UtcNow.AddHours(1) //default it to only 1 hour. ); CacheEntryChangeMonitor monitor = MemoryCache.Default.CreateCacheEntryChangeMonitor(absKey); CacheItemPolicy policy = new CacheItemPolicy(); policy.ChangeMonitors.Add(monitor); policy.SlidingExpiration = !time.HasValue ? new TimeSpan(1, 0, 0) : time.Value; //default it to only 1 hour return(policy); }
void InitForMemoryCache(bool isPublic, string[] filenamesArg, string[] cachekeysArg, CacheDependency dependency, DateTime utcStart) { bool dispose = true; try { MemCache memCache = HttpRuntime.InternalCache as MemCache; _bits = new SafeBitVector32(0); _utcLastModified = DateTime.MinValue; IList <String> files = filenamesArg; IList <String> keys = cachekeysArg; if (dependency != null) { ReadOnlyCollection <string> filePaths = (dependency._fileChangeMonitor != null) ? dependency._fileChangeMonitor.FilePaths : null; ReadOnlyCollection <string> cacheKeys = (dependency._entryChangeMonitor != null) ? dependency._entryChangeMonitor.CacheKeys : null; if (filePaths != null || filenamesArg != null) { if (filePaths == null) { files = filenamesArg; } else if (filenamesArg == null) { files = filePaths; } else { files = new List <String>(filenamesArg.Length + filePaths.Count); foreach (string f in filenamesArg) { files.Add(f); } foreach (string f in filePaths) { files.Add(f); } } } if (cacheKeys != null || cachekeysArg != null) { if (cacheKeys == null) { keys = cachekeysArg; } else if (cachekeysArg == null) { keys = cacheKeys; } else { keys = new List <String>(cachekeysArg.Length + cacheKeys.Count); foreach (string f in cachekeysArg) { keys.Add(f); } foreach (string f in cacheKeys) { keys.Add(f); } } } } _fileChangeMonitor = (files != null) ? new HostFileChangeMonitor(files) : null; _entryChangeMonitor = (keys != null) ? memCache.CreateCacheEntryChangeMonitor(keys, isPublic) : null; string uniqueId = null; if (_fileChangeMonitor != null) { _utcLastModified = _fileChangeMonitor.LastModified.UtcDateTime; uniqueId = _fileChangeMonitor.UniqueId; _fileChangeMonitor.NotifyOnChanged(new OnChangedCallback(OnChangedCallback)); } if (_entryChangeMonitor != null) { DateTime utcLastModified = _entryChangeMonitor.LastModified.UtcDateTime; if (utcLastModified > _utcLastModified) { _utcLastModified = utcLastModified; } uniqueId += _entryChangeMonitor.UniqueId; _entryChangeMonitor.NotifyOnChanged(new OnChangedCallback(OnChangedCallback)); } _uniqueID = uniqueId; #if DBG _isUniqueIDInitialized = true; #endif // check if file has changed since the start time if (utcStart < DateTime.MaxValue) { if (_utcLastModified > utcStart && !(_utcLastModified - DateTime.UtcNow > FUTURE_FILETIME_BUFFER)) // See VSWhidbey 400917 { _bits[CHANGED] = true; } } _bits[BASE_INIT] = true; if (dependency != null && dependency._bits[CHANGED]) { _bits[CHANGED] = true; } if (_bits[WANTS_DISPOSE] || _bits[CHANGED]) { Debug.Trace("CacheDependencyInit", "WANTS_DISPOSE or CHANGED. InitForMemoryCache calling DisposeInternal"); DisposeInternal(); } dispose = false; } finally { if (dispose) { _bits[BASE_INIT] = true; Debug.Trace("CacheDependencyInit", "\n\nERROR in CacheDependency.InitForMemoryCache, calling DisposeInternal"); DisposeInternal(); } } }
public ChangeMonitorDetail(CacheEntryChangeMonitor changeMonitor) { RegionName = changeMonitor.RegionName; LastModified = changeMonitor.LastModified; CacheKeys = changeMonitor.CacheKeys; }