/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) throw new ArgumentNullException("itemPolicy"); var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) updateCallback(name, value); // if (itemPolicy.SlidingExpiration != ServiceCache.NoSlidingExpiration) throw new ArgumentOutOfRangeException("itemPolicy.SlidingExpiration", "not supported."); if (itemPolicy.RemovedCallback != null) throw new ArgumentOutOfRangeException("itemPolicy.RemovedCallback", "not supported."); // var oldVersion = (tag as DataCacheItemVersion); var lockHandle = (tag as DataCacheLockHandle); var dataCacheTags = GetCacheDependency(tag, itemPolicy.Dependency, dispatch); var timeout = GetTimeout(itemPolicy.AbsoluteExpiration); string regionName; if (timeout == TimeSpan.Zero && dataCacheTags == null) if (oldVersion == null && lockHandle == null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value); else Cache.Put(name, value, regionName); } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, oldVersion); else Cache.Put(name, value, oldVersion, regionName); } else { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.PutAndUnlock(name, value, lockHandle); else Cache.PutAndUnlock(name, value, lockHandle, regionName); } else if (timeout != TimeSpan.Zero && dataCacheTags == null) if ((oldVersion == null) && (lockHandle == null)) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, timeout); else Cache.Put(name, value, timeout, regionName); } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, oldVersion, timeout); else Cache.Put(name, value, oldVersion, timeout, regionName); } else { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.PutAndUnlock(name, value, lockHandle, timeout); else Cache.PutAndUnlock(name, value, lockHandle, timeout, regionName); } else if (timeout == TimeSpan.Zero && dataCacheTags != null) if ((oldVersion == null) && (lockHandle == null)) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, dataCacheTags); else Cache.Put(name, value, dataCacheTags, regionName); } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, oldVersion, dataCacheTags); else Cache.Put(name, value, oldVersion, dataCacheTags, regionName); } else { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.PutAndUnlock(name, value, lockHandle, dataCacheTags); else Cache.PutAndUnlock(name, value, lockHandle, dataCacheTags, regionName); } else if (oldVersion == null && lockHandle == null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, timeout, dataCacheTags); else Cache.Put(name, value, timeout, dataCacheTags, regionName); } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.Put(name, value, oldVersion, timeout, dataCacheTags); else Cache.Put(name, value, oldVersion, timeout, dataCacheTags, regionName); } else { if (!Settings.TryGetRegion(ref name, out regionName)) Cache.PutAndUnlock(name, value, lockHandle, timeout, dataCacheTags); else Cache.PutAndUnlock(name, value, lockHandle, timeout, dataCacheTags, regionName); } // var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var header = dispatch.Header; header.Item = name; Add(tag, name + "#", CacheItemPolicy.Default, header, ServiceCacheByDispatcher.Empty); } return value; }
private IEnumerable<DataCacheTag> GetCacheDependency(object tag, CacheItemDependency dependency, ServiceCacheByDispatcher dispatch) { object value; if (dependency == null || (value = dependency(this, dispatch.Registration, tag, dispatch.Values)) == null) return null; // var names = (value as string[]); var touchable = Settings.Touchable; return ((touchable != null && names != null ? touchable.MakeDependency(tag, names) : value) as IEnumerable<DataCacheTag>); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) { throw new ArgumentNullException("itemPolicy"); } var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) { updateCallback(name, value); } // var absoluteExpiration = itemPolicy.AbsoluteExpiration; var slidingExpiration = itemPolicy.SlidingExpiration; ulong cas; object opvalue; StoreMode storeMode; IncrementTag increment; DecrementTag decrement; if (absoluteExpiration == DateTime.MaxValue && slidingExpiration == TimeSpan.Zero) { switch (_tagMapper.ToSetOpcode(tag, ref name, out cas, out opvalue, out storeMode)) { case TagMapper.SetOpcode.Prepend: value = Cache.Prepend(name, OpValueToArraySegment <byte>(opvalue)); break; case TagMapper.SetOpcode.PrependCas: value = Cache.Prepend(name, cas, OpValueToArraySegment <byte>(opvalue)); break; // case TagMapper.SetOpcode.Store: value = Cache.Store(storeMode, name, value); break; case TagMapper.SetOpcode.Cas: value = Cache.Cas(storeMode, name, value, cas); break; case TagMapper.SetOpcode.Decrement: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta); break; case TagMapper.SetOpcode.DecrementCas: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta, cas); break; case TagMapper.SetOpcode.Increment: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta); break; case TagMapper.SetOpcode.IncrementCas: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta, cas); break; default: throw new InvalidOperationException(); } } else if (absoluteExpiration != DateTime.MinValue && slidingExpiration == TimeSpan.Zero) { switch (_tagMapper.ToSetOpcode(tag, ref name, out cas, out opvalue, out storeMode)) { case TagMapper.SetOpcode.Prepend: case TagMapper.SetOpcode.PrependCas: throw new NotSupportedException("Operation not supported with absoluteExpiration && slidingExpiration"); case TagMapper.SetOpcode.Store: value = Cache.Store(storeMode, name, value, absoluteExpiration); break; case TagMapper.SetOpcode.Cas: value = Cache.Cas(storeMode, name, value, absoluteExpiration, cas); break; case TagMapper.SetOpcode.Decrement: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta, absoluteExpiration); break; case TagMapper.SetOpcode.DecrementCas: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta, absoluteExpiration, cas); break; case TagMapper.SetOpcode.Increment: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta, absoluteExpiration); break; case TagMapper.SetOpcode.IncrementCas: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta, absoluteExpiration, cas); break; default: throw new InvalidOperationException(); } } else if (absoluteExpiration == DateTime.MinValue && slidingExpiration != TimeSpan.Zero) { switch (_tagMapper.ToSetOpcode(tag, ref name, out cas, out opvalue, out storeMode)) { case TagMapper.SetOpcode.Prepend: case TagMapper.SetOpcode.PrependCas: throw new NotSupportedException("Operation not supported with absoluteExpiration && slidingExpiration"); case TagMapper.SetOpcode.Store: value = Cache.Store(storeMode, name, value, slidingExpiration); break; case TagMapper.SetOpcode.Cas: value = Cache.Cas(storeMode, name, value, slidingExpiration, cas); break; case TagMapper.SetOpcode.Decrement: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta, slidingExpiration); break; case TagMapper.SetOpcode.DecrementCas: decrement = OpValueToDecrementTag(opvalue); value = Cache.Decrement(name, decrement.DefaultValue, decrement.Delta, slidingExpiration, cas); break; case TagMapper.SetOpcode.Increment: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta, slidingExpiration); break; case TagMapper.SetOpcode.IncrementCas: increment = OpValueToIncrementTag(opvalue); value = Cache.Increment(name, increment.DefaultValue, increment.Delta, slidingExpiration, cas); break; default: throw new InvalidOperationException(); } } else { throw new InvalidOperationException("absoluteExpiration && slidingExpiration"); } // var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var header = dispatch.Header; header.Item = name; Add(tag, name + "#", CacheItemPolicy.Default, header, ServiceCacheByDispatcher.Empty); } return(value); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) throw new ArgumentNullException("itemPolicy"); var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) updateCallback(name, value); // item priority WebCacheItemPriority cacheItemPriority; switch (itemPolicy.Priority) { case CacheItemPriority.AboveNormal: cacheItemPriority = WebCacheItemPriority.AboveNormal; break; case CacheItemPriority.BelowNormal: cacheItemPriority = WebCacheItemPriority.BelowNormal; break; case CacheItemPriority.High: cacheItemPriority = WebCacheItemPriority.High; break; case CacheItemPriority.Low: cacheItemPriority = WebCacheItemPriority.Low; break; case CacheItemPriority.Normal: cacheItemPriority = WebCacheItemPriority.Normal; break; case CacheItemPriority.NotRemovable: cacheItemPriority = WebCacheItemPriority.NotRemovable; break; default: cacheItemPriority = WebCacheItemPriority.Default; break; } // var removedCallback = (itemPolicy.RemovedCallback == null ? null : new WebCacheItemRemovedCallback((n, v, c) => { itemPolicy.RemovedCallback(n, v); })); Cache.Insert(name, value, GetCacheDependency(tag, itemPolicy.Dependency, dispatch), itemPolicy.AbsoluteExpiration, itemPolicy.SlidingExpiration, cacheItemPriority, removedCallback); var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var headerPolicy = new WebCacheDependency(null, new[] { name }); var header = dispatch.Header; header.Item = name; Cache.Insert(name + "#", header, headerPolicy, itemPolicy.AbsoluteExpiration, itemPolicy.SlidingExpiration, cacheItemPriority, null); } return value; }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) { throw new ArgumentNullException("itemPolicy"); } var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) { updateCallback(name, value); } // if (itemPolicy.SlidingExpiration != ServiceCache.NoSlidingExpiration) { throw new ArgumentOutOfRangeException("itemPolicy.SlidingExpiration", "not supported."); } if (itemPolicy.RemovedCallback != null) { throw new ArgumentOutOfRangeException("itemPolicy.RemovedCallback", "not supported."); } // var oldVersion = (tag as DataCacheItemVersion); var lockHandle = (tag as DataCacheLockHandle); var dataCacheTags = GetCacheDependency(tag, itemPolicy.Dependency, dispatch); var timeout = GetTimeout(itemPolicy.AbsoluteExpiration); string regionName; if (timeout == TimeSpan.Zero && dataCacheTags == null) { if (oldVersion == null && lockHandle == null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value); } else { Cache.Put(name, value, regionName); } } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, oldVersion); } else { Cache.Put(name, value, oldVersion, regionName); } } else { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.PutAndUnlock(name, value, lockHandle); } else { Cache.PutAndUnlock(name, value, lockHandle, regionName); } } } else if (timeout != TimeSpan.Zero && dataCacheTags == null) { if ((oldVersion == null) && (lockHandle == null)) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, timeout); } else { Cache.Put(name, value, timeout, regionName); } } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, oldVersion, timeout); } else { Cache.Put(name, value, oldVersion, timeout, regionName); } } else { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.PutAndUnlock(name, value, lockHandle, timeout); } else { Cache.PutAndUnlock(name, value, lockHandle, timeout, regionName); } } } else if (timeout == TimeSpan.Zero && dataCacheTags != null) { if ((oldVersion == null) && (lockHandle == null)) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, dataCacheTags); } else { Cache.Put(name, value, dataCacheTags, regionName); } } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, oldVersion, dataCacheTags); } else { Cache.Put(name, value, oldVersion, dataCacheTags, regionName); } } else { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.PutAndUnlock(name, value, lockHandle, dataCacheTags); } else { Cache.PutAndUnlock(name, value, lockHandle, dataCacheTags, regionName); } } } else if (oldVersion == null && lockHandle == null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, timeout, dataCacheTags); } else { Cache.Put(name, value, timeout, dataCacheTags, regionName); } } else if (oldVersion != null) { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.Put(name, value, oldVersion, timeout, dataCacheTags); } else { Cache.Put(name, value, oldVersion, timeout, dataCacheTags, regionName); } } else { if (!Settings.TryGetRegion(ref name, out regionName)) { Cache.PutAndUnlock(name, value, lockHandle, timeout, dataCacheTags); } else { Cache.PutAndUnlock(name, value, lockHandle, timeout, dataCacheTags, regionName); } } // var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var header = dispatch.Header; header.Item = name; Add(tag, name + "#", CacheItemPolicy.Default, header, ServiceCacheByDispatcher.Empty); } return(value); }
private IEnumerable <DataCacheTag> GetCacheDependency(object tag, CacheItemDependency dependency, ServiceCacheByDispatcher dispatch) { object value; if (dependency == null || (value = dependency(this, dispatch.Registration, tag, dispatch.Values)) == null) { return(null); } // var names = (value as string[]); var touchable = Settings.Touchable; return((touchable != null && names != null ? touchable.MakeDependency(tag, names) : value) as IEnumerable <DataCacheTag>); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) throw new ArgumentNullException("itemPolicy"); var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) updateCallback(name, value); // throw new NotImplementedException(); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) { throw new ArgumentNullException("itemPolicy"); } var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) { updateCallback(name, value); } // item priority WebCacheItemPriority cacheItemPriority; switch (itemPolicy.Priority) { case CacheItemPriority.AboveNormal: cacheItemPriority = WebCacheItemPriority.AboveNormal; break; case CacheItemPriority.BelowNormal: cacheItemPriority = WebCacheItemPriority.BelowNormal; break; case CacheItemPriority.High: cacheItemPriority = WebCacheItemPriority.High; break; case CacheItemPriority.Low: cacheItemPriority = WebCacheItemPriority.Low; break; case CacheItemPriority.Normal: cacheItemPriority = WebCacheItemPriority.Normal; break; case CacheItemPriority.NotRemovable: cacheItemPriority = WebCacheItemPriority.NotRemovable; break; default: cacheItemPriority = WebCacheItemPriority.Default; break; } // var removedCallback = (itemPolicy.RemovedCallback == null ? null : new WebCacheItemRemovedCallback((n, v, c) => { itemPolicy.RemovedCallback(n, v); })); Cache.Insert(name, value, GetCacheDependency(tag, itemPolicy.Dependency, dispatch), itemPolicy.AbsoluteExpiration, itemPolicy.SlidingExpiration, cacheItemPriority, removedCallback); var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var headerPolicy = new WebCacheDependency(null, new[] { name }); var header = dispatch.Header; header.Item = name; Cache.Insert(name + "#", header, headerPolicy, itemPolicy.AbsoluteExpiration, itemPolicy.SlidingExpiration, cacheItemPriority, null); } return(value); }
/// <summary> /// Adds the specified tag. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The item policy.</param> /// <param name="value">The value.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Add(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) throw new ArgumentNullException("itemPolicy"); var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) updateCallback(name, value); // if (itemPolicy.SlidingExpiration != ServiceCache.NoSlidingExpiration) throw new ArgumentOutOfRangeException("itemPolicy.SlidingExpiration", "not supported."); if (itemPolicy.RemovedCallback != null) throw new ArgumentOutOfRangeException("itemPolicy.RemovedCallback", "not supported."); // throw new NotImplementedException(); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name used to identify the item in cache.</param> /// <param name="itemPolicy">The itemPolicy defining caching policies.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch"></param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { _cache[name] = value; var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var header = dispatch.Header; header.Item = name; _cache[name + "#"] = header; } return(value); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">Not used</param> /// <param name="name">The key used to identify the item in cache.</param> /// <param name="itemPolicy">Not used</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">Not used</param> /// <returns>Last value that what in cache.</returns> public object Add(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { // TODO: Throw on dependency or other stuff not supported by this simple system object lastValue; if (!_cache.TryGetValue(name, out lastValue)) { _cache[name] = value; var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var header = dispatch.Header; header.Item = name; _cache[name + "#"] = header; } return(null); } return(lastValue); }
private SystemCaching.CacheItemPolicy GetCacheDependency(object tag, CacheItemPolicy itemPolicy, ServiceCacheByDispatcher dispatch) { // item priority SystemCaching.CacheItemPriority itemPriority; switch (itemPolicy.Priority) { case CacheItemPriority.NotRemovable: itemPriority = SystemCaching.CacheItemPriority.NotRemovable; break; default: itemPriority = SystemCaching.CacheItemPriority.Default; break; } var removedCallback = (itemPolicy.RemovedCallback != null ? new SystemCaching.CacheEntryRemovedCallback(x => { itemPolicy.RemovedCallback(x.CacheItem.Key, x.CacheItem.Value); }) : null); var updateCallback = (itemPolicy.UpdateCallback != null ? new SystemCaching.CacheEntryUpdateCallback(x => { itemPolicy.UpdateCallback(x.UpdatedCacheItem.Key, x.UpdatedCacheItem.Value); }) : null); var newItemPolicy = new SystemCaching.CacheItemPolicy { AbsoluteExpiration = itemPolicy.AbsoluteExpiration, Priority = itemPriority, RemovedCallback = removedCallback, SlidingExpiration = itemPolicy.SlidingExpiration, UpdateCallback = updateCallback, }; var changeMonitors = GetCacheDependency(tag, itemPolicy.Dependency, dispatch); if (changeMonitors != null) { var list = newItemPolicy.ChangeMonitors; foreach (var changeMonitor in changeMonitors) { list.Add(changeMonitor); } } return(newItemPolicy); }
/// <summary> /// Adds an object into cache based on the parameters provided. /// </summary> /// <param name="tag">The tag.</param> /// <param name="name">The name.</param> /// <param name="itemPolicy">The itemPolicy object.</param> /// <param name="value">The value to store in cache.</param> /// <param name="dispatch">The dispatch.</param> /// <returns></returns> public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch) { if (itemPolicy == null) { throw new ArgumentNullException("itemPolicy"); } var updateCallback = itemPolicy.UpdateCallback; if (updateCallback != null) { updateCallback(name, value); } string regionName; Settings.TryGetRegion(ref name, out regionName); // Cache.Set(name, value, GetCacheDependency(tag, itemPolicy, dispatch), regionName); var registration = dispatch.Registration; if (registration != null && registration.UseHeaders) { var headerPolicy = new SystemCaching.CacheItemPolicy(); headerPolicy.ChangeMonitors.Add(Cache.CreateCacheEntryChangeMonitor(new[] { name }, regionName)); var header = dispatch.Header; header.Item = name; Cache.Set(name + "#", header, headerPolicy, regionName); } return(value); }