public async Task <bool> HashSetAsync <T>(string hashId, string key, T value, OverWrittenTypeDenum isAlways, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) => { When when = When.Always; switch (isAlways) { case OverWrittenTypeDenum.Always: when = When.Always; break; case OverWrittenTypeDenum.Exists: when = When.Exists; break; case OverWrittenTypeDenum.NotExists: when = When.NotExists; break; } if (serializer != null) { return await db.HashSetAsync(hashId, key, serializer.Serializer(value), when); } return await db.HashSetAsync(hashId, key, redisSerializer.Serializer(value), when); })); }
public long ListRightPush <T>(string key, List <T> value, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) => { if (value != null) { return 0; } 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 db.ListRightPush(key, values, CommandFlags.None); })); }
public async Task <long> ListRightPushWhenExistsAsync <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.Exists, CommandFlags.None); } return await db.ListRightPushAsync(key, redisSerializer.Serializer(value), When.Exists, 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 async Task <bool> SortedAddAsync <T>(string key, T value, double score, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) => { if (serializer != null) { return await db.SortedSetAddAsync(key, serializer.Serializer(value), score); } return await db.SortedSetAddAsync(key, redisSerializer.Serializer(value), score); })); }
public bool LockExtend <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.LockExtend(key, serializer.Serializer(value), TimeSpan.FromSeconds(seconds)); } return db.LockExtend(key, redisSerializer.Serializer(value), TimeSpan.FromSeconds(seconds)); })); }
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 bool SortedRemove <T>(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.SortedSetRemove(key, serializer.Serializer(value)); } return db.SortedSetRemove(key, redisSerializer.Serializer(value)); })); }
public async Task <bool> LockTakeAsync <T>(string key, T value, int seconds, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(await ExecuteCommand(ConnectTypeEnum.Write, connectionName, async (db) => { if (serializer != null) { return await db.LockTakeAsync(key, serializer.Serializer(value), TimeSpan.FromSeconds(seconds)); } return await db.LockTakeAsync(key, redisSerializer.Serializer(value), TimeSpan.FromSeconds(seconds)); })); }
public long ListRightPushWhenNoExists <T>(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.ListRightPush(key, serializer.Serializer(value), When.Always, CommandFlags.None); } return db.ListRightPush(key, redisSerializer.Serializer(value), When.Always, CommandFlags.None); })); }
public async Task <bool> HashSetAsync <T>(string hashId, 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.HashSetAsync(hashId, key, serializer.Serializer(value)); } return await db.HashSetAsync(hashId, key, redisSerializer.Serializer(value)); })); }
public long ListInsertAfter <T>(string key, T value, string insertvalue, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) => { if (serializer != null) { return db.ListInsertAfter(key, serializer.Serializer(value), insertvalue); } return db.ListInsertAfter(key, redisSerializer.Serializer(value), insertvalue); })); }
public long ListRemove <T>(string key, T value, long removecount, string connectionName = null, IRedisSerializer serializer = null) { RedisThrow.NullSerializer(redisSerializer, serializer); return(ExecuteCommand(ConnectTypeEnum.Write, connectionName, (db) => { if (serializer != null) { return db.ListRemove(key, serializer.Serializer(value), removecount); } return db.ListRemove(key, redisSerializer.Serializer(value), removecount); })); }
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 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 <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 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 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 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 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 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 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 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 <long> ListLeftPushAsync <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.ListLeftPushAsync(key, values, CommandFlags.None); })); }