public static void Insert(string key, object value, CacheDependency dependency, TimeSpan timeframe, CacheItemPriority priority) { if (value != null) { _cache.Insert(key, value, dependency, DateTime.Now.Add(timeframe), Cache.NoSlidingExpiration, priority, null); } }
/// <summary>Costructor</summary> /// <param name="value">Actual object to be stored in cache</param> public CacheItem(object value) { _v = value; _abs = Cache.NoAbsoluteExpiration; _sld = Cache.NoSlidingExpiration; _p = CacheItemPriority.Default; }
/// <summary> /// Sets the priority for keeping the cache entry in the cache during a memory pressure tokened cleanup. /// </summary> /// <param name="options"></param> /// <param name="priority"></param> public static MemoryCacheEntryOptions SetPriority( this MemoryCacheEntryOptions options, CacheItemPriority priority) { options.Priority = priority; return options; }
internal AddCommand(string key, byte[] value, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, short removeCallback, short updateCallback, Hashtable queryInfo, BitSet flagMap, string cacheId,EventDataFilter updateDataFilter,EventDataFilter removeDataFilter) { base.name = "AddCommand"; base.key = key; _addCommand = new Alachisoft.NCache.Common.Protobuf.AddCommand(); if (absoluteExpiration != Cache.NoAbsoluteExpiration) _addCommand.absExpiration = absoluteExpiration.Ticks; if (slidingExpiration != Cache.NoSlidingExpiration) _addCommand.sldExpiration = slidingExpiration.Ticks; Alachisoft.NCache.Caching.UserBinaryObject ubObject = Alachisoft.NCache.Caching.UserBinaryObject.CreateUserBinaryObject(value); _addCommand.key = key; _addCommand.data.AddRange(ubObject.DataList); _addCommand.requestId = base.RequestId; _addCommand.updateCallbackId = updateCallback; _addCommand.removeCallbackId = removeCallback; _addCommand.priority = (int)priority; _addCommand.flag = flagMap.Data; _addCommand.updateDataFilter = (short)updateDataFilter; _addCommand.removeDataFilter = (short)removeDataFilter; // Changes made to send Queries, Tags and NamgedTags in a single object ObjectQueryInfo objectQueryInfo = new ObjectQueryInfo(); if (queryInfo["query-info"] != null) objectQueryInfo.queryInfo = ProtobufHelper.GetQueryInfoObj(queryInfo["query-info"] as Hashtable); _addCommand.objectQueryInfo = objectQueryInfo; }
public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { _cache.Insert(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback); }
public CacheItemArgs(string key) { _CacheKey = key; _CacheTimeOut = 20; _CachePriority = CacheItemPriority.Default; //_ParamList = new ArrayList(); }
/// <summary> /// Constructs a fully formed CacheItem. This constructor is to be used when restoring an existing /// CacheItem from the backing store. As such, it does not generate its own Guid for this instance, /// but allows the guid to be passed in, as read from the backing store. /// </summary> /// <param name="lastAccessedTime">Time this CacheItem last accessed by user.</param> /// <param name="key">Key provided by the user for this cache item. May not be null.</param> /// <param name="value">Value to be stored. May be null.</param> /// <param name="scavengingPriority">Scavenging priority of CacheItem. See <see cref="CacheItemPriority" /> for values.</param> /// <param name="refreshAction">Object supplied by caller that will be invoked upon expiration of the CacheItem. May be null.</param> /// <param name="expirations">Param array of ICacheItemExpiration objects. May provide 0 or more of these.</param> public CacheItem(DateTime lastAccessedTime, string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations) { Initialize(key, value, refreshAction, scavengingPriority, expirations); TouchedByUserAction(false, lastAccessedTime); InitializeExpirations(); }
public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority) { if (obj != null) { _cache.Insert(key, obj, dep, DateTime.Now.AddSeconds((double) (Factor * seconds)), TimeSpan.Zero, priority, null); } }
public CacheItemArgs(string key, int timeout) : this(key) { _CacheTimeOut = timeout; _CachePriority = CacheItemPriority.Default; //_ParamList = new ArrayList(); }
public CacheItem(string key, object value, CacheItemPriority scavengingPriority,params ICacheItemExpiration[] expirations) { Initialize(key, value, scavengingPriority, expirations); TouchedByUserAction(false); InitializeExpirations(); }
/// <summary> /// 建立定时不访问便移除的缓存 /// </summary> public static object AddCache(string key, object value, TimeSpan slidingExpiration, CacheItemPriority priority) { if (HttpRuntime.Cache[key] == null && value != null) return HttpRuntime.Cache.Add(key, value, null, Cache.NoAbsoluteExpiration, slidingExpiration, priority, null); else return null; }
internal CacheEntry (Cache objManager, string strKey, object objItem,CacheDependency objDependency, CacheItemRemovedCallback eventRemove, DateTime dtExpires, TimeSpan tsSpan, long longMinHits, bool boolPublic, CacheItemPriority enumPriority ) { if (boolPublic) _enumFlags |= Flags.Public; _strKey = strKey; _objItem = objItem; _objCache = objManager; _onRemoved += eventRemove; _enumPriority = enumPriority; _ticksExpires = dtExpires.ToUniversalTime ().Ticks; _ticksSlidingExpiration = tsSpan.Ticks; // If we have a sliding expiration it overrides the absolute expiration (MS behavior) // This is because sliding expiration causes the absolute expiration to be // moved after each period, and the absolute expiration is the value used // for all expiration calculations. if (tsSpan.Ticks != Cache.NoSlidingExpiration.Ticks) _ticksExpires = DateTime.UtcNow.AddTicks (_ticksSlidingExpiration).Ticks; _objDependency = objDependency; if (_objDependency != null) // Add the entry to the cache dependency handler (we support multiple entries per handler) _objDependency.Changed += new CacheDependencyChangedHandler (OnChanged); _longMinHits = longMinHits; }
public InsertCommand(string key, byte[] value, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, short removeCallback, short updateCallback, Hashtable queryInfo, BitSet flagMap, object lockId, LockAccessType accessType, string cacheId, EventDataFilter updateCallbackFilter, EventDataFilter removeCallabackFilter) { base.name = "InsertCommand"; base.key = key; _insertCommand = new Alachisoft.NCache.Common.Protobuf.InsertCommand(); _insertCommand.key = key; Alachisoft.NCache.Caching.UserBinaryObject ubObject = UserBinaryObject.CreateUserBinaryObject(value); _insertCommand.data.AddRange(ubObject.DataList); _insertCommand.requestId = base.RequestId; _insertCommand.removeCallbackId = removeCallback; _insertCommand.updateCallbackId = updateCallback; _insertCommand.updateDataFilter = (short)updateCallbackFilter; _insertCommand.removeDataFilter = (short)removeCallabackFilter; _insertCommand.priority = (int)priority; _insertCommand.flag = flagMap.Data; if(lockId != null) _insertCommand.lockId = lockId.ToString(); _insertCommand.lockAccessType = (int)accessType; if (absoluteExpiration != Web.Caching.Cache.NoAbsoluteExpiration) _insertCommand.absExpiration = absoluteExpiration.Ticks; if (slidingExpiration != Web.Caching.Cache.NoSlidingExpiration) _insertCommand.sldExpiration = slidingExpiration.Ticks; ObjectQueryInfo objectQueryInfo = new ObjectQueryInfo(); if (queryInfo["query-info"] != null) objectQueryInfo.queryInfo = ProtobufHelper.GetQueryInfoObj(queryInfo["query-info"] as Hashtable); _insertCommand.objectQueryInfo = objectQueryInfo; }
/// <summary> /// 建立缓存,并在移除时执行事件 /// </summary> public static object AddCache(string key, object value, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemovedCallback) { if (HttpRuntime.Cache[key] == null && value != null) return HttpRuntime.Cache.Add(key, value, null, absoluteExpiration, slidingExpiration, priority, onRemovedCallback); else return null; }
public static IExpressionRegistration CachedLifetime(this IExpressionRegistration registration, TimeSpan slidingExpiration, CacheDependency dependency = null, CacheItemPriority itemPriority = CacheItemPriority.Default, CacheItemRemovedCallback itemRemovedCallback = null) { if (registration == null) throw new ArgumentNullException("registration"); registration.SetLifetime(new CachedLifetime(slidingExpiration, dependency, itemPriority, itemRemovedCallback)); return registration; }
public static void Add(string key, object o, int time, TimeSpan timespan, CacheItemPriority priority, CacheItemRemovedCallback callback) { if (o == null) { return; } _cache.Insert(key, o, null, DateTime.Now.AddSeconds(time), timespan, priority, callback); }
public override void Insert(string cacheKey, object itemToCache, DNNCacheDependency dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { //onRemoveCallback += ItemRemovedCallback; //Call base class method to add obect to cache base.Insert(cacheKey, itemToCache, dependency, absoluteExpiration, slidingExpiration, priority, onRemoveCallback); }
/// <summary> /// 插入缓存 /// </summary> /// <param name="key">Key</param> /// <param name="obj">缓存对象</param> /// <param name="dep"></param> /// <param name="seconds"></param> /// <param name="priority"></param> public static void Insert(string key, object obj, CacheDependency dep, int minuts, CacheItemPriority priority) { if (obj != null) { cache.Insert(key, obj, dep, DateTime.Now.AddMinutes(minuts), TimeSpan.Zero, priority, null); } }
public RedisCacheEntry(String key, Object value, DateTimeOffset absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority) : this(key, value, absoluteExpiration, slidingExpiration, priority.ToString()) { }
public static void AddObject(string CacheKey, object value, CacheItemPriority cacheItemPriority = 0) { CheckFile(); if (Convert.ToInt32(cacheItemPriority) == 0) { cacheItemPriority = _CacheItemPriority; } HttpContext.Current.Cache.Add(CacheKey, value, _CacheDependency, Expiration, Cache.NoSlidingExpiration, cacheItemPriority, null); }
public void Insert(string Key, object Obj, CacheDependency Dependency, double TimeOut, TimeSpan SlidingExpiration, CacheItemPriority Priority, CacheItemRemovedCallback RemovedCallback) { if ((Obj != null)) { Cache Cache = HttpRuntime.Cache; if (Cache [Key] == null) { Cache.Insert(Key, RuntimeHelpers.GetObjectValue(Obj), Dependency, DateTime.Now.AddSeconds(TimeOut), SlidingExpiration, Priority, RemovedCallback); } } }
public RedisCacheEntry(String key, Object value, DateTimeOffset absExp, TimeSpan slidingExp, CacheItemPriority priority) : base(key) { Value = value; State = new RedisCacheEntryState(absExp, slidingExp, priority, value.GetType().AssemblyQualifiedName); }
public AddKeyEventArgs(string key, object data, DateTime absoluteTimeout, TimeSpan slidingTimeout, string category, CacheItemPriority priority, string customRemoteData) { Key = key; Data = data; AbsoluteTimeout = absoluteTimeout; SlidingTimeout = slidingTimeout; Category = category; Priority = priority; CustomRemoteData = customRemoteData; }
public static IConfigurableRegistration CachedLifetime(this IConfigurableRegistration registration, CacheDependency dependency = null, CacheItemPriority itemPriority = CacheItemPriority.Default, CacheItemRemovedCallback itemRemovedCallback = null) { // HttpCachedLifetime / CachedLifetime ? if (registration == null) throw new ArgumentNullException("registration"); registration.SetLifetime(new CachedLifetime(dependency, itemPriority, itemRemovedCallback)); return registration; }
/// <summary> /// Makes a new Absolute Cache Expiration Settings /// </summary> public static ICacheExpirationSettings Make(int minutesToCache, CacheItemPriority cacheItemPriority = CacheItemPriority.Normal) { return new AbsoluteCacheExpirationSettings { CacheExpirationType = CacheExpirationType.Absolute, AbsoluteExpiration = DateTime.Now.AddMinutes(minutesToCache), SlidingExpiration = Cache.NoSlidingExpiration, Priority = cacheItemPriority }; }
/// <summary> /// Makes a new SlidingCacheExpirationSettings /// </summary> public static ICacheExpirationSettings Make(int slidingMinutes, CacheItemPriority cacheItemPriority = CacheItemPriority.AboveNormal) { return new SlidingCacheExpirationSettings { CacheExpirationType = CacheExpirationType.Sliding, AbsoluteExpiration = Cache.NoAbsoluteExpiration, SlidingExpiration = new TimeSpan(0, 0, slidingMinutes, 0), Priority = cacheItemPriority }; }
/// <summary> /// Makes a NeverExpiresCacheExpirationSettings /// </summary> public static ICacheExpirationSettings Make(CacheItemPriority cacheItemPriority = CacheItemPriority.Normal) { return new NeverExpiresCacheExpirationSettings { CacheExpirationType = CacheExpirationType.Never, AbsoluteExpiration = DateTime.UtcNow.AddYears(30), SlidingExpiration = Cache.NoSlidingExpiration, Priority = cacheItemPriority }; }
public CacheItemArgs(string key, int timeout, CacheItemPriority priority, params object[] parameters) : this(key) { _CacheTimeOut = timeout; _CachePriority = priority; _ParamList = new ArrayList(); foreach (object obj in parameters) { _ParamList.Add(obj); } }
public override void Insert(string Key, object Value, CommonLibrary.Services.Cache.CacheDependency Dependency, System.DateTime AbsoluteExpiration, System.TimeSpan SlidingExpiration, CacheItemPriority Priority, CacheItemRemovedCallback OnRemoveCallback) { CommonLibrary.Services.Cache.CacheDependency d = Dependency; if (IsWebFarm()) { string[] f = new string[1]; f[0] = GetFileName(Key); CreateCacheFile(f[0], Key); d = new CommonLibrary.Services.Cache.CacheDependency(f, null, Dependency); } base.Insert(Key, Value, d, AbsoluteExpiration, SlidingExpiration, Priority, OnRemoveCallback); }
/// <summary> /// 设置缓存,指定过期时间,不支持清除,依赖性 /// </summary> /// <param name="cacheKey">键</param> /// <param name="cacheObject">值</param> /// <param name="absoluteExpiration">固定的过期时间</param> /// <param name="cacheItemPriority">设置内存不足,缓存自动清除时,缓存的重要性,可不可以清除</param> public void SetCache(string cacheKey, object cacheObject, DateTime absoluteExpiration, CacheItemPriority cacheItemPriority) { System.Web.Caching.Cache objCache = HttpRuntime.Cache; objCache.Insert( cacheKey, cacheObject, null, absoluteExpiration, Cache.NoSlidingExpiration, cacheItemPriority, null ); }
/// <inheritdoc /> public IAndMemoryCacheEntryBuilder WithPriority(CacheItemPriority priority) { this.MemoryCacheEntry.Priority = priority; return(this); }
public virtual object Add(string CacheKey, object objObject, CacheDependency objDependency, DateTime AbsoluteExpiration, TimeSpan SlidingExpiration, CacheItemPriority Priority, CacheItemRemovedCallback OnRemoveCallback) { object retValue = GetItem(CacheKey); if (retValue == null) { Insert(CacheKey, objObject, new DNNCacheDependency(objDependency), AbsoluteExpiration, SlidingExpiration, Priority, OnRemoveCallback); } return(retValue); }
/// <summary> /// Constructor. /// </summary> public PriorityEvictionHint() { _hintType = EvictionHintType.PriorityEvictionHint; _priority = CacheItemPriority.Normal; }
public void Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations) { realCache.Add(key, value, scavengingPriority, refreshAction, expirations); }
/// <summary> /// Configures the cache region from configuration values /// </summary> /// <param name="settings">Configuration settings for the region</param> /// <param name="additionalProperties">The additional properties supplied by NHibernate engine</param> private void Configure(CacheRegionElement settings, IDictionary <string, string> additionalProperties) { log.Debug("Configuring cache region"); //these are some default conenction values that can be later used by the data dependencies //if no custome settings are specified string connectionName = null; string connectionString = null; if (additionalProperties != null) { //pick up connection settings that might be used later for data dependencis if any are specified if (additionalProperties.ContainsKey(Environment.ConnectionStringName)) { connectionName = additionalProperties[Environment.ConnectionStringName]; } if (additionalProperties.ContainsKey(Environment.ConnectionString)) { connectionString = additionalProperties[Environment.ConnectionString]; } } if (settings != null) { _priority = settings.Priority; _timeOfDayExpiration = settings.TimeOfDayExpiration; _relativeExpiration = settings.RelativeExpiration; if (log.IsDebugEnabled) { log.DebugFormat("using priority: {0}", settings.Priority.ToString("g")); if (_relativeExpiration.HasValue) { log.DebugFormat("using relative expiration :{0}", _relativeExpiration); } if (_timeOfDayExpiration.HasValue) { log.DebugFormat("using time of day expiration : {0}", _timeOfDayExpiration); } } CreateDependencyEnlisters(settings.Dependencies, connectionName, connectionString); } else { _priority = CacheItemPriority.Default; if (log.IsDebugEnabled) { log.DebugFormat("no priority specified using default : {0}", _priority.ToString("g")); } } //use the default expiration of no expiration was set if (_relativeExpiration.HasValue == false && _timeOfDayExpiration.HasValue == false) { _relativeExpiration = defaultRelativeExpiration; if (log.IsDebugEnabled) { log.DebugFormat("no expiration specified using default : {0}", _relativeExpiration); } } }
internal override void InsertOperation(string key, object value, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, LockHandle lockHandle, LockAccessType accessType, CacheDataNotificationCallback cacheItemUdpatedCallback, CacheDataNotificationCallback cacheItemRemovedCallaback, EventDataFilter itemUpdateDataFilter, EventDataFilter itemRemovedDataFilter, ref long size, bool allowQueryTags) { _webCache.InsertOperation(key, value, absoluteExpiration, slidingExpiration, priority, lockHandle, accessType, cacheItemUdpatedCallback, cacheItemRemovedCallaback, itemUpdateDataFilter, itemRemovedDataFilter, ref size, true); }
/// <summary> /// 插入缓存 /// </summary> /// <param name="key">用于引用该对象的缓存密钥</param> /// <param name="value">要插入到缓存的对象</param> /// <param name="dependencies">文件或缓存关键的依存关系所插入对象。 当任何依赖关系更改时,该对象将变为无效,并从缓存中删除。 如果没有依赖关系,此参数包含 null</param> /// <param name="absoluteExpiration">从该处插入的对象过期并从缓存中删除的时间。 若要避免的本地时间,如从标准时间到夏时制的更改可能存在的问题,请使用 System.DateTime.UtcNow,而不是 System.DateTime.Now 为此参数值。 如果您使用的绝对过期 slidingExpiration 参数必须是 System.Web.Caching.Cache.NoSlidingExpiration</param> /// <param name="slidingExpiration">对象的到期时间和上次访问所插入的对象的时间之间的间隔。 如果此值为 20 分钟的等效项,该对象会过期,可从缓存中删除上次访问后的 20 分钟。 如果您使用可调到期,absoluteExpiration 参数必须是 System.Web.Caching.Cache.NoAbsoluteExpiration</param> /// <param name="priority">与存储在缓存中,如通过所表示的其他项相关对象的成本 System.Web.Caching.CacheItemPriority 枚举。 逐出对象; 时,缓存使用此值具有较低的成本的对象会从缓存后再成本较高的对象</param> /// <param name="onRemoveCallback">从缓存中删除该对象之前将调用一个委托。 您可以用于更新缓存的项目,并确保它不删除从缓存</param> public static void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { _cache.Insert(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback); }
public static void SetCache(string CacheKey, object objObject, CacheDependency objDependency, DateTime AbsoluteExpiration, TimeSpan SlidingExpiration, CacheItemPriority Priority, CacheItemRemovedCallback OnRemoveCallback) { SetCache(CacheKey, objObject, new DNNCacheDependency(objDependency), AbsoluteExpiration, SlidingExpiration, Priority, OnRemoveCallback); }
public static void SetCache(string CacheKey, object objObject, DNNCacheDependency objDependency, DateTime AbsoluteExpiration, TimeSpan SlidingExpiration, CacheItemPriority Priority, CacheItemRemovedCallback OnRemoveCallback) { if (objObject != null) { //if no OnRemoveCallback value is specified, use the default method if (OnRemoveCallback == null) { OnRemoveCallback = ItemRemovedCallback; } CachingProvider.Instance().Insert(GetDnnCacheKey(CacheKey), objObject, objDependency, AbsoluteExpiration, SlidingExpiration, Priority, OnRemoveCallback); } }
//以下Set<T>为重载方法 /// <summary> /// 添加缓存(如果缓存键已经存在,则此方法调用无效) /// </summary> /// <typeparam name="T">类型</typeparam> /// <param name="key">缓存键</param> /// <param name="value">值</param> /// <param name="CacheTimeOption">缓存的时间长短</param> /// <param name="CacheExpirationOption"></param> /// <param name="dependencies">缓存依赖项</param> /// <param name="cacheItemPriority">优先级</param> public static void Set <T>(string key, T value, CacheTimeOption CacheTimeOption, CacheExpirationOption CacheExpirationOption, CacheDependency dependencies, CacheItemPriority cacheItemPriority) { Set(key, value, CacheTimeOption, CacheExpirationOption, dependencies, cacheItemPriority, null); }
object ICache.Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { DateTime expiration; if (slidingExpiration > TimeSpan.Zero) { expiration = OptimizedDateTime.Now.Add(slidingExpiration); } else { expiration = absoluteExpiration; } CacheItem item = new CacheItem(value, expiration); lock (this.items) { items.Add(key, item); } return(value); }
public static void Set(string cachekey, object value, int seconds, bool sliding, CacheItemPriority priority = CacheItemPriority.Default) { Set(cachekey, value, seconds, null, sliding, priority); }
/// <summary> /// 把值放到缓存里 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="cacheItemPriority">缓存优先级</param> public static void SetCacheItem(string key, object value, CacheItemPriority cacheItemPriority) { ICacheManager cache = CacheFactory.GetCacheManager("CacheManager"); cache.Add(key, value, cacheItemPriority, null, null); }
public static void Insert(string key, object obj, int seconds, CacheItemPriority priority) { Insert(key, obj, null, seconds, priority); }
public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority) { if (obj != null) { _cache.Insert(key, obj, dep, DateTime.Now.AddSeconds((double)(Factor * seconds)), TimeSpan.Zero, priority, null); } }
public virtual void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { HttpRuntime.Cache.Insert(key, value, dependencies, absoluteExpiration, Cache.NoSlidingExpiration, priority, onRemoveCallback); }
public override void Reset(CacheItemPriority cacheItemPriority) { _count = 1; }
/// <summary> /// Add a value to the cache with a relative expiry time, e.g 10 minutes. /// </summary> /// <typeparam name="TKey">The type of the key.</typeparam> /// <typeparam name="TValue">The type of the value.</typeparam> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <param name="slidingExpiry">The sliding time when the key value pair should expire and be purged from the cache.</param> /// <param name="priority">Normal priority will be purged on low memory warning.</param> public void Add <TKey, TValue>(TKey key, TValue value, TimeSpan slidingExpiry, CacheItemPriority priority = CacheItemPriority.Normal) where TValue : class { Add(key, value, slidingExpiry, priority, true); }
private void Insert(string key, object obj, CacheDependency dep, TimeSpan timeframe, CacheItemPriority priority, CacheItemRemovedCallback callback) { if (obj != null) { var cache = GetCache(); cache.Insert(key, obj, dep, DateTime.UtcNow.Add(timeframe), Cache.NoSlidingExpiration, priority, callback); } }
/// <summary> /// Add a value to the cache with an absolute time, e.g. 01/01/2020. /// </summary> /// <typeparam name="TKey">The type of the key.</typeparam> /// <typeparam name="TValue">The type of the value.</typeparam> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <param name="absoluteExpiry">The absolute date time when the cache should expire and be purged the value.</param> /// <param name="priority">Normal priority will be purged on low memory warning.</param> public void Add <TKey, TValue>(TKey key, TValue value, DateTime absoluteExpiry, CacheItemPriority priority = CacheItemPriority.Normal) where TValue : class { if (absoluteExpiry < DateTime.Now) { return; } var diff = absoluteExpiry - DateTime.Now; Add(key, value, diff, priority, false); }
public object Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { return(mCache.Add(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback)); }
public CacheItem(object value, CacheItemPriority priority, TimeSpan?relativeExpiry = null) { Value = value; Priority = priority; RelativeExpiry = relativeExpiry; }
void ICompactSerializable.Deserialize(CompactReader reader) { base.Deserialize(reader); _priority = (CacheItemPriority)Enum.ToObject(typeof(CacheItemPriority), reader.ReadInt16()); }
internal MemoryCacheEntry(string key, object value, DateTimeOffset absExp, TimeSpan slidingExp, CacheItemPriority priority, Collection <ChangeMonitor> dependencies, CacheEntryRemovedCallback removedCallback, MemoryCache cache) : base(key) { if (value == null) { throw new ArgumentNullException("value"); } this._utcCreated = DateTime.UtcNow; this._value = value; this._slidingExp = slidingExp; if (this._slidingExp > TimeSpan.Zero) { this._utcAbsExp = this._utcCreated + this._slidingExp; } else { this._utcAbsExp = absExp.UtcDateTime; } this._expiresEntryRef = System.Runtime.Caching.ExpiresEntryRef.INVALID; this._expiresBucket = 0xff; this._usageEntryRef = System.Runtime.Caching.UsageEntryRef.INVALID; if (priority == CacheItemPriority.NotRemovable) { this._usageBucket = 0xff; } else { this._usageBucket = 0; } this._callback = removedCallback; if (dependencies != null) { this._fields = new SeldomUsedFields(); this._fields._dependencies = dependencies; this._fields._cache = cache; } }
/// <summary> /// Overloaded Constructor /// Based on Priority Value /// </summary> /// <param name="priority"></param> public PriorityEvictionHint(CacheItemPriority priority) { _hintType = EvictionHintType.PriorityEvictionHint; _priority = priority; }
public static void InsertOutputIntoCache(double absoluteExpiration, double slidingExpiration, string cacheKey, object output, CacheDependency cacheDependency, CacheItemPriority priority) { InsertOutputIntoCache(absoluteExpiration, slidingExpiration, cacheKey, output, cacheDependency); }
public virtual void Insert(string cacheKey, object itemToCache, CacheDependency objDependency, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { Insert(cacheKey, itemToCache, new DNNCacheDependency(objDependency), absoluteExpiration, slidingExpiration, priority, onRemoveCallback); }
/// <param name="level">缓存级别[高于Normal的将不受定时缓存清理的限制]</param> public override void Add(string key, object value, string fileName, double cacheMinutes, CacheItemPriority level) { if (Contains(key)) { Remove(key); } Insert(key, value, fileName, cacheMinutes, level);//再插入Cache }
static void Set(string cachekey, object value, int seconds, string[] filedependencies = null, bool sliding = false, CacheItemPriority priority = CacheItemPriority.Default) { CacheItemPolicy policy = new CacheItemPolicy(); if (filedependencies != null) { policy.ChangeMonitors.Add(new HostFileChangeMonitor(new List <string>(filedependencies))); } if (sliding) { policy.SlidingExpiration = new TimeSpan(0, seconds, 0); } else { policy.AbsoluteExpiration = DateTimeOffset.UtcNow.AddSeconds(seconds); } policy.Priority = priority; Cacher.Current.Remove(cachekey); Cacher.Current.Add(new CacheItem(cachekey, value), policy); }
object ICache.Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback) { var cache = GetCache(); object addedObject = cache.Add(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback); return(addedObject); }