public override object Add(string key, object value, CacheItemBaseDependency[] dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheBaseItem.PriorityLevel priority, CacheRemovedCallback onRemoveCallback)
        {
            CacheItemPriority aspnetPriority;

            switch (priority)
            {
            case CacheBaseItem.PriorityLevel.Low:
                aspnetPriority = CacheItemPriority.Low;
                break;

            case CacheBaseItem.PriorityLevel.BelowNormal:
                aspnetPriority = CacheItemPriority.BelowNormal;
                break;

            case CacheBaseItem.PriorityLevel.Normal:
                aspnetPriority = CacheItemPriority.Normal;
                break;

            case CacheBaseItem.PriorityLevel.AboveNormal:
                aspnetPriority = CacheItemPriority.AboveNormal;
                break;

            case CacheBaseItem.PriorityLevel.High:
                aspnetPriority = CacheItemPriority.High;
                break;

            case CacheBaseItem.PriorityLevel.NotRemovable:
                aspnetPriority = CacheItemPriority.NotRemovable;
                break;

            default:
                throw new Exception("Unknown CacheBaseItem.PriorityLevel " + priority);
            }

            CacheDependency dependency = null;

            if (dependencies != null)
            {
                foreach (var d in dependencies)
                {
                    if (d is CacheItemFilesDependency)
                    {
                        dependency = new CacheDependency(((CacheItemFilesDependency)d).Files);
                    }
                    else if (d is CacheItemKeysDependency)
                    {
                        dependency = new CacheDependency(null, ((CacheItemKeysDependency)d).Keys);
                    }
                }
            }

            return(this.Cache.Add(
                       key,
                       value,
                       dependency,
                       absoluteExpiration,
                       slidingExpiration,
                       aspnetPriority,
                       onRemoveCallback == null ? null : new CacheItemRemovedCallback((k, v, r) =>
            {
                CacheRemovedReason reason;
                switch (r)
                {
                case CacheItemRemovedReason.Removed:
                    reason = CacheRemovedReason.Removed;
                    break;

                case CacheItemRemovedReason.DependencyChanged:
                    reason = CacheRemovedReason.DependencyChanged;
                    break;

                case CacheItemRemovedReason.Expired:
                    reason = CacheRemovedReason.Expired;
                    break;

                case CacheItemRemovedReason.Underused:
                    reason = CacheRemovedReason.Underused;
                    break;

                default:
                    throw new Exception("Unknown CacheRemovedReason " + r);
                }
                onRemoveCallback(k, v, reason);
            })
                       ));
        }
Example #2
0
 public abstract object Add(string key, object value, CacheItemBaseDependency[] dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheBaseItem.PriorityLevel priority, CacheRemovedCallback onRemoveCallback);
        public override object Add(string key, object value, CacheItemBaseDependency[] dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheBaseItem.PriorityLevel priority, CacheRemovedCallback onRemoveCallback)
        {
            var policy = new CacheItemPolicy();

            switch (priority)
            {
            case CacheBaseItem.PriorityLevel.Low:
            case CacheBaseItem.PriorityLevel.BelowNormal:
            case CacheBaseItem.PriorityLevel.Normal:
            case CacheBaseItem.PriorityLevel.AboveNormal:
            case CacheBaseItem.PriorityLevel.High:
                policy.Priority = System.Runtime.Caching.CacheItemPriority.Default;
                break;

            case CacheBaseItem.PriorityLevel.NotRemovable:
                policy.Priority = CacheItemPriority.NotRemovable;
                break;

            default:
                throw new Exception("Unknown CacheBaseItem.PriorityLevel " + priority);
            }

            if (absoluteExpiration != CacheManager.NoAbsoluteExpiration)
            {
                policy.AbsoluteExpiration = absoluteExpiration;
            }
            if (slidingExpiration != CacheManager.NoSlidingExpiration)
            {
                policy.SlidingExpiration = slidingExpiration;
            }
            if (dependencies != null)
            {
                foreach (var d in dependencies)
                {
                    if (d is CacheItemFilesDependency)
                    {
                        var filesMonitor = new HostFileChangeMonitor(((CacheItemFilesDependency)d).Files);
                        policy.ChangeMonitors.Add(filesMonitor);
                    }
                    else if (d is CacheItemKeysDependency)
                    {
                        policy.ChangeMonitors.Add(this.Cache.CreateCacheEntryChangeMonitor(((CacheItemKeysDependency)d).Keys));
                    }
                }
            }

            if (onRemoveCallback != null)
            {
                policy.RemovedCallback = new CacheEntryRemovedCallback((a) =>
                {
                    CacheRemovedReason reason;
                    switch (a.RemovedReason)
                    {
                    case CacheEntryRemovedReason.Removed:
                        reason = CacheRemovedReason.Removed;
                        break;

                    case CacheEntryRemovedReason.ChangeMonitorChanged:
                        reason = CacheRemovedReason.DependencyChanged;
                        break;

                    case CacheEntryRemovedReason.Expired:
                        reason = CacheRemovedReason.Expired;
                        break;

                    case CacheEntryRemovedReason.Evicted:
                    case CacheEntryRemovedReason.CacheSpecificEviction:
                        reason = CacheRemovedReason.Underused;
                        break;

                    default:
                        throw new Exception("Unknown CacheRemovedReason " + a.RemovedReason);
                    }
                    onRemoveCallback(a.CacheItem.Key, a.CacheItem.Value, reason);
                });
            }

            return(this.Cache.Add(key, value, policy));
        }