コード例 #1
0
		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);
			}
		}
コード例 #2
0
ファイル: CacheItem.cs プロジェクト: christrotter/NCache
		/// <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;
		}
コード例 #3
0
 /// <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;
 }
コード例 #4
0
ファイル: AddCommand.cs プロジェクト: javithalion/NCache
        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;
        }
コード例 #5
0
 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);
 }
コード例 #6
0
 public CacheItemArgs(string key)
 {
     _CacheKey = key;
     _CacheTimeOut = 20;
     _CachePriority = CacheItemPriority.Default;
     //_ParamList = new ArrayList();
 }
コード例 #7
0
ファイル: CacheItem.cs プロジェクト: wuyingyou/uniframework
        /// <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();
        }
コード例 #8
0
ファイル: DataCache.cs プロジェクト: huaminglee/myyyyshop
 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);
     }
 }
コード例 #9
0
 public CacheItemArgs(string key, int timeout)
     : this(key)
 {
     _CacheTimeOut = timeout;
     _CachePriority = CacheItemPriority.Default;
     //_ParamList = new ArrayList();
 }
コード例 #10
0
ファイル: CacheItem.cs プロジェクト: Tony-Liang/Common
        public CacheItem(string key, object value, CacheItemPriority scavengingPriority,params ICacheItemExpiration[] expirations)
        {
            Initialize(key, value, scavengingPriority, expirations);

            TouchedByUserAction(false);
            InitializeExpirations();
        }
コード例 #11
0
ファイル: CacheHelper.cs プロジェクト: pyfxl/fxlweb
 /// <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;
 }
コード例 #12
0
		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;
		}
コード例 #13
0
ファイル: InsertCommand.cs プロジェクト: javithalion/NCache
        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;
        }
コード例 #14
0
ファイル: CacheHelper.cs プロジェクト: pyfxl/fxlweb
 /// <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;
 }
コード例 #15
0
        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;
        }
コード例 #16
0
ファイル: MangaCache.cs プロジェクト: shaohaiou/comopp
 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);
 }
コード例 #17
0
        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);
        }
コード例 #18
0
ファイル: CacheOperate.cs プロジェクト: JuRogn/OA
        /// <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);
            }

        }
コード例 #19
0
 public RedisCacheEntry(String key,
     Object value,
     DateTimeOffset absoluteExpiration,
     TimeSpan slidingExpiration,
     CacheItemPriority priority)
     : this(key, value, absoluteExpiration, slidingExpiration, priority.ToString())
 {
 }
コード例 #20
0
ファイル: CacheManager.cs プロジェクト: ajhCMS/AJH.CMS.WEB.UI
 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);
 }
コード例 #21
0
		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);
				}
			}
		}
コード例 #22
0
 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);
 }
コード例 #23
0
 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;
 }
コード例 #24
0
        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;
        }
コード例 #25
0
		/// <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
			};
		}
コード例 #26
0
		/// <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
			};
		}
コード例 #27
0
		/// <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
			};
		}
コード例 #28
0
 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);
     }
 }
コード例 #29
0
 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);
 }
コード例 #30
0
ファイル: CacheProvider.cs プロジェクト: aNd1coder/Wojoz
 /// <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
     );
 }
コード例 #31
0
 /// <inheritdoc />
 public IAndMemoryCacheEntryBuilder WithPriority(CacheItemPriority priority)
 {
     this.MemoryCacheEntry.Priority = priority;
     return(this);
 }
コード例 #32
0
        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);
        }
コード例 #33
0
 /// <summary>
 /// Constructor.
 /// </summary>
 public PriorityEvictionHint()
 {
     _hintType = EvictionHintType.PriorityEvictionHint;
     _priority = CacheItemPriority.Normal;
 }
コード例 #34
0
 public void Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)
 {
     realCache.Add(key, value, scavengingPriority, refreshAction, expirations);
 }
コード例 #35
0
        /// <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);
                }
            }
        }
コード例 #36
0
ファイル: WrapperCache.cs プロジェクト: yaobos/NCache
 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);
 }
コード例 #37
0
ファイル: CacheHelper.cs プロジェクト: yimsungnam/ZqUtils
 /// <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);
 }
コード例 #38
0
ファイル: DataCache.cs プロジェクト: netromedia/Dnn.Platform
 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);
 }
コード例 #39
0
ファイル: DataCache.cs プロジェクト: netromedia/Dnn.Platform
 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);
     }
 }
コード例 #40
0
ファイル: RedisHelper.cs プロジェクト: lcx19910911/DOL
 //以下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);
 }
コード例 #41
0
ファイル: Cache.cs プロジェクト: lmm713281/DataCommander
        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);
        }
コード例 #42
0
ファイル: Cacher.cs プロジェクト: moayyaed/cms-2
 public static void Set(string cachekey, object value, int seconds, bool sliding, CacheItemPriority priority = CacheItemPriority.Default)
 {
     Set(cachekey, value, seconds, null, sliding, priority);
 }
コード例 #43
0
        /// <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);
        }
コード例 #44
0
ファイル: WebCache.cs プロジェクト: tyriankid/equipmentTest
 public static void Insert(string key, object obj, int seconds, CacheItemPriority priority)
 {
     Insert(key, obj, null, seconds, priority);
 }
コード例 #45
0
ファイル: WebCache.cs プロジェクト: tyriankid/equipmentTest
 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);
     }
 }
コード例 #46
0
 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);
 }
コード例 #47
0
 public override void Reset(CacheItemPriority cacheItemPriority)
 {
     _count = 1;
 }
コード例 #48
0
 /// <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);
 }
コード例 #49
0
 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);
     }
 }
コード例 #50
0
        /// <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);
        }
コード例 #51
0
 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));
 }
コード例 #52
0
 public CacheItem(object value, CacheItemPriority priority, TimeSpan?relativeExpiry = null)
 {
     Value          = value;
     Priority       = priority;
     RelativeExpiry = relativeExpiry;
 }
コード例 #53
0
 void ICompactSerializable.Deserialize(CompactReader reader)
 {
     base.Deserialize(reader);
     _priority = (CacheItemPriority)Enum.ToObject(typeof(CacheItemPriority), reader.ReadInt16());
 }
コード例 #54
0
 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;
     }
 }
コード例 #55
0
 /// <summary>
 /// Overloaded Constructor
 /// Based on Priority Value
 /// </summary>
 /// <param name="priority"></param>
 public PriorityEvictionHint(CacheItemPriority priority)
 {
     _hintType = EvictionHintType.PriorityEvictionHint;
     _priority = priority;
 }
コード例 #56
0
 public static void InsertOutputIntoCache(double absoluteExpiration, double slidingExpiration, string cacheKey, object output, CacheDependency cacheDependency, CacheItemPriority priority)
 {
     InsertOutputIntoCache(absoluteExpiration, slidingExpiration, cacheKey, output, cacheDependency);
 }
コード例 #57
0
 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);
 }
コード例 #58
0
 /// <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
 }
コード例 #59
0
ファイル: Cacher.cs プロジェクト: moayyaed/cms-2
        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);
        }
コード例 #60
0
ファイル: Cache.cs プロジェクト: lmm713281/DataCommander
        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);
        }