public IDictionary <string, T> FindByKeys <T>(IEnumerable <string> keys) where T : class
{
using (MiniProfiler.StepStatic("RedisCache_FindByKeys_" + keys.Count() + "_Keys"))
{
return(TryOnClient(client => client.GetAll <T>(keys)));
}
}
public void Remove(IEnumerable <string> keys)
{
using (MiniProfiler.StepStatic("RedisCache_Remove_" + keys.Count() + "_Keys"))
{
TryOnClient(client => client.RemoveAll(keys));
}
}
public void RemoveAll()
{
using (MiniProfiler.StepStatic("RedisCache_RemoveAll"))
{
TryOnClient(client => client.FlushDb());
}
}
public bool TryRemove(string key)
{
using (MiniProfiler.StepStatic("RedisCache_TryRemove_" + key))
{
return(TryOnClient(client => client.Remove(key)));
}
}
public void Remove(string key)
{
using (MiniProfiler.StepStatic("RedisCache_Remove_" + key))
{
TryOnClient(client => client.Remove(key));
}
}
public bool Exists(string key)
{
using (MiniProfiler.StepStatic("RedisCache_Exists_" + key))
{
return(TryOnClient(client => client.Exists(key)));
}
}
public void Unlock(string key, IConcurrencyHandle handle)
{
using (MiniProfiler.StepStatic("RedisCache_Unlock_" + key))
{
var token = ((RedisLockHandle)handle).Token;
TryOnClient(c => c.Database.LockRelease(key, token));
}
}
public T Get <T>(string key) where T : class
{
using (MiniProfiler.StepStatic("RedisCache_Get_" + key))
{
return(TryOnClient(client =>
{
return client.Get <T>(key);
}
));
}
}
public void Set <T>(string key, T value, IConcurrencyHandle handle) where T : class
{
using (MiniProfiler.StepStatic("RedisCache_SetConcurrent_" + key))
{
TryOnClient(c =>
{
if (c.Database.LockTake(key, ((RedisLockHandle)handle).Token, TimeSpan.FromSeconds(1)))
{
try
{
c.Add <object>(key, value, TimeSpan.FromHours(1));
}
finally
{
c.Database.LockRelease(key, ((RedisLockHandle)handle).Token);
}
}
});
}
}
public bool TryGet <T>(string key, ref T value) where T : class
{
using (MiniProfiler.StepStatic("RedisCache_TryGet_" + key))
{
T val = default(T);
var result = TryOnClient((client) =>
{
val = client.Get <T>(key);
if (val == null)
{
return(false);
}
return(true);
});
value = val;
return(result);
}
}
public T Get <T>(string key, out IConcurrencyHandle handle)
where T : class, new()
{
using (MiniProfiler.StepStatic("RedisCache_GetConcurrent_" + key))
{
var token = this.GetType().ToString();
var retryPolicy = new LockRetryPolicy();
var result = TryOnClient(c =>
{
T item = default(T);
retryPolicy.Handle(() =>
{
if (c.Database.LockTake(key, token, TimeSpan.FromSeconds(1)))
{
try
{
object obj = c.Get <object>(key);
item = (T)obj;
}
finally
{
c.Database.LockRelease(key, token);
}
}
});
return(item);
});
handle = new RedisLockHandle
{
Token = token
};
return(result);
}
}
