public async Task <bool> SetAddAsync <T>(string key, T value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
if (serializer != null)
{
return await db.SetAddAsync(key, serializer.Serializer(value));
}
return await db.SetAddAsync(key, redisSerializer.Serializer(value));
}));
}
public bool HashSet <T>(string hashId, string key, T value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) =>
{
if (serializer != null)
{
return db.HashSet(hashId, key, serializer.Serializer(value));
}
return db.HashSet(hashId, key, redisSerializer.Serializer(value));
}));
}
public async Task <long> ListRightPushWhenNoExistsAsync <T>(string key, T value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
if (serializer != null)
{
return await db.ListRightPushAsync(key, serializer.Serializer(value), When.Always, CommandFlags.None);
}
return await db.ListRightPushAsync(key, redisSerializer.Serializer(value), When.Always, CommandFlags.None);
}));
}
public async Task <long> ListRemoveAsync <T>(string key, T value, long removecount, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
if (serializer != null)
{
return await db.ListRemoveAsync(key, serializer.Serializer(value), removecount);
}
return await db.ListRemoveAsync(key, redisSerializer.Serializer(value), removecount);
}));
}
public async Task ListSetByIndexAsync <T>(string key, long index, T value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
if (serializer != null)
{
await db.ListSetByIndexAsync(key, index, serializer.Serializer(value));
}
await db.ListSetByIndexAsync(key, index, redisSerializer.Serializer(value));
});
}
public bool LockTake <T>(string key, T value, int seconds, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) =>
{
if (serializer != null)
{
return db.LockTake(key, serializer.Serializer(value), TimeSpan.FromSeconds(seconds));
}
return db.LockTake(key, redisSerializer.Serializer(value), TimeSpan.FromSeconds(seconds));
}));
}
public IList <T> ListRange <T>(string key, long start, long end, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Read, connectionName, (db) =>
{
var result = db.ListRange(key, start, end);
if (serializer != null)
{
return serializer.Deserialize <T>(result);
}
return redisSerializer.Deserialize <T>(result);
}));
}
public TResult HashGet <TResult>(string hashId, string key, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Read, connectionName, (db) =>
{
var res = db.HashGet(hashId, key);
if (serializer != null)
{
return serializer.Deserialize <TResult>(res);
}
return redisSerializer.Deserialize <TResult>(res);
}));
}
public async Task <long?> SortedZrankAsync <T>(string key, T value, int orderby = 0, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
Order o = orderby == 1 ? Order.Descending : Order.Ascending;
if (serializer != null)
{
return await db.SortedSetRankAsync(key, serializer.Serializer(value), o);
}
return await db.SortedSetRankAsync(key, redisSerializer.Serializer(value), o);
}));
}
public async Task <IList <TResult> > HashValuesAsync <TResult>(string hashId, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
var value = await db.HashValuesAsync(hashId);
if (serializer != null)
{
return serializer.Deserialize <TResult>(value);
}
return redisSerializer.Deserialize <TResult>(value);
}));
}
public T ListGetByIndex <T>(string key, long index, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Read, connectionName, (db) =>
{
var value = db.ListGetByIndex(key, index);
if (serializer != null)
{
return serializer.Deserialize <T>(value);
}
return redisSerializer.Deserialize <T>(value);
}));
}
public async Task <T> LockQueryAsync <T>(string key, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
var value = await db.LockQueryAsync(key);
if (serializer != null)
{
return serializer.Deserialize <T>(value);
}
return redisSerializer.Deserialize <T>(value);
}));
}
public T SetPop <T>(string key, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) =>
{
var value = db.SetPop(key);
if (serializer != null)
{
return serializer.Deserialize <T>(value);
}
return redisSerializer.Deserialize <T>(value);
}));
}
public async Task <Dictionary <T, double> > SortedRangeAsync <T>(string key, long start, long stop, int orderby = 0, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
Order o = orderby == 1 ? Order.Descending : Order.Ascending;
var resultEntry = await db.SortedSetRangeByRankWithScoresAsync(key, start, stop, order: o);
if (serializer != null)
{
return resultEntry.ToDictionary(t => serializer.Deserialize <T>(t.Element), t => t.Score);
}
return resultEntry.ToDictionary(t => redisSerializer.Deserialize <T>(t.Element), t => t.Score);
}));
}
public TResult StringGet <TResult>(string key, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Read, connectionName, (db) =>
{
var value = db.StringGet(key);
if (serializer != null)
{
return serializer.Deserialize <TResult>(value);
}
return redisSerializer.Deserialize <TResult>(value);
}));
}
public async Task <TResult> HashGetAsync <TResult>(string hashId, string key, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
var res = await db.HashGetAsync(hashId, key);
if (serializer != null)
{
return serializer.Deserialize <TResult>(res);
}
return redisSerializer.Deserialize <TResult>(res);
}));
}
public void ListSetByIndex <T>(string key, long index, T value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) =>
{
if (serializer != null)
{
db.ListSetByIndex(key, index, serializer.Serializer(value));
}
else
{
db.ListSetByIndex(key, index, redisSerializer.Serializer(value));
}
});
}
public async Task <IList <T> > SortedRangeByScoreAsync <T>(string key, double start, double stop, int orderby = 0, int skip = 0, int take = -1, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
Order o = orderby == 1 ? Order.Descending : Order.Ascending;
var resultEntry = await db.SortedSetRangeByScoreAsync(key, start, stop, order: o, skip: skip, take: take);
if (serializer != null)
{
return serializer.Deserialize <T>(resultEntry);
}
return redisSerializer.Deserialize <T>(resultEntry);
}));
}
public long SortedRemove <T>(string key, IList <T> values, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) =>
{
List <RedisValue> listValues = new List <RedisValue>();
foreach (var val in values)
{
if (serializer != null)
{
listValues.Add(serializer.Serializer(val));
}
listValues.Add(redisSerializer.Serializer(val));
}
return db.SortedSetRemove(key, listValues.ToArray());
}));
}
public async Task <IList <TResult> > StringGetAsync <TResult>(string[] keys, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Read, connectionName, async (db) =>
{
RedisKey[] redisKey = new RedisKey[keys.Length];
for (int i = 0; i < redisKey.Length; i++)
{
redisKey[i] = keys[i];
}
var redisValue = await db.StringGetAsync(redisKey);
if (serializer != null)
{
return serializer.Deserialize <TResult>(redisValue);
}
return redisSerializer.Deserialize <TResult>(redisValue);
}));
}
public async Task <long> ListRightPushAsync <T>(string key, List <T> value, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
RedisValue[] values = new RedisValue[value.Count];
for (int i = 0; i < value.Count; i++)
{
if (serializer != null)
{
values[i] = serializer.Serializer(value[i]);
}
else
{
values[i] = redisSerializer.Serializer(value[i]);
}
}
return await db.ListRightPushAsync(key, values, CommandFlags.None);
}));
}
public IList <TResult> HashGet <TResult>(string hashId, string[] keys, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(ExecuteCommand(ConnectTypeEnum.Read, connectionName, (db) =>
{
List <RedisValue> listvalues = new List <RedisValue>();
foreach (var key in keys)
{
listvalues.Add(key);
}
var res = db.HashGet(hashId, listvalues.ToArray());
if (serializer != null)
{
return serializer.Deserialize <TResult>(res);
}
return redisSerializer.Deserialize <TResult>(res);
}));
}
public async Task <TResult> HashGetOrInsertAsync <TResult>(string hashId, string key, Func <TResult> fetcher, int seconds = 0, string connectionRead = null, string connectionWrite = null,
bool isCache = true, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
if (!isCache)
{
return(fetcher.Invoke());
}
if (!await HashExistsAsync(hashId, key, connectionRead))
{
var source = fetcher.Invoke();
if (source != null)
{
if (seconds > 0)
{
bool exists = await KeyExistsAsync(hashId, connectionRead);
await HashSetAsync(hashId, key, source, connectionWrite, serializer);
if (!exists)
{
await KeyExpireAsync(hashId, seconds, connectionWrite);
}
}
else
{
await HashSetAsync(hashId, key, source, connectionWrite, serializer);
}
}
return(source);
}
else
{
return(await HashGetAsync <TResult>(hashId, key, connectionRead, serializer));
}
}
public async Task <long> SortedAddAsync <T>(string key, Dictionary <T, double> values, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
List <SortedSetEntry> sortedEntry = new List <SortedSetEntry>();
foreach (var keyvalue in values)
{
if (serializer != null)
{
var entry = new SortedSetEntry(serializer.Serializer(keyvalue.Key), keyvalue.Value);
sortedEntry.Add(entry);
}
else
{
var entry = new SortedSetEntry(redisSerializer.Serializer(keyvalue.Key), keyvalue.Value);
sortedEntry.Add(entry);
}
}
return await db.SortedSetAddAsync(key, sortedEntry.ToArray());
}));
}
public TResult HashGetOrInsert <T, TResult>(string hashId, string key, Func <T, TResult> fetcher, T t, int seconds = 0, string connectionRead = null, string connectionWrite = null,
bool isCache = true, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
if (!isCache)
{
return(fetcher.Invoke(t));
}
if (!HashExists(hashId, key, connectionRead))
{
var source = fetcher.Invoke(t);
if (source != null)
{
if (seconds > 0)
{
bool exists = KeyExists(hashId, connectionRead);
HashSet(hashId, key, source, connectionWrite, serializer);
if (!exists)
{
KeyExpire(hashId, seconds, connectionWrite);
}
}
else
{
HashSet(hashId, key, source, connectionWrite, serializer);
}
}
return(source);
}
else
{
return(HashGet <TResult>(hashId, key, connectionRead, serializer));
}
}
public async Task <TResult> StringGetOrInsertAsync <TResult>(string key, Func <TResult> fetcher, int seconds = 0, string connectionRead = null, string connectionWrite = null,
bool isCache = true, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
if (!isCache)
{
return(fetcher.Invoke());
}
if (!await KeyExistsAsync(key, connectionRead))
{
var source = fetcher.Invoke();
if (source != null)
{
await StringSetAsync(key, source, seconds, connectionWrite, serializer);
}
return(source);
}
else
{
return(await StringGetAsync <TResult>(key, connectionRead, serializer));
}
}
public async Task <bool> StringSetAsync <T>(string key, T value, int seconds = 0, string connectionName = null, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) =>
{
if (seconds > 0)
{
if (serializer != null)
{
return await db.StringSetAsync(key, serializer.Serializer(value), TimeSpan.FromSeconds(seconds));
}
return await db.StringSetAsync(key, redisSerializer.Serializer(value), TimeSpan.FromSeconds(seconds));
}
else
{
if (serializer != null)
{
return await db.StringSetAsync(key, serializer.Serializer(value));
}
return await db.StringSetAsync(key, redisSerializer.Serializer(value));
}
}));
}
public TResult StringGetOrInsert <T, TResult>(string key, Func <T, TResult> fetcher, T t, int seconds = 0, string connectionRead = null, string connectionWrite = null,
bool isCache = true, IRedisSerializer serializer = null)
{
RedisThrow.NullSerializer(redisSerializer, serializer);
if (!isCache)
{
return(fetcher.Invoke(t));
}
if (!KeyExists(key, connectionRead))
{
var source = fetcher.Invoke(t);
if (source != null)
{
StringSet(key, source, seconds, connectionWrite, serializer);
}
return(source);
}
else
{
return(StringGet <TResult>(key, connectionRead, serializer));
}
}
