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);
}
