在之前一篇随笔《
在.NET项目中使用PostSharp,实现AOP面向切面编程处理
》介绍了PostSharp框架的使用,试用PostSharp能给我带来很多便利和优势,减少代码冗余,提高可读性,并且可以更加优雅的实现常规的日志、异常、缓存、事务等业务场景的处理。本篇主要介绍使用MemoryCache实现缓存的处理。

1、MemoryCache的介绍回顾

上篇没有提及缓存的处理,一般情况下,缓存的处理我们可以利用微软的分布式缓存组件MemoryCache进行缓存的处理操作。MemoryCache的使用网上介绍的不多,不过这个是.NET4.0新引入的缓存对象,主要是替换原来企业库的缓存模块,使得.NET的缓存可以无处不在,而不用基于特定的Windows版本上使用。

缓存在很多情况下需要用到,合理利用缓存可以一方面可以提高程序的响应速度,同时可以减少对特定资源访问的压力。本文主要针对自己在Winform方面的缓存使用做一个引导性的介绍,希望大家能够从中了解一些缓存的使用场景和使用方法。缓存是一个中大型系统所必须考虑的问题。为了避免每次请求都去访问后台的资源(例如数据库),我们一般会考虑将一些更新不是很频繁的,可以重用的数据,通过一定的方式临时地保存起来,后续的请求根据情况可以直接访问这些保存起来的数据。这种机制就是所谓的缓存机制。

.NET 4.0的缓存功能主要由三部分组成:System.Runtime.Caching,System.Web.Caching.Cache和Output Cache。

System.Runtime.Caching这是在.NET 4.0中新增的缓存框架,主要是使用MemoryCache对象,该对象存在于程序集System.Runtime.Caching.dll。

System.Web.Caching.Cache这个则是在.NET2.0开始就一直存在的缓存对象,一般主要用在Web中,当然也可以用于Winform里面,不过要引用System.Web.dll。

Output Cache则是Asp.NET里面使用的,在ASP.NET 4.0之前的版本都是直接使用System.Web.Caching.Cache来缓存HTML片段。在ASP.NET 4.0中对它进行了重新设计,提供了一个OutputCacheProvider供开发人员进行扩展,但是它默认情况下,仍然使用System.Web.Caching.Cache来做做缓存

我在之前的一篇随笔《
Winform里面的缓存使用
》曾经介绍了MemoryCache辅助类的处理,用来方便实现缓存的数据操作。它的辅助类主要代码如下所示。

    /// <summary>
    ///基于MemoryCache的缓存辅助类/// </summary>
    public static classMemoryCacheHelper
{
private static readonly Object locker = new object();/// <summary> ///创建一个缓存的键值,并指定响应的时间范围,如果失效,则自动获取对应的值/// </summary> /// <typeparam name="T">对象类型</typeparam> /// <param name="key">对象的键</param> /// <param name="cachePopulate">获取缓存值的操作</param> /// <param name="slidingExpiration">失效的时间范围</param> /// <param name="absoluteExpiration">失效的绝对时间</param> /// <returns></returns> public static T GetCacheItem<T>(String key, Func<T> cachePopulate, TimeSpan? slidingExpiration = null, DateTime? absoluteExpiration = null)
{
if(String.IsNullOrWhiteSpace(key)) throw new ArgumentException("Invalid cache key");if(cachePopulate == null) throw new ArgumentNullException("cachePopulate");if(slidingExpiration == null && absoluteExpiration == null) throw new ArgumentException("Either a sliding expiration or absolute must be provided");if(MemoryCache.Default[key] == null)
{
lock(locker)
{
if(MemoryCache.Default[key] == null)
{
var item = newCacheItem(key, cachePopulate());var policy =CreatePolicy(slidingExpiration, absoluteExpiration);

MemoryCache.Default.Add(item, policy);
}
}
}
return(T)MemoryCache.Default[key];
}
private static CacheItemPolicy CreatePolicy(TimeSpan? slidingExpiration, DateTime?absoluteExpiration)
{
var policy = newCacheItemPolicy();if(absoluteExpiration.HasValue)
{
policy.AbsoluteExpiration
=absoluteExpiration.Value;
}
else if(slidingExpiration.HasValue)
{
policy.SlidingExpiration
=slidingExpiration.Value;
}

policy.Priority
=CacheItemPriority.Default;returnpolicy;
}
/// <summary> ///清空缓存/// </summary> public static voidClearCache()
{
List
<string> cacheKeys = MemoryCache.Default.Select(kvp =>kvp.Key).ToList();foreach (string cacheKey incacheKeys)
{
MemoryCache.Default.Remove(cacheKey);
}
}

...//省略部分代码

}

而我们在程序中,如果需要使用缓存,那么调用这个辅助类来解决,也算是比较方便的,实现缓存的代码如下所示。

    public static classUserCacheService
{
/// <summary> ///获取用户全部简单对象信息,并放到缓存里面/// </summary> /// <returns></returns> public static List<SimpleUserInfo>GetSimpleUsers()
{
System.Reflection.MethodBase method
=System.Reflection.MethodBase.GetCurrentMethod();string key = string.Format("{0}-{1}", method.DeclaringType.FullName, method.Name);return MemoryCacheHelper.GetCacheItem<List<SimpleUserInfo>>(key,delegate() {//return CallerFactory<IUserService>.Instance.GetSimpleUsers();//模拟从数据库获取数据 List<SimpleUserInfo> list = new List<SimpleUserInfo>();for(int i = 0; i< 10; i++)
{
var info = newSimpleUserInfo();
info.ID
=i;
info.Name
= string.Concat("Name:", i);
info.FullName
= string.Concat("姓名:", i);
list.Add(info);
}
returnlist;
},
new TimeSpan(0, 10, 0));//10分钟过期 }/// <summary> ///根据用户的ID,获取用户的登陆名称,并放到缓存里面/// </summary> /// <param name="userId">用户的ID</param> /// <returns></returns> public static string GetNameByID(stringuserId)
{
string result = "";if (!string.IsNullOrEmpty(userId))
{
System.Reflection.MethodBase method
=System.Reflection.MethodBase.GetCurrentMethod();string key = string.Format("{0}-{1}-{2}", method.DeclaringType.FullName, method.Name, userId);

result
= MemoryCacheHelper.GetCacheItem<string>(key,delegate() {//return CallerFactory<IUserService>.Instance.GetNameByID(userId.ToInt32()); return string.Concat("Name:", userId);
},
new TimeSpan(0, 30, 0));//30分钟过期 }returnresult;
}

上面案例我模拟构造数据库数据返回,否则一般使用BLLFactory<T>、或者混合框架客户端里面使用CallerFactory<T>进行调用接口了,相当于需要对它们进行进一步的函数封装处理才能达到目的。

案例中可以设置失效缓存时间,并且失效后,自动通过Func<T> cachePopulate的函数重新获取缓存内容,在实际情况下,也是非常智能的一种处理方式。

2、结合PostSharp和MemoryCache实现缓存

上面的案例使用MemoryCache辅助类来实现缓存的处理,能够解决实际的问题,不过同时问题也来了,每次缓存处理,都需要写一段额外的代码进行处理,代码的冗余就非常多了,而且一旦很多地方采用缓存,那么维护这些代码就很成问题。

我们希望引入PostSharp技术,来减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。这种AOP的代码织入技术能够很好分离横切面和业务处理,从而实现简化代码的目的。

就上面的代码问题,我们来看看,引入PostSharp后,我们的代码是如何实现缓存处理的。

    /// <summary>
    ///使用PostSharp,结合MemoryCache实现缓存的处理类/// </summary>
    public classCacheService
{
/// <summary> ///获取用户全部简单对象信息,并放到缓存里面/// </summary> /// <returns></returns> [Cache(ExpirationPeriod = 30)]public static List<SimpleUserInfo> GetSimpleUsers(intuserid)
{
//return CallerFactory<IUserService>.Instance.GetSimpleUsers();//模拟从数据库获取数据 List<SimpleUserInfo> list = new List<SimpleUserInfo>();for (int i = 0; i < 10; i++)
{
var info = newSimpleUserInfo();
info.ID
=i;
info.Name
= string.Concat("Name:", i);
info.FullName
= string.Concat("姓名:", i);
list.Add(info);
}
returnlist;
}
/// <summary> ///根据用户的ID,获取用户的登陆名称,并放到缓存里面/// </summary> /// <param name="userId">用户的ID</param> /// <returns></returns> [Cache]public static string GetNameByID(stringuserId)
{
//return CallerFactory<IUserService>.Instance.GetNameByID(userId.ToInt32()); return string.Concat("Name:", userId);
}
}

我们注意到了上面的函数代码,除了调用业务逻辑(这里构造数据演示)外,其实是没有多余的其他代码的。不过我们是在函数开始进行了一个特性的标识:

[Cache(ExpirationPeriod = 30)]

或者

[Cache]

这个就是我们声明使用缓存处理的函数,如此而已,是不是非常简单了。

我们来看看生成后的代码反编译得到的结果,如下所示。

这个和我们实际的代码是不太一样的,这里整合了PostSharp的织入代码,从而能够实现缓存的处理操作了,但是我们在开发过程中是透明的,只需要维护好自己编写的代码即可。

这个里面需要使用了CacheAttribute来进行标识,这个类的代码就是使用了PostSharp的基类进行处理了

    /// <summary>
    ///方法实现缓存的标识/// </summary>
[Serializable]public classCacheAttribute : MethodInterceptionAspect
{
/// <summary> ///缓存的失效时间设置,默认采用30分钟/// </summary> public int ExpirationPeriod = 30;/// <summary> ///PostSharp的调用处理,实现数据的缓存处理/// </summary> public override voidOnInvoke(MethodInterceptionArgs args)
{
//默认30分钟失效,如果设置过期时间,那么采用设置值 TimeSpan timeSpan = new TimeSpan(0, 0, ExpirationPeriod, 0);var cache =MethodResultCache.GetCache(args.Method, timeSpan);var arguments = args.Arguments.ToList(); var result =cache.GetCachedResult(arguments);if (result != null)
{
args.ReturnValue
=result;return;
}
else{base.OnInvoke(args);//调用后重新更新缓存 cache.CacheCallResult(args.ReturnValue, arguments);
}
}
}

这个CacheAttribute特性类包含一个设置失效的时间间隔(分钟),来指定函数返回结果的失效时间的,通过继承MethodInterceptionAspect基类,我们重写了void OnInvoke(MethodInterceptionArgs args)函数,从而对调用过程的横切面进行介入:

如果调用过程中获得缓存结果,则直接返回,不需要调用函数业务逻辑;否则调用函数获得返回值,并重新设置缓存结果值。

在函数代码里面,通过传入参数(包括方法对象、超时时间等)实现方法缓存对象的构建。

MethodResultCache.GetCache(args.Method, timeSpan);

在MethodResultCache里面,我们就是对方法的缓存进行处理的,首先需要声明一个MemoryCache的对象用于管理缓存(分布式缓存)。

        /// <summary>
        ///初始化缓存管理器/// </summary>
        private voidInitCacheManager()
{
_cache
= newMemoryCache(_methodName);
}

其中通过函数获取方法和参数的键,也就是唯一的键。

        /// <summary>
        ///根据调用方法名称和参数获取缓存键/// </summary>
        /// <param name="arguments">方法的参数列表</param>
        /// <returns></returns>
        private string GetCacheKey(IEnumerable<object>arguments)
{
var key = string.Format("{0}({1})", _methodName,string.Join(",", arguments.Select(x => x != null ? x.ToString() : "<Null>")));returnkey;
}

设置缓存的操作,我们就是调用MemoryCache缓存管理类来实现的键值设置的,如下代码所示。

        /// <summary>
        ///缓存结果内容/// </summary>
        /// <param name="result">待加入缓存的结果</param>
        /// <param name="arguments">方法的参数集合</param>
        public void CacheCallResult(object result, IEnumerable<object>arguments)
{
_cache.Set(GetCacheKey(arguments), result, DateTimeOffset.Now.Add(_expirationPeriod));
}

这样我们就设置了一个键值的缓存,并指定了缓存的失效时间,在这个时间段内,我们每次获取的数据,不需要再次调用外部接口,直接从缓存里面获取,速度提高很多,同时也减轻了分布式构架中的服务器承载的IO压力。

我们可以编写一小段代码进行测试出来的效率,如下代码所示。

            //First test
            DateTime start =DateTime.Now;var list = CacheService.GetSimpleUsers(1);int end = (int)DateTime.Now.Subtract(start).TotalMilliseconds;

Console.WriteLine(
"first:" +end);//Second test start =DateTime.Now;
list
= CacheService.GetSimpleUsers(2);
end
= (int)DateTime.Now.Subtract(start).TotalMilliseconds;
Console.WriteLine(
"Second:" + end);

获得的结果如下所示(分别介绍获得结果的时间)。

 first: 519Second:501first:0Second:0first:0Second:0

从上面代码可以看出,第一次请求数据的有一定的时间差,后面请求毫秒数则是直接0了。

通过上面的 PostSharp和MemoryCache的整合,我们可以极大简化了缓存的处理代码,并且能够利用较为不错的MemoryCache缓存管理类来实现缓存的处理,非常方便和高效了。

标签: none

添加新评论