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 void Set <T>(string key, T value, IConcurrencyHandle handle)
{
var azureLockHandle = (AzureLockHandle)handle;
HandleBadDataCacheBug(() =>
{
_dataCache.PutAndUnlock(key, value, azureLockHandle.Instance, TimeSpan.FromHours(1));
});
}
public T Get <T>(string key, out IConcurrencyHandle handle) where T : new()
{
var retryPolicy = new LockRetryPolicy();
DataCacheLockHandle lockHandle = null;
object item = null;
HandleBadDataCacheBug(() => retryPolicy.Handle(() =>
{
item = _dataCache.GetAndLock(key, TimeSpan.FromSeconds(1), out lockHandle, true);
}));
handle = new AzureLockHandle
{
Instance = lockHandle
};
return((T)item);
}
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 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);
}
}
