public async ValueTask <float> IncrementByAsync(string key, float amount, CancellationToken cancellationToken)
{
return(await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.IncrByFloat, key.ToRedisEncoded(), amount.ToRedisEncoded());
return await SendOrQueueAsync(command, FloatResultProcessor, token);
}, cancellationToken).ConfigureAwait(false));
}
public async ValueTask <int> IncrementAsync(string key, CancellationToken cancellationToken)
{
return(await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Incr, key.ToRedisEncoded());
return await SendOrQueueAsync(command, IntegerResultProcessor, token);
}, cancellationToken).ConfigureAwait(false));
}
private async ValueTask SelectDb(CancellationToken cancellationToken)
{
await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Select, ClientConfig.Db.ToRedisEncoded());
await SendOrQueueAsync(command, SuccessResultProcessor, CancellationToken.None, true);
}, cancellationToken);
}
private async ValueTask SetClientNameAsync(CancellationToken cancellationToken)
{
await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Client, Commands.SetName, ClientConfig.ClientName.ToRedisEncoded());
await SendOrQueueAsync(command, SuccessResultProcessor, token, true);
}, cancellationToken).ConfigureAwait(false);
}
public async Task <StringRedisValue> StringGetAsync(string key,
CancellationToken cancellationToken)
{
return(new StringRedisValue(await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Get, key.ToRedisEncoded());
return await SendAndReceiveAsync(command, DataResultProcessor, token);
}, cancellationToken).ConfigureAwait(false)));
}
public async Task <bool> KeyExistsAsync(string key,
CancellationToken cancellationToken)
{
return(await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Exists, key.ToRedisEncoded());
return await SendAndReceiveAsync(command, IntegerResultProcessor, token);
}, cancellationToken).ConfigureAwait(false) == 1);
}
public async Task <LuaScript> LoadScript(string script, CancellationToken cancellationToken)
{
var command = RedisCommand.From(Commands.Script, Commands.Load, script.ToRedisEncoded());
var scriptResponse = await _redisClient.RunWithTimeout(async token =>
{
return(await _redisClient.SendOrQueueAsync(command, _redisClient.DataResultProcessor, token));
}, cancellationToken).ConfigureAwait(false);
return(new LuaScript(_redisClient, scriptResponse));
}
public async Task <IEnumerable <StringRedisValue> > StringGetAsync(IEnumerable <string> keys,
CancellationToken cancellationToken)
{
return(await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.MGet, keys.ToRedisEncoded());
return await SendAndReceiveAsync(command, ArrayResultProcessor, token);
}, cancellationToken).ConfigureAwait(false));
}
public async Task DeleteKeyAsync(IEnumerable <string> keys,
AwaitOptions awaitOptions,
CancellationToken cancellationToken)
{
await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Del, keys.ToRedisEncoded());
var task = SendAndReceiveAsync(command, IntegerResultProcessor, token);
if (awaitOptions == AwaitOptions.AwaitCompletion)
{
await task;
}
}, cancellationToken).ConfigureAwait(false);
}
private async Task StringSetAsync(RedisKeyValue redisKeyValue, AwaitOptions awaitOptions,
CancellationToken cancellationToken)
{
await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Set, redisKeyValue.Key.ToRedisEncoded(),
redisKeyValue.Value.ToRedisEncoded());
var task = SendOrQueueAsync(command, SuccessResultProcessor, token);
if (awaitOptions == AwaitOptions.AwaitCompletion)
{
await task;
}
}, cancellationToken).ConfigureAwait(false);
}
private async Task StringSetAsync(RedisKeyValue redisKeyValue, AwaitOptions awaitOptions,
CancellationToken cancellationToken)
{
//CollateMultipleRequestsForPipelining(new Tuple<string, string>(key, value), _stringSetQueue);
await RunWithTimeout(async token =>
{
var command = RedisCommand.From(Commands.Set, redisKeyValue.Key.ToRedisEncoded(),
redisKeyValue.Value.ToRedisEncoded());
var task = SendAndReceiveAsync(command, SuccessResultProcessor, token);
if (awaitOptions == AwaitOptions.AwaitCompletion)
{
await task;
}
}, cancellationToken).ConfigureAwait(false);
}
public async Task StringSetAsync(IEnumerable <RedisKeyValue> keyValuePairs,
AwaitOptions awaitOptions,
CancellationToken cancellationToken)
{
await RunWithTimeout(async token =>
{
var encodedKeysAndValues = new List <IRedisEncodable>();
foreach (var keyValuePair in keyValuePairs)
{
encodedKeysAndValues.Add(keyValuePair.Key.ToRedisEncoded());
encodedKeysAndValues.Add(keyValuePair.Value.ToRedisEncoded());
}
var command = RedisCommand.From(Commands.MSet, encodedKeysAndValues);
var task = SendAndReceiveAsync(command, SuccessResultProcessor, token);
if (awaitOptions == AwaitOptions.AwaitCompletion)
{
await task;
}
}, cancellationToken).ConfigureAwait(false);
}
internal static IRedisCommand ToRedisCommand(this string value)
{
return(RedisCommand.From(new RedisEncodable(value)));
}