/// <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>
/// 删除文件
/// </summary>
public void Delete()
{
var db = RedisConnectionFactory.GetDatabase();
db.KeyDelete(FileKeyPrefix + FullPath);
Body = null;
}
/// <summary>
/// 更新文件内容
/// </summary>
internal void UpdateBody(RedisFileBody body)
{
var db = RedisConnectionFactory.GetDatabase();
db.StringSet(FileKeyPrefix + FullPath, JsonConvert.SerializeObject(body));
Body = body;
}
/// <summary>
/// 删除文件夹
/// </summary>
public void Delete()
{
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(RedisFileEntry.FileKeyPrefix + FullPath + "/"))
{
db.KeyDelete(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 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);
}
/// <summary>
/// 枚举文件
/// </summary>
public IEnumerable <IFileEntry> EnumerateFiles()
{
var db = RedisConnectionFactory.GetDatabase();
foreach (var endpoint in RedisConnectionFactory.GetEndPoints())
{
var server = RedisConnectionFactory.GetServer(endpoint);
foreach (var key in server.Keys())
{
var keyStr = key.ToString();
if (keyStr.StartsWith(RedisFileEntry.FileKeyPrefix + FullPath + "/"))
{
var path = keyStr.Substring(RedisFileEntry.FileKeyPrefix.Length);
var childPathParts = path.Substring(FullPath.Length + 1).Split('/');
if (childPathParts.Length == 1)
{
yield return(new RedisFileEntry(RedisConnectionFactory, path, false));
}
}
}
}
}
public IDatabase GetDatabase(int index)
{
return(_redisConnectinFactory.GetDatabase(index));
}