/// <summary>
/// 设置值
/// </summary>
public void Put(TKey key, TValue value, TimeSpan keepTime)
{
// 如果以前序列化失败过，直接使用备用的缓存
if (SerializeFailedTypes.ContainsKey(typeof(TKey)) ||
SerializeFailedTypes.ContainsKey(typeof(TValue)))
{
FallbackCache.Put(key, value, keepTime);
return;
}
// 尝试序列化key和value，失败时使用备用的缓存
string keyJson, valueJson;
try {
keyJson = JsonConvert.SerializeObject(key);
} catch {
SerializeFailedTypes[typeof(TKey)] = true;
FallbackCache.Put(key, value, keepTime);
return;
}
try {
valueJson = JsonConvert.SerializeObject(value);
} catch {
SerializeFailedTypes[typeof(TValue)] = true;
FallbackCache.Put(key, value, keepTime);
return;
}
// 保存到Redis
var db = RedisConnectionFactory.GetDatabase();
db.StringSet(UniquePrefix + keyJson, valueJson, keepTime);
}
/// <summary>
/// 获取值
/// </summary>
public bool TryGetValue(TKey key, out TValue value)
{
// 先从备用的缓存获取
if (FallbackCache.TryGetValue(key, out value))
{
return(true);
}
// 不存在时尝试序列化key，失败时返回false
string keyJson;
try {
keyJson = JsonConvert.SerializeObject(key);
} catch {
SerializeFailedTypes[typeof(TKey)] = true;
return(false);
}
// 从Redis获取
var db = RedisConnectionFactory.GetDatabase();
var redisValue = db.StringGet(UniquePrefix + keyJson);
if (!redisValue.HasValue)
{
return(false);
}
// 反序列化值，失败时返回false
try {
value = JsonConvert.DeserializeObject <TValue>(redisValue.ToString());
} catch {
SerializeFailedTypes[typeof(TValue)] = true;
return(false);
}
return(true);
}
/// <summary>
/// Returns cached item based on the provided key or null if item is not known.
/// </summary>
/// <param name="key">Key for item</param>
/// <returns>Cached item or null if not found.</returns>
public static object TryGet(object key)
{
Verify.ArgumentNotNull(key, "key");
var context = HttpContext.Current;
if (context != null)
{
return(context.Items[key]);
}
return(FallbackCache.ContainsKey(key) ? FallbackCache[key] : null);
}
/// <summary>
/// Checks if the cache has the provided key.
/// </summary>
/// <param name="key">Key for item</param>
/// <returns>True when item exist in cache. Otherwise false.</returns>
public static bool HasKey(object key)
{
Verify.ArgumentNotNull(key, "key");
var httpContext = HttpContext.Current;
if (httpContext != null)
{
return(httpContext.Items.Contains(key));
}
return(FallbackCache.ContainsKey(key));
}
/// <summary>
/// Add an item to the cache.
/// </summary>
/// <param name="key">Key for item. Used when retrieving/clearing item later.</param>
/// <param name="value">The item to store.</param>
public static void Add(object key, object value)
{
Verify.ArgumentNotNull(key, "key");
var httpContext = HttpContext.Current;
if (httpContext != null)
{
httpContext.Items.Add(key, value);
}
else
{
FallbackCache.Add(key, value);
}
}
/// <summary>
/// Remove a named item from the cache.
/// </summary>
/// <param name="key">Key for item to remove</param>
public static void Remove(object key)
{
Verify.ArgumentNotNull(key, "key");
var context = HttpContext.Current;
if (context != null)
{
context.Items.Remove(key);
}
else
{
FallbackCache.Remove(key);
}
}
/// <summary>
/// 删除所有缓存值
/// </summary>
public void Clear()
{
var db = RedisConnectionFactory.GetDatabase();
foreach (var endpoint in RedisConnectionFactory.GetEndPoints())
{
var server = RedisConnectionFactory.GetServer(endpoint);
foreach (var key in server.Keys())
{
if (key.ToString().StartsWith(UniquePrefix))
{
db.KeyDelete(key);
}
}
}
FallbackCache.Clear();
}
/// <summary>
/// 获取缓存对象数量
/// </summary>
public int Count()
{
int count = 0;
foreach (var endpoint in RedisConnectionFactory.GetEndPoints())
{
var server = RedisConnectionFactory.GetServer(endpoint);
foreach (var key in server.Keys())
{
if (key.ToString().StartsWith(UniquePrefix))
{
count += 1;
}
}
}
count += FallbackCache.Count();
return(count);
}
/// <summary>
/// 删除值
/// </summary>
public void Remove(TKey key)
{
// 先从备用的缓存删除
FallbackCache.Remove(key);
// 尝试序列化key
string keyJson;
try {
keyJson = JsonConvert.SerializeObject(key);
} catch {
SerializeFailedTypes[typeof(TKey)] = true;
return;
}
// 从Redis删除
var db = RedisConnectionFactory.GetDatabase();
db.KeyDelete(UniquePrefix + keyJson);
}
