public async Task MultipleMessageReadTest()
{
SetupStream("+OK\r\n+Test\r\n:100\r\n*3\r\n:1\r\n:2\r\n:3\r\n$6\r\nfoobar\r\n-Error message\r\n");
IRedisType result = await ReadAsync <RedisString>();
Assert.Equal(new RedisString("OK"), result);
result = await ReadAsync <RedisString>();
Assert.Equal(new RedisString("Test"), result);
result = await ReadAsync <RedisInteger>();
Assert.Equal(new RedisInteger(100), result);
result = await ReadAsync <RedisArray>();
Assert.Equal(new RedisArray(new RedisInteger(1), new RedisInteger(2), new RedisInteger(3)), result);
result = await ReadAsync <RedisBulkString>();
Assert.Equal(RedisBulkString.FromString("foobar"), result);
result = await ReadAsync <RedisErorr>();
Assert.Equal(new RedisErorr("Error message"), result);
}
public async Task <IRedisType> SendAsync(IRedisType data, CancellationToken cancellationToken)
{
await _sem.WaitAsync(cancellationToken);
try
{
await _writer.WriteAsync(data, cancellationToken);
return(await _reader.ReadAsync(cancellationToken));
}
finally
{
_sem.Release();
}
}
private async Task <IRedisType> ReadArrayAsync(string value, CancellationToken cancellationToken)
{
int length;
if (!int.TryParse(value, out length) || length < -1)
{
throw new IOException($"Invalid Array length '{value}'");
}
if (length == -1)
{
return(RedisArray.Null);
}
var items = new IRedisType[length];
for (int i = 0; i < length; i++)
{
items[i] = await ReadAsync(cancellationToken);
}
return(new RedisArray(items));
}
private async Task <T> SendAsync <T>(IRedisType request, CancellationToken cancellationToken) where T : IRedisType
{
var state = GetState <Connected>();
IRedisType response;
try
{
response = await state.Client.SendAsync(request, cancellationToken);
}
catch (Exception ex)
{
Close();
throw new ConnectionException("Error while making request", ex);
}
if (response is T)
{
return((T)response);
}
throw new ConnectionException($"Invalid Response type - expected '{typeof(T).Name}' but got '{response.GetType().Name}'");
}
public Task WriteAsync(IRedisType value, CancellationToken cancellationToken)
{
switch (value.RedisType)
{
case RedisType.String:
return(WriteAsync(value as RedisString, cancellationToken));
case RedisType.Error:
return(WriteAsync(value as RedisErorr, cancellationToken));
case RedisType.Integer:
return(WriteAsync(value as RedisInteger, cancellationToken));
case RedisType.BulkString:
return(WriteAsync(value as RedisBulkString, cancellationToken));
case RedisType.Array:
return(WriteAsync(value as RedisArray, cancellationToken));
default:
throw new ArgumentOutOfRangeException(nameof(value));
}
}
public CommandBuilder WithArg(IRedisType arg)
{
_args.Add(arg);
return(this);
}
private async Task WriteSimpleAsync(IRedisType value, CancellationToken cancellationToken)
{
var bytes = DefaultEncoding.GetBytes($"{value.RedisType.Prefix()}{value}{NewLine}");
await _stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
}
private async Task <string> WriteAsync(IRedisType dataType)
{
await _writer.WriteAsync(dataType, CancellationToken.None);
return(Encoding.ASCII.GetString(_stream.ToArray()));
}
