C# 基础数据缓存

最近做一个C#项目，刚做完基础数据，现把缓存机制给大家分享一下：

做过基础数据的同学应该都知道，每次涉及到查询数据时都会去数据库把配置好的基础数据查询出来，这样每次在操作是会很慢。那么我们每次点开一个新页面都会去数据库查询一下基础数据，这样会频繁的连接数据库，用户多了之后肯定就会特别慢。因为数据一旦配好之后就会很少去改动它，所以我们可以做一个缓存把每次查询出来的基础数据缓存起来，这样就可以提高查询效率。好了，废话不多说了，上代码。

我声明一下我用的是Dictionary数据字典，您也可以使用Cache等等别的技术，实现机制都一样。

     我使用了一个接口，一个抽象类，一个工厂类，一个普通类。

首先我们得定义设置缓存，获取缓存，删除缓存的方法，还要定义缓存的大小，太大了就会不好控制，消耗内存。在接口中定义方法，然后用抽象类继承接口实现方法，因为缓存是一直保存在整个网站运行期间，所以不能实例化它，我们得用abstract类，用工厂模式实现调用。 需要注意一点就是我们可以定义Dictionary里面的类型为泛型类而不用object类型，这样在使用的时候就不用装箱，拆箱。

 以下是接口ICache代码：

/// <summary> 
/// 设置缓存 
/// </summary> 
/// <param name="key"></param> 
/// <param name="value"></param> 
void SetCache(TKey key, TValue value);

/// <summary> 
/// 获取缓存 
/// </summary> 
/// <param name="key"></param> 
/// <returns></returns> 
TValue GetCache(TKey key);

/// <summary> 
/// 清空指定缓存 
/// </summary> 
void Clear(TKey key);

/// <summary> 
/// 清空当前登录用户的缓存 
/// </summary> 
/// <param name="key"></param> 
void ClearAll();

/// <summary> 
/// 定义缓存Key 
/// </summary> 
/// <param name="key"></param> 
/// <returns></returns> 
TKey JoinKey(TKey key);

/// <summary> 
/// 缓存大小 
/// </summary> 
int CacheSize { get; set; }

接着，我们用一个抽象类(AbstractCache)继承接口,这里面的大部分都是虚方法，因为我们在使用的时候考虑到还有别的缓存，所以可以在继承类里面重写这些方法。

public AbstractCache(string type) 
{ 
this._type = type; 
if (AbstractCache<TKey, TValue>._cacheList == null) 
{ 
AbstractCache<TKey, TValue>._cacheList = new Dictionary<string, Dictionary<TKey, TValue>>(); 
} 
if (!AbstractCache<TKey, TValue>._cacheList.ContainsKey(_type)) 
{ 
AbstractCache<TKey, TValue>._cacheList.Add(this._type, new Dictionary<TKey, TValue>()); 
} 
} 
private static Dictionary<string, Dictionary<TKey, TValue>> _cacheList; 
private string _type; 
private int _cacheSize = 100;

public virtual void SetCache(TKey key, TValue value) 
{ 
Dictionary<TKey, TValue> dic = this.getTypeCache(); 
lock (AbstractCache<TKey, TValue>._cacheList) 
{ 
TKey fullKey = this.JoinKey(key); 
if (!dic.ContainsKey(fullKey)) 
{ 
if (dic.Count >= this._cacheSize) 
{ 
if (dic.Keys.Count > 0) 
{ 
TKey tmpKey = default(TKey); 
foreach (TKey k in dic.Keys) 
{ 
tmpKey = k; 
break; 
} 
dic.Remove(tmpKey); 
} 
} 
if (value != null) 
{ 
dic.Add(fullKey, value); 
} 
else 
{ 
dic.Add(fullKey, default(TValue)); 
} 
} 
else 
{ 
if (value != null) 
{ 
dic[fullKey] = value; 
} 
else 
{ 
dic[fullKey] = default(TValue); 
} 
} 
} 
}

public virtual TValue GetCache(TKey key) 
{ 
Dictionary<TKey, TValue> dic = this.getTypeCache(); 
TKey fullKey = this.JoinKey(key); 
if (dic.ContainsKey(fullKey)) 
{ 
return dic[fullKey]; 
} 
return default(TValue); 
}

public virtual void Clear(TKey key) 
{ 
Dictionary<TKey, TValue> dic = this.getTypeCache(); 
lock (AbstractCache<TKey, TValue>._cacheList) 
{ 
TKey fullKey = this.JoinKey(key); 
if (dic.ContainsKey(fullKey)) 
{ 
dic.Remove(fullKey); 
} 
} 
} 
public virtual void ClearAll() 
{ 
throw new NotImplementedException(); 
}

public abstract TKey JoinKey(TKey key);

public int CacheSize 
{ 
get 
{ 
return _cacheSize; 
} 
set 
{ 
_cacheSize = value; 
} 
}

/// <summary> 
/// 获取当前类型的缓存数据 
/// </summary> 
/// <returns></returns> 
protected Dictionary<TKey, TValue> getTypeCache() 
{ 
Dictionary<TKey, TValue> dic = AbstractCache<TKey, TValue>._cacheList[this._type]; 
if (dic == null) 
{ 
throw new Exception("不正确的初始化方式"); 
} 
return dic; 
}

接下来我们需要顶一个DataAuthCache类来继承抽象类重写一些自己需要的方法,

public DataAuthCache() 
: base("DataAuthCache")  //这个参数是区分缓存那一部分类容的 
{ 
} 
private static object _lockObj = new object(); 
public override string JoinKey(string entityName) 
{ 
return Entity.Session.Manage.Current.AuthContext.OrgID + "_" + Entity.Session.Manage.Current.AuthContext.UserID + "_" + entityName; 
} 
public override void ClearAll() 
{ 
long orgKey = Entity.Session.Manage.Current.AuthContext.OrgID; 
long userKey = Entity.Session.Manage.Current.AuthContext.UserID; 
lock (_lockObj) 
{ 
Dictionary<string, string> dic = this.getTypeCache(); 
string containKey = orgKey + "_" + userKey; 
List<string> keys = new List<string>(); 
//Dictionary里面Keys不能用索引直接访问 
foreach (string key in dic.Keys) 
{ 
keys.Add(key);

} 
if (keys.Count > 0) 
{ 
foreach (string key in keys) 
{ 
if (key.IndexOf(containKey) > 0) 
{ 
dic.Remove(key); 
} 
} 
} 
} 
}

然后，我们可以定义一个工厂类(AbstractCacheFactory)来实现外部的调用

private static ICache<string, string> _dataAuthCache = null; 
public static AbstractCache<string, string> GetDataAuthCache() 
{ 
if (_dataAuthCache == null) 
{ 
_dataAuthCache = new DataAuthCache(); 
} 
return (AbstractCache<string, string>)_dataAuthCache; 
}

好了，到这，我们就完成缓存了，很简单吧!

AbstractCache<string, string> dac =AbstractCacheFactory.GetDataAuthCache(); 
string cacheHql = dac.GetCache(tpl.EntityName);

cacheHql就是我们缓存的数据查询片段，好了，就分享到这儿了。欢迎大家提出宝贵意见，和分享搞好的方法。