正在考虑web应用缓存层的设计，参考了不少资料，估计还是需要用到相对成熟应用广泛的分布式缓存Memcached。在.net平台上早就有相对成熟的Memcached客户端产品，如BeITMemcached和EnyimMemcached，业余时间看了一下源码，自己分析并调用一下并不困难。这里简单介绍一下利用Memcached的一个简单的缓存层设计，示例代码基于EnyimMemcached，下面以贴代码为主。

一、公共缓存接口【DEMO下载】

分析asp.net web caching的缓存类，我们大致可以抽象出如下几个接口方法：

1. namespace DotNet.Common.EnyimCache 
2. { 
3.     /// <summary> 
4.     /// memcached公共缓存调用方法接口(读) 
5.     /// </summary> 
6.     public interface ICacheReaderService 
7.     { 
8.  
9.         /// <summary> 
10.         /// 返回指定key的对象 
11.         /// </summary> 
12.         /// <param name="key"></param> 
13.         /// <returns></returns> 
14.         object Get(string key); 
15.  
16.         /// <summary> 
17.         /// 返回指定key的对象 
18.         /// </summary> 
19.         /// <typeparam name="T"></typeparam> 
20.         /// <param name="key"></param> 
21.         /// <returns></returns> 
22.         T Get<T>(string key); 
23.  
24.         /// <summary> 
25.         /// 是否存在 
26.         /// </summary> 
27.         /// <param name="key"></param> 
28.         /// <returns></returns> 
29.         bool isExists(string key); 
30.     } 
31.  
32.     /// <summary> 
33.     /// memcached公共缓存调用方法接口(写) 
34.     /// </summary> 
35.     public interface ICacheWriterService 
36.     { 
37.         /// <summary> 
38.         /// 缓存有效间隔时间 (以分钟为单位) 
39.         /// </summary> 
40.         int TimeOut { set; get; } 
41.  
42.         /// <summary> 
43.         /// 添加指定key的对象 
44.         /// </summary> 
45.         /// <param name="key"></param> 
46.         /// <param name="obj"></param> 
47.         void Add(string key, object obj); 
48.  
49.         /// <summary> 
50.         /// 添加指定key的对象 
51.         /// </summary> 
52.         /// <typeparam name="T"></typeparam> 
53.         /// <param name="key"></param> 
54.         /// <param name="obj"></param> 
55.         void Add<T>(string key, T obj); 
56.  
57.         /// <summary> 
58.         /// 移除指定key的对象 
59.         /// </summary> 
60.         /// <param name="key"></param> 
61.         bool Remove(string key); 
62.  
63.         /// <summary> 
64.         /// 修改指定key的对象 
65.         /// </summary> 
66.         /// <param name="key"></param> 
67.         /// <returns></returns> 
68.         bool Modify(string key, object destObj); 
69.  
70.         /// <summary> 
71.         /// 清空缓存 
72.         /// </summary> 
73.         /// <returns></returns> 
74.         bool Release(); 
75.     } 
76. } 

看命名就知道，增删改查是也。根据个人使用缓存的经验，修改操作通常是不需要的，如果确实需要修改缓存数据，直接删除然后添加就是改了。

还有，你可能会问，这里为什么要定义两个接口？原因主要是考虑到读操作（查询）是经常使用的，而写操作（增删改）相对较少，所以也把它们设计成读写分离的方式。

二、缓存服务实现

这里就需要调用Memcached客户端封装好的调用方法，实现增删改查等方法。

1. using System; 
2.  
3. namespace DotNet.Common.EnyimCache 
4. { 
5.     using Enyim.Caching.Memcached; 
6.  
7.     public class CacheReaderService : BaseService, ICacheReaderService 
8.     { 
9.  
10.         public int TimeOut 
11.         { 
12.             get; 
13.             set; 
14.         } 
15.  
16.         public CacheReaderService() 
17.         { 
18.  
19.         } 
20.  
21.         public object Get(string key) 
22.         { 
23.             object obj = null; 
24.             Client.TryGet(key, out obj); 
25.             return obj; 
26.         } 
27.  
28.         public T Get<T>(string key) 
29.         { 
30.             object obj = Get(key); 
31.             T result = default(T); 
32.             if (obj != null) 
33.             { 
34.                 result = (T)obj; 
35.             } 
36.             return result; 
37.         } 
38.  
39.         public bool isExists(string key) 
40.         { 
41.             object obj = Get(key); 
42.             return (obj == null) ? false : true; 
43.         } 
44.     } 
45.  
46.     public class CacheWriterService : BaseService, ICacheWriterService 
47.     { 
48.         public int TimeOut 
49.         { 
50.             get; 
51.             set; 
52.         } 
53.  
54.         public CacheWriterService() 
55.         { 
56.  
57.         } 
58.  
59.         public CacheWriterService(int timeOut) 
60.         { 
61.             this.TimeOut = timeOut; 
62.         } 
63.  
64.         public void Add(string key, object obj) 
65.         { 
66.             if (TimeOut > 0) 
67.             { 
68.                 Client.Store(StoreMode.Add, key, obj, DateTime.Now.AddMinutes(TimeOut)); 
69.             } 
70.             else 
71.             { 
72.                 Client.Store(StoreMode.Add, key, obj); 
73.             } 
74.         } 
75.  
76.         public void Add<T>(string key, T obj) 
77.         { 
78.             if (TimeOut > 0) 
79.             { 
80.                 Client.Store(StoreMode.Add, key, obj, DateTime.Now.AddMinutes(TimeOut)); 
81.             } 
82.             else 
83.             { 
84.                 Client.Store(StoreMode.Add, key, obj); 
85.             } 
86.         } 
87.  
88.         public bool Remove(string key) 
89.         { 
90.             return Client.Remove(key); 
91.         } 
92.  
93.         public bool Modify(string key, object destObj) 
94.         { 
95.             return Client.Store(StoreMode.Set, key, destObj); 
96.         } 
97.  
98.         /// <summary> 
99.         /// 清空缓存 TO DO 
100.         /// </summary> 
101.         /// <returns></returns> 
102.         public bool Release() 
103.         { 
104.             throw new NotImplementedException(); 
105.         } 
106.     } 
107. } 

基类里初始化一个MemcachedClient示例Client，这个Client的方法里封装了较多的函数。查看源码可以知道，它们本质上都是 向Memcached服务端发送相关指令（run command），然后解析返回的二进制数据，如果您熟悉memcached所使用的协议，理解起来应该会相当简单。本文示例只使用了客户端提供的几个方 法。

同时要注意，在实现具体缓存服务的时候，CacheWriterService有两个构造函数，其中带参数的是为缓存显式指定过期时间。这个参数在实际应用中通常需要配置，显然是比较灵活一些的。

备注：在接口中有一个函数Release，本来的目标是清空所有的缓存数据，但是客户端没有直接提供对应的函数，如果您有好的方法，请不吝赐教。

三、简单的读写测试

贴一下字符串、时间、单个类和集合的增删改查示例代码：

1. ICacheWriterService writer = CacheBuilder.GetWriterService();//writer 使用memcached默认过期时间 
2. ICacheReaderService reader = CacheBuilder.GetReaderService();//reader 
3.  
4. #region 字符串 
5.  
6. string strKey = "hello"; 
7.  
8. bool isOK = writer.Remove(strKey); //移除 
9. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
10.  
11. writer.Add(strKey, "hello world"); //添加 
12. Console.WriteLine("Add key {0}, value:hello world", strKey); 
13.  
14. bool isExists = reader.isExists(strKey);//是否存在 
15. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
16.  
17. string result = reader.Get(strKey) as string;//查询 
18. Console.WriteLine("Get key {0}:{1}", strKey, result); 
19.  
20. bool isModify = writer.Modify(strKey, "Hello Memcached!");//修改 
21. Console.WriteLine("Modify key {0}, value:Hello Memcached. The result is:{1}", strKey, isModify); 
22.  
23. result = reader.Get<string>(strKey); 
24. Console.WriteLine("Generic get key {0}:{1}", strKey, result); 
25.  
26. isOK = writer.Remove(strKey); 
27. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
28.  
29. isExists = reader.isExists(strKey); 
30. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
31.  
32. result = reader.Get(strKey) as string; 
33. Console.WriteLine("Get key {0}:{1}", strKey, result); 
34.  
35. result = reader.Get<string>(strKey); 
36. Console.WriteLine("Generic get key {0}:{1}", strKey, result); 
37. Console.WriteLine(); 
38. Console.WriteLine("==========================================="); 
39. Console.Read(); 
40.  
41. #endregion 
42.  
43. #region 时间 
44.  
45. DateTime dtNow = DateTime.Now; 
46. strKey = "datetime"; 
47. isOK = writer.Remove(strKey); //移除 
48. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
49.  
50. writer.Add(strKey, dtNow); //添加 
51. Console.WriteLine("Add key {0}, value:{1}", strKey, dtNow); 
52.  
53. isExists = reader.isExists(strKey);//是否存在 
54. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
55.  
56. DateTime dt = (DateTime)reader.Get(strKey);//查询 
57. Console.WriteLine("Get key {0}:{1}", strKey, dt); 
58.  
59. dt = reader.Get<DateTime>(strKey); 
60. Console.WriteLine("Generic get key {0}:{1}", strKey, dt); 
61.  
62. isOK = writer.Remove(strKey); 
63. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
64.  
65. isExists = reader.isExists(strKey); 
66. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
67.  
68. Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey)); 
69.  
70. Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get<DateTime>(strKey));//default(datetime) 
71. Console.WriteLine(); 
72. Console.WriteLine("==========================================="); 
73.  
74. Console.Read(); 
75.  
76. #endregion 
77.  
78. #region 类 
79.  
80. dtNow = DateTime.Now; 
81. Province province = new Province(13579, "江苏", dtNow, dtNow); 
82.  
83. strKey = string.Format("{0}_{1}", province.GetType().Name, province.Id);//省 
84. isOK = writer.Remove(strKey); //移除 
85. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
86.  
87. writer.Add(strKey, province); //添加 
88. Console.WriteLine("Add key {0}, value:{1}", strKey, dtNow); 
89.  
90. isExists = reader.isExists(strKey);//是否存在 
91. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
92.  
93. Province queryProvince = (Province)reader.Get(strKey);//查询 
94. Console.WriteLine("Get key {0}:{1}", strKey, queryProvince.ProvinceName); 
95.  
96. queryProvince = reader.Get<Province>(strKey); 
97. Console.WriteLine("Generic get key {0}:{1}", strKey, queryProvince.ProvinceName); 
98.  
99. isOK = writer.Remove(strKey); 
100. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
101.  
102. isExists = reader.isExists(strKey); 
103. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
104.  
105. Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey)); 
106.  
107. Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get<Province>(strKey)); 
108. Console.WriteLine(); 
109. Console.WriteLine("==========================================="); 
110.  
111. Console.Read(); 
112.  
113. #endregion 
114.  
115. #region 集合(列表) 
116.  
117. dtNow = DateTime.Now; 
118. IList<City> listCities = new List<City>(); 
119. City city = new City(135, province.Id, "南京", "210000", dtNow, dtNow); 
120. listCities.Add(city); 
121. city = new City(246, province.Id, "苏州", "215000", dtNow, dtNow); 
122. listCities.Add(city); 
123.  
124. strKey = string.Format("List_{0}_{1}_{2}", province.GetType().Name, province.Id, city.GetType().Name);//省份对应城市 
125. isOK = writer.Remove(strKey); //移除 
126. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
127.  
128. writer.Add(strKey, listCities); //添加 
129. Console.WriteLine("Add key {0}, value:", strKey); 
130. foreach (var item in listCities) 
131. { 
132.     Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName); 
133. } 
134.  
135. isExists = reader.isExists(strKey);//是否存在 
136. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
137.  
138. IList<City> queryCities = reader.Get(strKey) as IList<City>;//查询 
139. Console.WriteLine("Get key {0}:", strKey); 
140. foreach (var item in queryCities) 
141. { 
142.     Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName); 
143. } 
144.  
145. queryCities = reader.Get<IList<City>>(strKey); 
146. Console.WriteLine("Generic get key {0}:", strKey); 
147. foreach (var item in queryCities) 
148. { 
149.     Console.WriteLine("CityId:{0} CityName:{1}", item.Id, item.CityName); 
150. } 
151.  
152. isOK = writer.Remove(strKey); 
153. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
154.  
155. isExists = reader.isExists(strKey); 
156. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
157.  
158. Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey)); 
159.  
160. Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get<IList<City>>(strKey)); 
161. Console.WriteLine(); 
162. Console.WriteLine("==========================================="); 
163.  
164. Console.Read(); 
165.  
166. #endregion 
167.  
168. #region 集合(字典) 
169.  
170. dtNow = DateTime.Now; 
171. IDictionary<int, City> dictCities = new Dictionary<int, City>(); 
172. city = new City(123, province.Id, "镇江", "212000", dtNow, dtNow); 
173. dictCities.Add(city.Id, city); 
174. city = new City(321, province.Id, "扬州", "225000", dtNow, dtNow); 
175. dictCities.Add(city.Id, city); 
176.  
177. strKey = string.Format("Dictionary_{0}_{1}_{2}", province.GetType().Name, province.Id, city.GetType().Name);//省份对应城市 
178. isOK = writer.Remove(strKey); //移除 
179. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
180.  
181. writer.Add(strKey, dictCities); //添加 
182. Console.WriteLine("Add key {0}, value:", strKey); 
183. foreach (var item in dictCities) 
184. { 
185.     Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName); 
186. } 
187.  
188. isExists = reader.isExists(strKey);//是否存在 
189. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
190.  
191. IDictionary<int, City> queryDictCities = reader.Get(strKey) as IDictionary<int, City>;//查询 
192. Console.WriteLine("Get key {0}:", strKey); 
193. foreach (var item in queryDictCities) 
194. { 
195.     Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName); 
196. } 
197.  
198. queryDictCities = reader.Get<IDictionary<int, City>>(strKey); 
199. Console.WriteLine("Generic get key {0}:", strKey); 
200. foreach (var item in queryDictCities) 
201. { 
202.     Console.WriteLine("CityId:{0} CityName:{1}", item.Key, item.Value.CityName); 
203. } 
204.  
205. isOK = writer.Remove(strKey); 
206. Console.WriteLine("Removed key {0}:{1}", strKey, isOK); 
207.  
208. isExists = reader.isExists(strKey); 
209. Console.WriteLine("Key {0} exists:{1}", strKey, isExists); 
210.  
211. Console.WriteLine("Get key {0}:{1}", strKey, reader.Get(strKey)); 
212.  
213. Console.WriteLine("Generic get key {0}:{1}", strKey, reader.Get<IDictionary<int, City>>(strKey)); 
214. Console.WriteLine(); 
215. Console.WriteLine("==========================================="); 
216.  
217. Console.Read(); 
218.  
219. #endregion 

这里就不贴全部代码了，文章最后有示例可以下载。

在我的简单测试中，对常见基础数据类型如（字符串、数组、数字和时间）、集合（列表和字典）都有良好的表现，对datatable和dataset同样表现不俗，但是不太建议直接缓存这两种重粒度的类型。

在显式指定过期时间的示例中，指定过期时间是一分钟，但是memcached实际过期时间有时候好像会多于一分钟，估计是系统内部的延迟。

在本地计算机上进行10万次循环添加缓存的过程中，发现系统内存果然增加的非常厉害。然后查询性能并没有显著下降，也许和我的单机测试环境有关，所以我认为测试结果并没有说服力，要知道，memcached的优势是它的分布式缓存实现。

有人发现如何保证缓存系统的键唯一也非常令人头疼。同样的缓存框架，不同项目不同开发者如何保证自己程序添加的缓存键唯一呢？有一种简单方法就是通 过拼接字符串成为有意义的主键，比如按照项目名、命名空间、类名、数据库中的主键组合构成主键等等。当然了，在查询的时候也要自己封装特定格式的字符串主 键。个人感觉确实是一个行之有效的方法。