public async ValueTask ProcessResultAsync(CancellationToken token)
{
try
{
switch (_asyncReadCommand)
{
case null:
ProcessResultThrowIfSync();
break;
case Func <CancellationToken, ValueTask> VoidReadCommandAsync:
await VoidReadCommandAsync(token).ConfigureAwait(false);
OnSuccessVoidCallback?.Invoke();
break;
case Func <CancellationToken, ValueTask <int> > IntReadCommandAsync:
var i32 = await IntReadCommandAsync(token).ConfigureAwait(false);
OnSuccessIntCallback?.Invoke(i32);
OnSuccessLongCallback?.Invoke(i32);
OnSuccessBoolCallback?.Invoke(i32 == RedisNativeClient.Success);
OnSuccessVoidCallback?.Invoke();
break;
case Func <CancellationToken, ValueTask <long> > LongReadCommandAsync:
var i64 = await LongReadCommandAsync(token).ConfigureAwait(false);
OnSuccessIntCallback?.Invoke((int)i64);
OnSuccessLongCallback?.Invoke(i64);
OnSuccessBoolCallback?.Invoke(i64 == RedisNativeClient.Success);
OnSuccessVoidCallback?.Invoke();
break;
case Func <CancellationToken, ValueTask <double> > DoubleReadCommandAsync:
var f64 = await DoubleReadCommandAsync(token).ConfigureAwait(false);
OnSuccessDoubleCallback?.Invoke(f64);
break;
case Func <CancellationToken, ValueTask <byte[]> > BytesReadCommandAsync:
var bytes = await BytesReadCommandAsync(token).ConfigureAwait(false);
if (bytes != null && bytes.Length == 0)
{
bytes = null;
}
OnSuccessBytesCallback?.Invoke(bytes);
OnSuccessStringCallback?.Invoke(bytes != null ? Encoding.UTF8.GetString(bytes) : null);
OnSuccessTypeCallback?.Invoke(bytes != null ? Encoding.UTF8.GetString(bytes) : null);
OnSuccessIntCallback?.Invoke(bytes != null ? int.Parse(Encoding.UTF8.GetString(bytes)) : 0);
OnSuccessBoolCallback?.Invoke(bytes != null && Encoding.UTF8.GetString(bytes) == "OK");
break;
case Func <CancellationToken, ValueTask <string> > StringReadCommandAsync:
var s = await StringReadCommandAsync(token).ConfigureAwait(false);
OnSuccessStringCallback?.Invoke(s);
OnSuccessTypeCallback?.Invoke(s);
break;
case Func <CancellationToken, ValueTask <byte[][]> > MultiBytesReadCommandAsync:
var multiBytes = await MultiBytesReadCommandAsync(token).ConfigureAwait(false);
OnSuccessMultiBytesCallback?.Invoke(multiBytes);
OnSuccessMultiStringCallback?.Invoke(multiBytes?.ToStringList());
OnSuccessMultiTypeCallback?.Invoke(multiBytes.ToStringList());
OnSuccessDictionaryStringCallback?.Invoke(multiBytes.ToStringDictionary());
break;
case Func <CancellationToken, ValueTask <List <string> > > MultiStringReadCommandAsync:
var multiString = await MultiStringReadCommandAsync(token).ConfigureAwait(false);
OnSuccessMultiStringCallback?.Invoke(multiString);
break;
case Func <CancellationToken, ValueTask <RedisData> > RedisDataReadCommandAsync:
var data = await RedisDataReadCommandAsync(token).ConfigureAwait(false);
OnSuccessRedisTextCallback?.Invoke(data.ToRedisText());
OnSuccessRedisDataCallback?.Invoke(data);
break;
case Func <CancellationToken, ValueTask <bool> > BoolReadCommandAsync:
var b = await BoolReadCommandAsync(token).ConfigureAwait(false);
OnSuccessBoolCallback?.Invoke(b);
break;
case Func <CancellationToken, ValueTask <Dictionary <string, string> > > DictionaryStringReadCommandAsync:
var dict = await DictionaryStringReadCommandAsync(token).ConfigureAwait(false);
OnSuccessDictionaryStringCallback?.Invoke(dict);
break;
default:
ProcessResultThrowIfSync();
break;
}
}
catch (Exception ex)
{
Log.Error(ex);
if (OnErrorCallback != null)
{
OnErrorCallback(ex);
}
else
{
throw;
}
}
}
public void ProcessResult()
{
try
{
if (VoidReadCommand != null)
{
VoidReadCommand();
OnSuccessVoidCallback?.Invoke();
}
else if (IntReadCommand != null)
{
var result = IntReadCommand();
OnSuccessIntCallback?.Invoke(result);
OnSuccessLongCallback?.Invoke(result);
OnSuccessBoolCallback?.Invoke(result == RedisNativeClient.Success);
OnSuccessVoidCallback?.Invoke();
}
else if (LongReadCommand != null)
{
var result = LongReadCommand();
OnSuccessIntCallback?.Invoke((int)result);
OnSuccessLongCallback?.Invoke(result);
OnSuccessBoolCallback?.Invoke(result == RedisNativeClient.Success);
OnSuccessVoidCallback?.Invoke();
}
else if (DoubleReadCommand != null)
{
var result = DoubleReadCommand();
OnSuccessDoubleCallback?.Invoke(result);
}
else if (BytesReadCommand != null)
{
var result = BytesReadCommand();
if (result != null && result.Length == 0)
{
result = null;
}
OnSuccessBytesCallback?.Invoke(result);
OnSuccessStringCallback?.Invoke(result != null ? Encoding.UTF8.GetString(result) : null);
OnSuccessTypeCallback?.Invoke(result != null ? Encoding.UTF8.GetString(result) : null);
OnSuccessIntCallback?.Invoke(result != null ? int.Parse(Encoding.UTF8.GetString(result)) : 0);
OnSuccessBoolCallback?.Invoke(result != null && Encoding.UTF8.GetString(result) == "OK");
}
else if (StringReadCommand != null)
{
var result = StringReadCommand();
OnSuccessStringCallback?.Invoke(result);
OnSuccessTypeCallback?.Invoke(result);
}
else if (MultiBytesReadCommand != null)
{
var result = MultiBytesReadCommand();
OnSuccessMultiBytesCallback?.Invoke(result);
OnSuccessMultiStringCallback?.Invoke(result != null ? result.ToStringList() : null);
OnSuccessMultiTypeCallback?.Invoke(result.ToStringList());
OnSuccessDictionaryStringCallback?.Invoke(result.ToStringDictionary());
}
else if (MultiStringReadCommand != null)
{
var result = MultiStringReadCommand();
OnSuccessMultiStringCallback?.Invoke(result);
}
else if (RedisDataReadCommand != null)
{
var data = RedisDataReadCommand();
OnSuccessRedisTextCallback?.Invoke(data.ToRedisText());
OnSuccessRedisDataCallback?.Invoke(data);
}
else if (BoolReadCommand != null)
{
var result = BoolReadCommand();
OnSuccessBoolCallback?.Invoke(result);
}
else if (DictionaryStringReadCommand != null)
{
var result = DictionaryStringReadCommand();
OnSuccessDictionaryStringCallback?.Invoke(result);
}
else
{
ProcessResultThrowIfAsync();
}
}
catch (Exception ex)
{
Log.Error(ex);
if (OnErrorCallback != null)
{
OnErrorCallback(ex);
}
else
{
throw;
}
}
}
