关于缓存的设计
1、什么情况下用缓存
缓存是提高应用程序性能的最好方法之一。运用缓存可以优化数据查询,避免不必要的网络数据回传,和避免执行不必要的完全相同的数据处理逻辑。在实现缓存的时候我们要确定什么时候装入缓存数据。用异步装入缓存或用批处理方式来避免出现客户端数据延迟。
一般来说在一定时间内请求了相同的业务逻辑而没有变更的话,可以采用缓存来设计。数据请求频繁的的请求不适合采用缓存,如论坛的回复,但是论坛的主题是可以采用缓存设计的。
2、缓存设计的步骤
确定缓存数据结构:即设计中哪些数据用到了缓存,设计这些数据的缓存结构
确定缓存什么数据
确定缓存过期规则和清理
确定如何装入缓存数据
3、示例 Community Server的缓存类

1
using System;
2
using System.Collections;
3
using System.Text.RegularExpressions;
4
using System.Web;
5
using System.Web.Caching;
6
7
namespace Larry.Cache
8
{
9
/// <summary>
10
/// 缓存类 Community Server的缓存类
11
/// </summary>
12
public class BaseCache
13
{
14
/// <summary>
15
/// CacheDependency 说明
16
/// 如果您向 Cache 中添加某个具有依赖项的项,当依赖项更改时,
17
/// 该项将自动从 Cache 中删除。例如,假设您向 Cache 中添加某项,
18
/// 并使其依赖于文件名数组。当该数组中的某个文件更改时,
19
/// 与该数组关联的项将从缓存中删除。
20
/// [C#]
21
/// Insert the cache item.
22
/// CacheDependency dep = new CacheDependency(fileName, dt);
23
/// cache.Insert("key", "value", dep);
24
/// </summary>
25
public static readonly int DayFactor = 17280;
26
public static readonly int HourFactor = 720;
27
public static readonly int MinuteFactor = 12;
28
public static readonly double SecondFactor = 0.2;
29
30
private static readonly System.Web.Caching.Cache _cache;
31
32
private static int Factor = 1440;
33
34
/// <summary>
35
/// 单件模式
36
/// </summary>
37
static BaseCache()
38
{
39
HttpContext context = HttpContext.Current;
40
if (context != null)
41
{
42
_cache = context.Cache;
43
}
44
else
45
{
46
_cache = HttpRuntime.Cache;
47
}
48
}
49
50
/// <summary>
51
/// 一次性清除所有缓存
52
/// </summary>
53
public static void Clear()
54
{
55
IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
56
ArrayList al = new ArrayList();
57
while (CacheEnum.MoveNext()) //逐个清除
58
{
59
al.Add(CacheEnum.Key);
60
}
61
62
foreach (string key in al)
63
{
64
_cache.Remove(key);
65
}
66
67
}
68
69
70
71
public static void RemoveByPattern(string pattern)
72
{
73
IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
74
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Compiled);
75
while (CacheEnum.MoveNext())
76
{
77
if (regex.IsMatch(CacheEnum.Key.ToString()))
78
_cache.Remove(CacheEnum.Key.ToString());
79
}
80
}
81
82
/// <summary>
83
/// 清除特定的缓存
84
/// </summary>
85
/// <param name="key"></param>
86
public static void Remove(string key)
87
{
88
_cache.Remove(key);
89
}
90
91
/// <summary>
92
/// 缓存OBJECT.
93
/// </summary>
94
/// <param name="key"></param>
95
/// <param name="obj"></param>
96
public static void Insert(string key, object obj)
97
{
98
Insert(key, obj, null, 1);
99
}
100
101
/// <summary>
102
/// 缓存obj 并建立依赖项
103
/// </summary>
104
/// <param name="key"></param>
105
/// <param name="obj"></param>
106
/// <param name="dep"></param>
107
public static void Insert(string key, object obj, CacheDependency dep)
108
{
109
Insert(key, obj, dep, MinuteFactor * 3);
110
}
111
112
/// <summary>
113
/// 按秒缓存对象
114
/// </summary>
115
/// <param name="key"></param>
116
/// <param name="obj"></param>
117
/// <param name="seconds"></param>
118
public static void Insert(string key, object obj, int seconds)
119
{
120
Insert(key, obj, null, seconds);
121
}
122
123
/// <summary>
124
/// 按秒缓存对象 并存储优先级
125
/// </summary>
126
/// <param name="key"></param>
127
/// <param name="obj"></param>
128
/// <param name="seconds"></param>
129
/// <param name="priority"></param>
130
public static void Insert(string key, object obj, int seconds, CacheItemPriority priority)
131
{
132
Insert(key, obj, null, seconds, priority);
133
}
134
135
/// <summary>
136
/// 按秒缓存对象 并建立依赖项
137
/// </summary>
138
/// <param name="key"></param>
139
/// <param name="obj"></param>
140
/// <param name="dep"></param>
141
/// <param name="seconds"></param>
142
public static void Insert(string key, object obj, CacheDependency dep, int seconds)
143
{
144
Insert(key, obj, dep, seconds, CacheItemPriority.Normal);
145
}
146
147
/// <summary>
148
/// 按秒缓存对象 并建立具有优先级的依赖项
149
/// </summary>
150
/// <param name="key"></param>
151
/// <param name="obj"></param>
152
/// <param name="dep"></param>
153
/// <param name="seconds"></param>
154
/// <param name="priority"></param>
155
public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority)
156
{
157
if (obj != null)
158
{
159
_cache.Insert(key, obj, dep, DateTime.Now.AddSeconds(Factor * seconds), TimeSpan.Zero, priority, null);
160
}
161
162
}
163
164
165
public static void MicroInsert(string key, object obj, int secondFactor)
166
{
167
if (obj != null)
168
{
169
_cache.Insert(key, obj, null, DateTime.Now.AddSeconds(Factor * secondFactor), TimeSpan.Zero);
170
}
171
}
172
173
/// <summary>
174
/// 最大时间缓存
175
/// </summary>
176
/// <param name="key"></param>
177
/// <param name="obj"></param>
178
public static void Max(string key, object obj)
179
{
180
Max(key, obj, null);
181
}
182
183
/// <summary>
184
/// 具有依赖项的最大时间缓存
185
/// </summary>
186
/// <param name="key"></param>
187
/// <param name="obj"></param>
188
/// <param name="dep"></param>
189
public static void Max(string key, object obj, CacheDependency dep)
190
{
191
if (obj != null)
192
{
193
_cache.Insert(key, obj, dep, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.AboveNormal, null);
194
}
195
}
196
197
/// <summary>
198
/// Insert an item into the cache for the Maximum allowed time
199
/// </summary>
200
/// <param name="key"></param>
201
/// <param name="obj"></param>
202
public static void Permanent(string key, object obj)
203
{
204
Permanent(key, obj, null);
205
}
206
207
public static void Permanent(string key, object obj, CacheDependency dep)
208
{
209
if (obj != null)
210
{
211
_cache.Insert(key, obj, dep, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.NotRemovable, null);
212
}
213
}
214
215
public static object Get(string key)
216
{
217
return _cache[key];
218
}
219
220
/// <summary>
221
/// Return int of seconds * SecondFactor
222
/// </summary>
223
public static int SecondFactorCalculate(int seconds)
224
{
225
// Insert method below takes integer seconds, so we have to round any fractional values
226
return Convert.ToInt32(Math.Round((double)seconds * SecondFactor));
227
}
228
}
229
}
230
其实这个类就是一个单件模式的设计 和缓存的公共操作方法,其中CacheDependency表示建立缓存依赖项,CacheItemPriority表示缓存的优先级。S使用如下
1
public static CardShop.Model.Systems GetConfig()
2
{
3
const string cacheKey = "WebConfig";
4
CardShop.Model.Systems sampleCacheTable = Larry.Cache.BaseCache.Get(cacheKey) as CardShop.Model.Systems;
5
if (sampleCacheTable == null)
6
{
7
OprationCheck.Message("第一次加载使用缓存");
8
sampleCacheTable = model;
9
Larry.Cache.BaseCache.Insert(cacheKey, sampleCacheTable, 24 * Larry.Cache.BaseCache.MinuteFactor);
10
}
11
else
12
{
13
OprationCheck.Message("已经加载了缓存不需要再加载");
14
}
15
return sampleCacheTable;
16
}