private void AddTask(string name, int seconds)
{
_onCacheRemove = CacheItemRemoved;
HttpRuntime.Cache.Insert(name, seconds, null,
DateTime.Now.AddSeconds(seconds), Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable, _onCacheRemove);
}
internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
if (!BuildResultCompiledType.UsesDelayLoadType(result))
{
ICollection virtualPathDependencies = result.VirtualPathDependencies;
CacheDependency dependencies = null;
if (virtualPathDependencies != null)
{
dependencies = result.VirtualPath.GetCacheDependency(virtualPathDependencies, utcStart);
if (dependencies != null)
{
result.UsesCacheDependency = true;
}
}
if (result.CacheToMemory)
{
CacheItemPriority normal;
BuildResultCompiledAssemblyBase base2 = result as BuildResultCompiledAssemblyBase;
if (((base2 != null) && (base2.ResultAssembly != null)) && !base2.UsesExistingAssembly)
{
string assemblyCacheKey = BuildResultCache.GetAssemblyCacheKey(base2.ResultAssembly);
Assembly assembly = (Assembly) this._cache.Get(assemblyCacheKey);
if (assembly == null)
{
this._cache.UtcInsert(assemblyCacheKey, base2.ResultAssembly, null, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
}
CacheDependency dependency2 = new CacheDependency(0, null, new string[] { assemblyCacheKey });
if (dependencies != null)
{
AggregateCacheDependency dependency3 = new AggregateCacheDependency();
dependency3.Add(new CacheDependency[] { dependencies, dependency2 });
dependencies = dependency3;
}
else
{
dependencies = dependency2;
}
}
string memoryCacheKey = GetMemoryCacheKey(cacheKey);
if (result.IsUnloadable)
{
normal = CacheItemPriority.Normal;
}
else
{
normal = CacheItemPriority.NotRemovable;
}
CacheItemRemovedCallback onRemoveCallback = null;
if (result.ShutdownAppDomainOnChange || (result is BuildResultCompiledAssemblyBase))
{
if (this._onRemoveCallback == null)
{
this._onRemoveCallback = new CacheItemRemovedCallback(this.OnCacheItemRemoved);
}
onRemoveCallback = this._onRemoveCallback;
}
this._cache.UtcInsert(memoryCacheKey, result, dependencies, result.MemoryCacheExpiration, result.MemoryCacheSlidingExpiration, normal, onRemoveCallback);
}
}
}
/// <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;
}
private void AddTask(string name, int seconds)
{
_onCacheRemove = new CacheItemRemovedCallback(CacheItemRemoved);
HttpRuntime.Cache.Insert(name, seconds, null,
DateTime.Now.AddSeconds(seconds), System.Web.Caching.Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable, _onCacheRemove);
}
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);
}
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;
}
/// <summary>
/// 添加缓存 (绝对有效期)
/// </summary>
/// <param name="cacheKey">缓存键值</param>
/// <param name="cacheValue">缓存内容</param>
/// <param name="timeout">绝对有效期（单位: 秒）</param>
public static void Set(string cacheKey, object cacheValue, int timeout)
{
if (string.IsNullOrEmpty(cacheKey))
{
return;
}
if (null == cacheValue)
{
Remove(cacheKey);
return;
}
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
if (timeout <= 0)
{
cache.Insert(cacheKey, cacheValue, null, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.High, callBack);
}
else
{
cache.Insert(cacheKey, cacheValue, null, DateTime.Now.AddSeconds(timeout), System.Web.Caching.Cache.NoSlidingExpiration, CacheItemPriority.High, callBack);
}
}
/// <summary>
/// 本地缓存写入，包括分钟，是否绝对过期及缓存过期的回调
/// </summary>
/// <param name="name">key</param>
/// <param name="value">value</param>
/// <param name="minutes"缓存分钟></param>
/// <param name="isAbsoluteExpiration">是否绝对过期</param>
/// <param name="onRemoveCallback">缓存过期回调</param>
public static void Set(string name, object value, int minutes, bool isAbsoluteExpiration, CacheItemRemovedCallback onRemoveCallback)
{
if (isAbsoluteExpiration)
HttpRuntime.Cache.Insert(name, value, null, DateTime.Now.AddMinutes(minutes), Cache.NoSlidingExpiration, CacheItemPriority.Normal, onRemoveCallback);
else
HttpRuntime.Cache.Insert(name, value, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(minutes), CacheItemPriority.Normal, onRemoveCallback);
}
private void BindSignal(string virtualPath, CacheItemRemovedCallback callback)
{
string key = _prefix + virtualPath;
//PERF: Don't add in the cache if already present. Creating a "CacheDependency"
// object (below) is actually quite expensive.
if (HostingEnvironment.Cache.Get(key) != null)
return;
var cacheDependency = HostingEnvironment.VirtualPathProvider.GetCacheDependency(
virtualPath,
new[] { virtualPath },
_clock.UtcNow);
Logger.Debug("Monitoring virtual path \"{0}\"", virtualPath);
HostingEnvironment.Cache.Add(
key,
virtualPath,
cacheDependency,
Cache.NoAbsoluteExpiration,
Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable,
callback);
}
//TODO: Fix this so the timer doesn't keep running during unit tests.
public void StartTimer(int secondInterval)
{
_onCacheRemove = DoWork;
HttpRuntime.Cache.Insert(GetType().ToString(), secondInterval, null,
DateTime.Now.AddSeconds(secondInterval), Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable, _onCacheRemove);
}
/// <summary>
/// 加入当前对象到缓存中
/// </summary>
/// <param name="objId">key for the object</param>
/// <param name="o">object</param>
public void AddObject(string objId, object o)
{
if (objId == null || objId.Length == 0 || o == null)
return;
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
webCacheforfocus.Insert(objId, o, null, DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, 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);
}
public override void Initialize(string name, NameValueCollection config)
{
if (String.IsNullOrEmpty(name))
name = "InProc Session State Provider";
base.Initialize(name, config);
_callback = new CacheItemRemovedCallback(this.OnCacheItemRemoved);
}
static void RemoveFileWithDelayInternal(string fileKey, object fileData, int delay, CacheItemRemovedCallback removeAction) {
string key = RemoveTaskKeyPrefix + fileKey;
if(HttpRuntime.Cache[key] == null) {
DateTime absoluteExpiration = DateTime.UtcNow.Add(new TimeSpan(0, delay, 0));
HttpRuntime.Cache.Insert(key, fileData, null, absoluteExpiration,
Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, removeAction);
}
}
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);
}
private void AddTask(string taskName, int seconds)
{
// http://blog.stackoverflow.com/2008/07/easy-background-tasks-in-aspnet/
OnCacheRemove = new CacheItemRemovedCallback(CacheItemRemoved);
HttpRuntime.Cache.Insert(taskName, seconds, null,
DateTime.Now.AddSeconds(seconds), Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable, OnCacheRemove);
}
public void Insert(string key, object value, CacheItemRemovedCallback cacheItemRemovedCallback, params string[] fileDependencies)
{
if (key.HasValue() && value != null)
{
HttpRuntime.Cache.Insert(key, value, fileDependencies.Any() ? new CacheDependency(fileDependencies) : null,
System.Web.Caching.Cache.NoAbsoluteExpiration, System.Web.Caching.Cache.NoSlidingExpiration,
CacheItemPriority.Normal, cacheItemRemovedCallback);
}
}
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);
}
}
}
/// <summary>
/// 增加一个缓存对象
/// </summary>
/// <param name="strKey">键值名称</param>
/// <param name="valueObj">被缓存对象</param>
/// <param name="timeSpan">缓存失效时间，默认为3分钟</param>
/// <param name="priority">保留优先级(枚举数值)，1最不会被清除，6最容易被内存管理清除,0为default
/// 【1:NotRemovable；2:High；3:AboveNormal；4:Normal；5:BelowNormal；6:Low】</param>
/// <returns>缓存写入是否成功true 、 false</returns>
public static bool InsertCache(string strKey, object valueObj, TimeSpan timeSpan, int priority)
{
TimeSpan ts;
if (strKey != null && strKey.Length != 0 && valueObj != null)
{
//建立回调委托的一个实例
//onRemove是委托执行的函数，具体方法看下面的onRemove(...)
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
#region 失效时间设置
if (timeSpan == null)
{
ts = new TimeSpan(0, 3, 0);//如果不进行设置则为三分钟
}
else
{
ts = timeSpan;
}
#endregion
#region System.Web.Caching.Cache 对象中存储的项的相对优先级
CacheItemPriority cachePriority;
switch (priority)
{
case 6:
cachePriority = CacheItemPriority.Low;
break;
case 5:
cachePriority = CacheItemPriority.BelowNormal;
break;
case 4:
cachePriority = CacheItemPriority.Normal;
break;
case 3:
cachePriority = CacheItemPriority.AboveNormal;
break;
case 2:
cachePriority = CacheItemPriority.High;
break;
case 1:
cachePriority = CacheItemPriority.NotRemovable;
break;
default:
cachePriority = CacheItemPriority.Default;
break;
}
#endregion
HttpRuntime.Cache.Insert(strKey, valueObj, null, DateTime.Now.Add(ts), System.Web.Caching.Cache.NoSlidingExpiration, cachePriority, callBack);
return true;
}
else
{
return false;
}
}
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;
}
private void Add(String key, Object value, DateTime absoluteExpiration, TimeSpan slidingExpiration, System.Web.Caching.CacheItemPriority priority, CacheItemRemovedCallback callback)
{
if (value == null)
{
this.Delete(key);
}
else
{
HttpRuntime.Cache.Add(key, value, null, absoluteExpiration, slidingExpiration, priority, callback);
}
}
public void AddItemToCache(Object sender, EventArgs e)
{
itemRemoved = false;
onRemove = new CacheItemRemovedCallback(RemovedCallback);
if (Cache["Key1"] == null)
Cache.Add("Key1", "Value 1", null, DateTime.Now.AddSeconds(60), Cache.NoSlidingExpiration, CacheItemPriority.High, onRemove);
lblResult.Text = "Value of cache key: " + Cache["Key1"];
}
public static void InsertType (Type type, string filename, string key,
CacheItemRemovedCallback removed_callback)
{
//string [] cacheKeys = new string [] { cachePrefix + filename };
//CacheDependency dep = new CacheDependency (null, cacheKeys);
CacheDependency dep = new CacheDependency (filename);
HttpRuntime.Cache.Insert (cacheTypePrefix + key, type, dep,
Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
CacheItemPriority.Normal, removed_callback);
}
/// <summary>
/// 加入当前对象到缓存中
/// </summary>
/// <param name="objId">对象的键值</param>
/// <param name="o">缓存的对象</param>
public virtual void AddObjectWith(string objId, object o)
{
if (objId == null || objId.Length == 0 || o == null)
{
return;
}
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
webCache.Insert(objId, o, null, System.DateTime.Now.AddSeconds(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <param name="minutes"></param>
/// <param name="cacheDependency"></param>
/// <param name="removeCallback"></param>
public void Insert(string key, object obj, int minutes, CacheDependency cacheDependency, CacheItemRemovedCallback removeCallback)
{
if (String.IsNullOrEmpty(key) || key.Equals("")) return;
if (null == obj) return;
if (minutes >0)
_cache.Insert(key, obj, cacheDependency, DateTime.Now.AddSeconds(minutes * 60), TimeSpan.Zero, CacheItemPriority.High, removeCallback);
else
_cache.Insert(key, obj, cacheDependency, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.High, removeCallback);
}
public void Init (HttpApplication app)
{
app.AddOnResolveRequestCacheAsync (
new BeginEventHandler (OnBeginRequestCache),
new EndEventHandler (OnEndRequestCache));
app.AddOnUpdateRequestCacheAsync (
new BeginEventHandler (OnBeginUpdateCache),
new EndEventHandler (OnEndUpdateCache));
response_removed = new CacheItemRemovedCallback (OnRawResponseRemoved);
}
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="CacheName">对象的键值</param>
/// <param name="o">缓存的对象</param>
/// <param name="dependKey">依赖关联的键值</param>
public void AddObjectWithDepend(string CacheName, object o, string[] DependKey)
{
if (CacheName == null || CacheName.Length == 0 || o == null)
{
return;
}
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(CacheOnRemove);
CacheDependency dep = new CacheDependency(null, DependKey, DateTime.Now);
webcache.Insert(CacheName, o, dep, System.DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
private void AddTask(string name, int seconds)
{
try
{
_onCacheRemove = CacheItemRemoved;
HttpRuntime.Cache.Insert(name, seconds, null,
DateTime.Now.AddSeconds(seconds), Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable, _onCacheRemove);
}
catch (Exception ex)
{
logger.Warn("AddTask", ex);
}
}
/// <summary>
/// Inserts the specified cache key.
/// </summary>
/// <param name="cacheKey">The cache key.</param>
/// <param name="itemToCache">The value.</param>
/// <param name="dependency">The dependency.</param>
/// <param name="absoluteExpiration">The absolute expiration.</param>
/// <param name="slidingExpiration">The sliding expiration.</param>
/// <param name="priority">The priority.</param>
/// <param name="onRemoveCallback">The on remove callback.</param>
public virtual void Insert(string cacheKey, object itemToCache, DNNCacheDependency dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority,
CacheItemRemovedCallback onRemoveCallback)
{
Cache.Insert(cacheKey, itemToCache, dependency == null ? null : dependency.SystemCacheDependency, absoluteExpiration, slidingExpiration, priority, onRemoveCallback);
}
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);
}
/// <summary>
/// Adds the specified entry to the cache.
/// </summary>
/// <param name="key">The entry key.</param>
/// <param name="value">The entry value.</param>
/// <param name="dependentEntitySets">The list of dependent entity sets.</param>
/// <param name="slidingExpiration">The sliding expiration.</param>
/// <param name="absoluteExpiration">The absolute expiration.</param>
/// <param name="callback">callback</param>
private void PutItemExec(string key, object value, IEnumerable <string> dependentEntitySets, TimeSpan slidingExpiration, DateTime absoluteExpiration, CacheItemRemovedCallback callback)
{
key = GetCacheKey(key);
var cache = HttpCache;
CacheDependency cd = null;
if (dependentEntitySets != null)
{
var l = dependentEntitySets.ToList();
foreach (var entitySet in l)
{
EnsureEntryExists(DependentEntitySetPrefix + entitySet);
}
if (l.Count > 0)
{
cd = new CacheDependency(new string[0], l.Select(c => DependentEntitySetPrefix + c).ToArray());
}
}
try
{
cache.Insert(key, value, cd, absoluteExpiration, slidingExpiration, CacheItemPriority.Normal, callback);
}
catch (Exception ex)
{
while (ex != null)
{
Logger.Error(ex);
ex = ex.InnerException;
}
// there's a possibility that one of the dependencies has been evicted by another thread
// in this case just don't put this item in the cache
}
}
public T Add <T>(string cacheKey, T value, ICacheItemExpiration expiration, CacheItemRemovedCallback removeCallback = null)
{
throw new NotImplementedException();
}
/// <summary>
/// Cache_Add
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="cacheValue">object value</param>
/// <param name="keepMinutes"></param>
/// <param name="dependencies">缓存的依赖项，也就是此项的更改意味着缓存内容已经过期。如果没有依赖项，可将此值设置为NULL。</param>
/// <param name="cacheItemRemovedCallback">表示缓存删除数据对象时调用的事件，一般用做通知程序。</param>
/// <returns></returns>
public static Boolean Cache_Add(string cacheKey, object cacheValue, DateTime expireTime, CacheDependency dependencies = null, CacheItemRemovedCallback cacheItemRemovedCallback = null)
{
HttpRuntime.Cache.Insert(cacheKey, cacheValue, dependencies, expireTime, Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, cacheItemRemovedCallback);
return(true);
}
public void InsertCacheItem(string cacheKey, Func <object> getCacheItem, TimeSpan?timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
{
CacheDependency dependency = null;
if (dependentFiles != null && dependentFiles.Any())
{
dependency = new CacheDependency(dependentFiles);
}
InsertCacheItem(cacheKey, getCacheItem, timeout, isSliding, priority, removedCallback, dependency);
}
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);
}
/// <summary>
/// This overload is here for legacy purposes
/// </summary>
/// <param name="cacheKey"></param>
/// <param name="getCacheItem"></param>
/// <param name="timeout"></param>
/// <param name="isSliding"></param>
/// <param name="priority"></param>
/// <param name="removedCallback"></param>
/// <param name="dependency"></param>
/// <returns></returns>
internal object GetCacheItem(string cacheKey, Func <object> getCacheItem, TimeSpan?timeout, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, CacheDependency dependency = null)
{
cacheKey = GetCacheKey(cacheKey);
// NOTE - because we don't know what getCacheItem does, how long it will take and whether it will hang,
// getCacheItem should run OUTSIDE of the global application lock else we run into lock contention and
// nasty performance issues.
// So.... we insert a Lazy<object> in the cache while holding the global application lock, and then rely
// on the Lazy lock to ensure that getCacheItem runs once and everybody waits on it, while the global
// application lock has been released.
// NOTE
// The Lazy value creation may produce a null value.
// Must make sure (for backward compatibility) that we pretend they are not in the cache.
// So if we find an entry in the cache that already has its value created and is null,
// pretend it was not there. If value is not already created, wait... and return null, that's
// what prior code did.
// NOTE
// The Lazy value creation may throw.
// So... the null value _will_ be in the cache but never returned
Lazy <object> result;
// Fast!
// Only one thread can enter an UpgradeableReadLock at a time, but it does not prevent other
// threads to enter a ReadLock in the meantime -- only upgrading to WriteLock will prevent all
// reads. We first try with a normal ReadLock for maximum concurrency and take the penalty of
// having to re-lock in case there's no value. Would need to benchmark to figure out whether
// it's worth it, though...
try
{
_locker.EnterReadLock();
result = _cache.Get(cacheKey) as Lazy <object>; // null if key not found
}
finally
{
if (_locker.IsReadLockHeld)
{
_locker.ExitReadLock();
}
}
var value = result == null ? null : GetSafeLazyValue(result);
if (value != null)
{
return(value);
}
using (var lck = new UpgradeableReadLock(_locker))
{
result = _cache.Get(cacheKey) as Lazy <object>; // null if key not found
// cannot create value within the lock, so if result.IsValueCreated is false, just
// do nothing here - means that if creation throws, a race condition could cause
// more than one thread to reach the return statement below and throw - accepted.
if (result == null || GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
{
result = GetSafeLazy(getCacheItem);
var absolute = isSliding ? System.Web.Caching.Cache.NoAbsoluteExpiration : (timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value));
var sliding = isSliding == false ? System.Web.Caching.Cache.NoSlidingExpiration : (timeout ?? System.Web.Caching.Cache.NoSlidingExpiration);
lck.UpgradeToWriteLock();
//NOTE: 'Insert' on System.Web.Caching.Cache actually does an add or update!
_cache.Insert(cacheKey, result, dependency, absolute, sliding, priority, removedCallback);
}
}
// using GetSafeLazy and GetSafeLazyValue ensures that we don't cache
// exceptions (but try again and again) and silently eat them - however at
// some point we have to report them - so need to re-throw here
// this does not throw anymore
//return result.Value;
value = result.Value; // will not throw (safe lazy)
if (value is ExceptionHolder eh)
{
eh.Exception.Throw(); // throw once!
}
return(value);
}
/// <summary>
/// This overload is here for legacy purposes
/// </summary>
/// <param name="cacheKey"></param>
/// <param name="getCacheItem"></param>
/// <param name="timeout"></param>
/// <param name="isSliding"></param>
/// <param name="priority"></param>
/// <param name="removedCallback"></param>
/// <param name="dependency"></param>
internal void InsertCacheItem(string cacheKey, Func <object> getCacheItem, TimeSpan?timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, CacheDependency dependency = null)
{
// NOTE - here also we must insert a Lazy<object> but we can evaluate it right now
// and make sure we don't store a null value.
var result = GetSafeLazy(getCacheItem);
var value = result.Value; // force evaluation now - this may throw if cacheItem throws, and then nothing goes into cache
if (value == null)
{
return; // do not store null values (backward compat)
}
cacheKey = GetCacheKey(cacheKey);
var absolute = isSliding ? System.Web.Caching.Cache.NoAbsoluteExpiration : (timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value));
var sliding = isSliding == false ? System.Web.Caching.Cache.NoSlidingExpiration : (timeout ?? System.Web.Caching.Cache.NoSlidingExpiration);
try
{
_locker.EnterWriteLock();
//NOTE: 'Insert' on System.Web.Caching.Cache actually does an add or update!
_cache.Insert(cacheKey, result, dependency, absolute, sliding, priority, removedCallback);
}
finally
{
if (_locker.IsWriteLockHeld)
{
_locker.ExitWriteLock();
}
}
}
/// <summary>
/// 本地缓存写入，包括分钟，是否绝对过期及缓存过期的回调
/// </summary>
/// <param name="name">key</param>
/// <param name="value">value</param>
/// <param name="minutes"缓存分钟></param>
/// <param name="isAbsoluteExpiration">是否绝对过期</param>
/// <param name="onRemoveCallback">缓存过期回调</param>
public static void Set(string name, object value, int minutes, bool isAbsoluteExpiration, CacheItemRemovedCallback onRemoveCallback)
{
if (isAbsoluteExpiration)
{
HttpRuntime.Cache.Insert(name, value, null, DateTime.Now.AddMinutes(minutes), Cache.NoSlidingExpiration, CacheItemPriority.Normal, onRemoveCallback);
}
else
{
HttpRuntime.Cache.Insert(name, value, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(minutes), CacheItemPriority.Normal, onRemoveCallback);
}
}
//------------------------提供给上面方法进行调用-----------------------------------
/// <summary>
/// 设置缓存
/// </summary>
public static bool Set(string key, object value, CacheDependency cacheDependency, DateTime dateTime,
TimeSpan timeSpan, CacheItemPriority cacheItemPriority, CacheItemRemovedCallback cacheItemRemovedCallback)
{
if (string.IsNullOrEmpty(key) || value == null)
{
return(false);
}
HttpRuntime.Cache.Insert(key, value, cacheDependency, dateTime, timeSpan, cacheItemPriority,
cacheItemRemovedCallback);
return(true);
}
public Object Add(string key, Object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback)
{
return(default(Object));
}
/// <summary>
/// 添加缓存(如果缓存键已经存在，则此方法调用无效)
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">缓存键</param>
/// <param name="value">值</param>
/// <param name="callback">回调函数</param>
/// <param name="CacheTimeOption">缓存时间</param>
public static void Set <T>(string key, T value, CacheTimeOption CacheTimeOption, CacheItemRemovedCallback callback)
{
Set(key, value, CacheTimeOption, CacheExpirationOption.AbsoluteExpiration, null, CacheItemPriority.NotRemovable, callback);
}
private static void SetPageCache(string key, object value, DNNCacheDependency dependency, FriendlyUrlSettings settings, CacheItemRemovedCallback callback)
{
DateTime absoluteExpiration = DateTime.Now.Add(settings.CacheTime);
DataCache.SetCache(key,
value,
dependency,
absoluteExpiration,
Cache.NoSlidingExpiration,
CacheItemPriority.AboveNormal,
callback);
}
// 主调方法
/// <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>
/// <param name="callback">回调函数</param>
public static void Set <T>(string key, T value, CacheTimeOption CacheTimeOption, CacheExpirationOption CacheExpirationOption,
CacheDependency dependencies, CacheItemPriority cacheItemPriority, CacheItemRemovedCallback callback)
{
if (!value.Equals(default(T)) && CacheTimeOption != CacheTimeOption.None)
{
DateTime absoluteExpiration = GetAbsoluteExpirationTime(CacheTimeOption, CacheExpirationOption);
TimeSpan slidingExpiration = GetSlidingExpirationTime(CacheTimeOption, CacheExpirationOption);
HttpRuntime.Cache.Add(key, value, dependencies, absoluteExpiration, slidingExpiration, cacheItemPriority, callback);
}
}
public static void Insert(string key, object value, CacheDependency dependency, CacheItemPriority priority, CacheItemRemovedCallback callback)
{
_cache.Insert(key, value, dependency, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(SaveTime), priority, callback);
}
/// <summary>
/// Cache_Add
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="cacheValue">object value</param>
/// <param name="keepMinutes"></param>
/// <param name="dependencies">缓存的依赖项，也就是此项的更改意味着缓存内容已经过期。如果没有依赖项，可将此值设置为NULL。</param>
/// <param name="cacheItemRemovedCallback">表示缓存删除数据对象时调用的事件，一般用做通知程序。</param>
/// <returns></returns>
public static Boolean Cache_Add(string cacheKey, object cacheValue, int keepMinutes = 10, CacheDependency dependencies = null, CacheItemRemovedCallback cacheItemRemovedCallback = null)
{
HttpRuntime.Cache.Insert(cacheKey, cacheValue, dependencies, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(keepMinutes), CacheItemPriority.NotRemovable, cacheItemRemovedCallback);
return(true);
}
public static void Insert(string key, object value, CacheDependency dependency, CacheItemRemovedCallback callback)
{
Insert(key, value, dependency, CacheItemPriority.Default, callback);
}
public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback)
{
TCache.Insert(key, obj, dep, seconds, priority, onRemoveCallback);
}
/// <summary>
/// 建立缓存
/// </summary>
public static object TryAddCache(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemovedCallback)
{
if (GetCache(key) == null && value != null)
{
return(HttpRuntime.Cache.Add(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemovedCallback));
}
else
{
return(null);
}
}
public T Add <T>(string cacheKey, T value, TimeSpan?expire = null, CacheItemRemovedCallback removeCallback = null)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public void Insert(string key, Func <object> factory, TimeSpan?timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
{
InnerCache.Insert(key, () =>
{
var result = FastDictionaryAppCacheBase.GetSafeLazy(factory);
var value = result.Value; // force evaluation now - this may throw if cacheItem throws, and then nothing goes into cache
// do not store null values (backward compat), clone / reset to go into the cache
return(value == null ? null : CheckCloneableAndTracksChanges(value));
}, timeout, isSliding, priority, removedCallback, dependentFiles);
}
/// <summary>
/// 建立一个Exist缓存
/// </summary>
protected void TryAddExistCache(object existKey, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemovedCallback)
{
string key = basicKey + CACHEHEADER_EXISTS + existKey.ToString();
TryAddCache(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemovedCallback);
}
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>
/// 增加一个缓存对象
/// </summary>
/// <param name="strKey">键值名称</param>
/// <param name="valueObj">被缓存对象</param>
/// <param name="durationMin">缓存失效时间，默认为3分钟</param>
/// <param name="priority">保留优先级(枚举数值)，1最不会被清除，6最容易被内存管理清除,0为default
/// 【1:NotRemovable；2:High；3:AboveNormal；4:Normal；5:BelowNormal；6:Low】</param>
/// <returns>缓存写入是否成功true 、 false</returns>
public static bool InsertCach(string strKey, object valueObj, int durationMin, int priority)
{
TimeSpan ts;
if (strKey != null && strKey.Length != 0 && valueObj != null)
{
//建立回调委托的一个实例
//onRemove是委托执行的函数，具体方法看下面的onRemove(...)
var callBack = new CacheItemRemovedCallback(OnRemove);
#region 失效时间设置
if (durationMin == 0)
{
ts = new TimeSpan(0, 3, 0);//如果不进行设置则为三分钟
}
else
{
ts = new TimeSpan(0, durationMin, 0);
}
#endregion
#region System.Web.Caching.Cache 对象中存储的项的相对优先级
CacheItemPriority cachePriority;
switch (priority)
{
case 6:
cachePriority = CacheItemPriority.Low;
break;
case 5:
cachePriority = CacheItemPriority.BelowNormal;
break;
case 4:
cachePriority = CacheItemPriority.Normal;
break;
case 3:
cachePriority = CacheItemPriority.AboveNormal;
break;
case 2:
cachePriority = CacheItemPriority.High;
break;
case 1:
cachePriority = CacheItemPriority.NotRemovable;
break;
default:
cachePriority = CacheItemPriority.Default;
break;
}
#endregion
HttpContext.Current.Cache.Insert(strKey, valueObj, null, DateTime.Now.Add(ts), System.Web.Caching.Cache.NoSlidingExpiration, cachePriority, callBack);
return(true);
}
else
{
return(false);
}
}
private CacheItem CreateCacheItem <T>(string cacheKey, Func <T> factory, Func <ICacheItemExpiration> expiration, CacheItemRemovedCallback removeCallback)
{
cacheDictionary.CheckCapacity(cacheKey, Capacity, optimizer.CurrentMaxGen, NotifyCacheRemoved);
return(new CacheItem(
cacheKey,
factory(),
expiration == null ? null : expiration(),
removeCallback));
}
/// <summary>
/// 将对象插入到缓存管理器中。
/// </summary>
/// <typeparam name="T">缓存对象的类型。</typeparam>
/// <param name="cacheKey">用于引用对象的缓存键。</param>
/// <param name="value">要插入到缓存的对象。</param>
/// <param name="expire">对象存放于缓存中的有效时间，到期后将从缓存中移除。如果此值为 null，则默认有效时间为 30 分钟。</param>
/// <param name="removeCallback">当对象从缓存中移除时，使用该回调方法通知应用程序。</param>
public T Add <T>(string cacheKey, T value, TimeSpan?expire = null, CacheItemRemovedCallback removeCallback = null)
{
cacheDictionary.AddOrUpdate(cacheKey, () => CreateCacheItem(cacheKey, () => value, () => expire == null ? RelativeTime.Default : new RelativeTime(expire.Value), removeCallback));
return(value);
}
/// <summary>
/// 将对象插入到缓存管理器中。
/// </summary>
/// <typeparam name="T">缓存对象的类型。</typeparam>
/// <param name="cacheKey">用于引用对象的缓存键。</param>
/// <param name="value">要插入到缓存的对象。</param>
/// <param name="expiration">判断对象过期的对象。</param>
/// <param name="removeCallback">当对象从缓存中移除时，使用该回调方法通知应用程序。</param>
public T Add <T>(string cacheKey, T value, ICacheItemExpiration expiration, CacheItemRemovedCallback removeCallback = null)
{
cacheDictionary.AddOrUpdate(cacheKey, () => CreateCacheItem(cacheKey, () => value, () => expiration ?? RelativeTime.Default, removeCallback));
return(value);
}
private void AddTask(string name, int seconds)
{
OnCacheRemove = new CacheItemRemovedCallback(CacheItemRemoved);
HttpRuntime.Cache.Insert(name, seconds, null, DateTime.Now.AddSeconds(seconds), Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, OnCacheRemove);
}
public void Insert(string key, Object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback)
{
}
