提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

.NET缓存设计的使用说明

Net缓存 使用 说明 设计
2023-06-13 09:14:47 时间

关于缓存的设计
1、什么情况下用缓存

缓存是提高应用程序性能的最好方法之一。运用缓存可以优化数据查询，避免不必要的网络数据回传，和避免执行不必要的完全相同的数据处理逻辑。在实现缓存的时候我们要确定什么时候装入缓存数据。用异步装入缓存或用批处理方式来避免出现客户端数据延迟。
一般来说在一定时间内请求了相同的业务逻辑而没有变更的话，可以采用缓存来设计。数据请求频繁的的请求不适合采用缓存，如论坛的回复，但是论坛的主题是可以采用缓存设计的。


2、缓存设计的步骤
确定缓存数据结构：即设计中哪些数据用到了缓存，设计这些数据的缓存结构
确定缓存什么数据
确定缓存过期规则和清理
确定如何装入缓存数据


3、示例CommunityServer的缓存类


复制代码代码如下:

usingSystem;
 usingSystem.Collections;
 usingSystem.Text.RegularExpressions;
 usingSystem.Web;
 usingSystem.Web.Caching;

 namespaceLarry.Cache
 {
     ///<summary>
    ///缓存类CommunityServer的缓存类
    ///</summary>
    publicclassBaseCache
    {
        ///<summary>
        ///CacheDependency说明
        ///如果您向Cache中添加某个具有依赖项的项，当依赖项更改时，
        ///该项将自动从Cache中删除。例如，假设您向Cache中添加某项，
        ///并使其依赖于文件名数组。当该数组中的某个文件更改时，
        ///与该数组关联的项将从缓存中删除。
        ///[C#]
        ///Insertthecacheitem.
        ///CacheDependencydep=newCacheDependency(fileName,dt);
        ///cache.Insert("key","value",dep);
        ///</summary>
        publicstaticreadonlyintDayFactor=;
        publicstaticreadonlyintHourFactor=;
        publicstaticreadonlyintMinuteFactor=;
        publicstaticreadonlydoubleSecondFactor=0.;

        privatestaticreadonlySystem.Web.Caching.Cache_cache;

        privatestaticintFactor=;

        ///<summary>
        ///单件模式
        ///</summary>
        staticBaseCache()
        {
            HttpContextcontext=HttpContext.Current;
            if(context!=null)
            {
                _cache=context.Cache;
            }
            else
            {
                _cache=HttpRuntime.Cache;
            }
        }

        ///<summary>
        ///一次性清除所有缓存
        ///</summary>
        publicstaticvoidClear()
        {
            IDictionaryEnumeratorCacheEnum=_cache.GetEnumerator();
            ArrayListal=newArrayList();
            while(CacheEnum.MoveNext())//逐个清除
            {
                al.Add(CacheEnum.Key);
            }

            foreach(stringkeyinal)
            {
                _cache.Remove(key);
            }

        }

 

        publicstaticvoidRemoveByPattern(stringpattern)
        {
            IDictionaryEnumeratorCacheEnum=_cache.GetEnumerator();
            Regexregex=newRegex(pattern,RegexOptions.IgnoreCase|RegexOptions.Singleline|RegexOptions.Compiled);
            while(CacheEnum.MoveNext())
            {
                if(regex.IsMatch(CacheEnum.Key.ToString()))
                    _cache.Remove(CacheEnum.Key.ToString());
            }
        }

        ///<summary>
        ///清除特定的缓存
        ///</summary>
        ///<paramname="key"></param>
        publicstaticvoidRemove(stringkey)
        {
            _cache.Remove(key);
        }

        ///<summary>
        ///缓存OBJECT.
        ///</summary>
        ///<paramname="key"></param>
        ///<paramname="obj"></param>
        publicstaticvoidInsert(stringkey,objectobj)
        {
            Insert(key,obj,null,);
        }

       ///<summary>
       ///缓存obj并建立依赖项
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="dep"></param>
       publicstaticvoidInsert(stringkey,objectobj,CacheDependencydep)
       {
           Insert(key,obj,dep,MinuteFactor*);
       }

       ///<summary>
       ///按秒缓存对象
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="seconds"></param>
       publicstaticvoidInsert(stringkey,objectobj,intseconds)
       {
           Insert(key,obj,null,seconds);
       }

       ///<summary>
       ///按秒缓存对象并存储优先级
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="seconds"></param>
       ///<paramname="priority"></param>
       publicstaticvoidInsert(stringkey,objectobj,intseconds,CacheItemPrioritypriority)
       {
           Insert(key,obj,null,seconds,priority);
       }

       ///<summary>
       ///按秒缓存对象并建立依赖项
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="dep"></param>
       ///<paramname="seconds"></param>
       publicstaticvoidInsert(stringkey,objectobj,CacheDependencydep,intseconds)
       {
           Insert(key,obj,dep,seconds,CacheItemPriority.Normal);
       }

       ///<summary>
       ///按秒缓存对象并建立具有优先级的依赖项
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="dep"></param>
       ///<paramname="seconds"></param>
       ///<paramname="priority"></param>
       publicstaticvoidInsert(stringkey,objectobj,CacheDependencydep,intseconds,CacheItemPrioritypriority)
       {
           if(obj!=null)
           {
               _cache.Insert(key,obj,dep,DateTime.Now.AddSeconds(Factor*seconds),TimeSpan.Zero,priority,null);
           }

       }


       publicstaticvoidMicroInsert(stringkey,objectobj,intsecondFactor)
       {
           if(obj!=null)
           {
               _cache.Insert(key,obj,null,DateTime.Now.AddSeconds(Factor*secondFactor),TimeSpan.Zero);
           }
       }

       ///<summary>
       ///最大时间缓存
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       publicstaticvoidMax(stringkey,objectobj)
       {
           Max(key,obj,null);
       }

       ///<summary>
       ///具有依赖项的最大时间缓存
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       ///<paramname="dep"></param>
       publicstaticvoidMax(stringkey,objectobj,CacheDependencydep)
       {
           if(obj!=null)
           {
               _cache.Insert(key,obj,dep,DateTime.MaxValue,TimeSpan.Zero,CacheItemPriority.AboveNormal,null);
           }
       }

       ///<summary>
       ///InsertanitemintothecachefortheMaximumallowedtime
       ///</summary>
       ///<paramname="key"></param>
       ///<paramname="obj"></param>
       publicstaticvoidPermanent(stringkey,objectobj)
       {
           Permanent(key,obj,null);
       }

       publicstaticvoidPermanent(stringkey,objectobj,CacheDependencydep)
       {
           if(obj!=null)
           {
               _cache.Insert(key,obj,dep,DateTime.MaxValue,TimeSpan.Zero,CacheItemPriority.NotRemovable,null);
           }
       }

       publicstaticobjectGet(stringkey)
       {
           return_cache[key];
       }

       ///<summary>
       ///Returnintofseconds*SecondFactor
       ///</summary>
       publicstaticintSecondFactorCalculate(intseconds)
       {
           //Insertmethodbelowtakesintegerseconds,sowehavetoroundanyfractionalvalues
           returnConvert.ToInt(Math.Round((double)seconds*SecondFactor));
       }
   }
}

其实这个类就是一个单件模式的设计和缓存的公共操作方法，其中CacheDependency表示建立缓存依赖项，CacheItemPriority表示缓存的优先级。S使用如下

复制代码代码如下:


 publicstaticCardShop.Model.SystemsGetConfig()
    {
        conststringcacheKey="WebConfig";
        CardShop.Model.SystemssampleCacheTable=Larry.Cache.BaseCache.Get(cacheKey)asCardShop.Model.Systems;
        if(sampleCacheTable==null)
        {
                                  OprationCheck.Message("第一次加载使用缓存");
            sampleCacheTable=model;
            Larry.Cache.BaseCache.Insert(cacheKey,sampleCacheTable,24*Larry.Cache.BaseCache.MinuteFactor);
       }
       else
       {
           OprationCheck.Message("已经加载了缓存不需要再加载");
       }
       returnsampleCacheTable;
   }

相关文章