public Task DoExpireAtAsync(string key, int timestamp)
{
return(TaskHelper.Run(() =>
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Coder(RequestType.EXPIREAT, RequestType.EXPIREAT.ToString(), key, timestamp.ToString());
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpireAt, key, timestamp);
return;
}
}
}));
}
public ResponseData DoBatchWithParams(RequestType type, params string[] keys)
{
keys.KeyCheck();
var cmd = RedisCoder.Coder(type, type.ToString(), keys);
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithParams, type, keys));
}
else
{
return(result);
}
}
public ResponseData DoBatchWithIDDic(RequestType type, string id, Dictionary <string, string> dic)
{
lock (_syncLocker)
{
id.KeyCheck();
RedisCoder.CoderForDicWidthID(type, id, dic);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithIDDic, type, id, dic));
}
else
{
return(result);
}
}
}
public ResponseData DoRang(RequestType type, string key, double begin = 0, double end = -1)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(type, key, begin.ToString(), end.ToString(), "WITHSCORES");
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoRang, type, key, begin, end));
}
else
{
return(result);
}
}
}
public ResponseData DoWithKeyValue(RequestType type, string key, string value)
{
key.KeyCheck();
var cmd = RedisCoder.Coder(type, type.ToString(), key, value);
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoWithKeyValue, type, key, value));
}
else
{
return(result);
}
}
/// <summary>
/// SCAN
/// </summary>
/// <param name="type"></param>
/// <param name="offset"></param>
/// <param name="pattern"></param>
/// <param name="count"></param>
/// <returns></returns>
public ScanResponse DoScan(RequestType type, int offset = 0, string pattern = "*", int count = -1)
{
lock (_syncLocker)
{
if (offset < 0)
{
offset = 0;
}
if (!string.IsNullOrEmpty(pattern))
{
if (count > -1)
{
RedisCoder.Request(type, offset.ToString(), RedisConst.MATCH, pattern, RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, offset.ToString(), RedisConst.MATCH, pattern);
}
}
else
{
if (count > -1)
{
RedisCoder.Request(type, offset.ToString(), RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, offset.ToString());
}
}
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ScanResponse)OnRedirect.Invoke(result.Data, OperationType.DoScan, type, offset, pattern, count));
}
else
{
if (result.Type == ResponseType.Lines)
{
return(result.ToScanResponse());
}
return(null);
}
}
}
public ResponseData DoWithMutiParams(RequestType type, params string[] keys)
{
lock (_syncLocker)
{
keys.KeyCheck();
RedisCoder.Request(type, keys);
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithParams, type, keys));
}
else
{
return(result);
}
}
}
public ResponseData DoHash(RequestType type, string id, string key, string value)
{
lock (_syncLocker)
{
id.KeyCheck();
key.KeyCheck(); RedisCoder.Coder(type, type.ToString(), id, key, value);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoHash, type, id, key, value));
}
else
{
return(result);
}
}
}
/// <summary>
/// 用于可以迁移的命令
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <returns></returns>
public ResponseData DoWithKey(RequestType type, string key)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(type, key);
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoWithKey, type, key));
}
else
{
return(result);
}
}
}
public ResponseData DoRangByScore(RequestType type, string key, double min = double.MinValue, double max = double.MaxValue, RangType rangType = RangType.None, long offset = -1, int count = 20, bool withScore = false)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.CoderForRandByScore(type, key, min, max, rangType, offset, count, withScore);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoRangByScore, type, key, min, max, rangType, offset, count, withScore));
}
else
{
return(result);
}
}
}
public void DoExpireInsert(RequestType type, string key, string value, int seconds)
{
key.KeyCheck();
var cmd = RedisCoder.Coder(type, type.ToString(), key, value);
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpireInsert, key, value, seconds);
return;
}
cmd = RedisCoder.Coder(RequestType.EXPIRE, string.Format("{0} {1} {2}", type.ToString(), key, seconds));
Request(cmd);
RedisCoder.Decoder();
}
public ResponseData DoRang(RequestType type, string id, double begin = 0, double end = -1)
{
id.KeyCheck();
var cmd = RedisCoder.Coder(type, type.ToString(), id, begin.ToString(), end.ToString(), "WITHSCORES");
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoRang, type, id, begin, end));
}
else
{
return(result);
}
}
public ResponseData DoBatchWithIDKeys(RequestType type, string id, params string[] keys)
{
id.KeyCheck();
keys.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
List <string> list = new List <string>();
list.Add(type.ToString());
list.Add(id);
list.AddRange(keys);
RedisCoder.RequestOnlyParams(list.ToArray());
var sresult = RedisCoder.Decoder(type, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(sresult.Data, OperationType.DoBatchWithIDKeys, type, id, keys));
}
else
{
return(sresult);
}
}
}, _actionTimeout).Result;
}
catch (TaskCanceledException tex)
{
result.Type = ResponseType.Error;
result.Data = "Action Timeout";
}
catch (Exception ex)
{
result.Type = ResponseType.Error;
result.Data = ex.Message;
}
return(result);
}
public async Task <ResponseData> DoBatchWithDicAsync(RequestType type, Dictionary <string, string> dic, TimeSpan timeSpan)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
RedisCoder.CoderForDic(type, dic);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithDic, type, dic);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public ResponseData Do(RequestType type, string id, double begin = 0, double end = -1)
{
lock (_syncLocker)
{
var cmd = _redisCoder.Coder(type, type.ToString(), id, begin.ToString(), end.ToString(), "WITHSCORES");
_cnn.Send(cmd);
var result = _redisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
_cnn = OnRedirect.Invoke(result.Data);
_redisCoder = _cnn.RedisCoder;
return(Do(type, id, begin, end));
}
else
{
return(result);
}
}
}
public async Task <ResponseData> DoBatchWithListAsync(RequestType type, string id, IEnumerable <string> list, TimeSpan timeSpan)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
RedisCoder.CoderForList(type, id, list);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithList, type, list);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public Task DoExpireInsertAsync(RequestType type, string key, string value, int seconds)
{
return(TaskHelper.Run(() =>
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Coder(type, type.ToString(), key, value);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpireInsert, key, value, seconds);
return;
}
RedisCoder.Coder(RequestType.EXPIRE, string.Format("{0} {1} {2}", type.ToString(), key, seconds));
RedisCoder.Decoder();
}
}));
}
public ResponseData Do(RequestType type, string key, string value)
{
lock (_syncLocker)
{
var cmd = _redisCoder.Coder(type, type.ToString(), key, value);
_cnn.Send(cmd);
var result = _redisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
_cnn = OnRedirect.Invoke(result.Data);
_redisCoder = _cnn.RedisCoder;
return(Do(type, key, value));
}
else
{
return(result);
}
}
}
/// <summary>
/// 发送命令
/// </summary>
/// <param name="type"></param>
/// <param name="timeSpan"></param>
/// <returns></returns>
public async Task <ResponseData> DoAsync(RequestType type, TimeSpan timeSpan)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
RedisCoder.CoderByParams(type, type.ToString());
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.Do, null);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public ResponseData <string> DoBatchWithIDDic(RequestType type, string id, Dictionary <string, string> dic)
{
id.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.RequestForDicWidthID(type, id, dic);
result = RedisCoder.Decoder <string>(type, cts.Token);
if (result != null && result.Type == ResponseType.Redirect)
{
return((ResponseData <string>)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithIDDic, type, id, dic));
}
else
{
return(result);
}
}
}
}
catch (TaskCanceledException tex)
{
result.Type = ResponseType.Error;
result.Data = "Action Timeout";
}
catch (Exception ex)
{
result.Type = ResponseType.Error;
result.Data = ex.Message;
}
return(result);
}
/// <summary>
/// 发送命令
/// </summary>
/// <param name="cmd"></param>
public ResponseData Do(RequestType type)
{
var cmd = RedisCoder.Coder(type, type.ToString());
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.Do, null));
}
else if (result.Type == ResponseType.Error)
{
throw new Exception(result.Data);
}
else
{
return(result);
}
}
public async Task <ResponseData> DoWithMutiParamsAsync(RequestType type, TimeSpan timeSpan, params string[] keys)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
keys.KeyCheck();
RedisCoder.Coder(type, type.ToString(), keys);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithParams, type, keys);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public async Task <ResponseData> DoRangAsync(RequestType type, string key, double begin, double end, TimeSpan timeSpan)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Coder(type, type.ToString(), key, begin.ToString(), end.ToString(), "WITHSCORES");
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoRang, type, key, begin, end);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public async Task <ResponseData> DoRangByScoreAsync(TimeSpan timeSpan, RequestType type, string key, double min = double.MinValue, double max = double.MaxValue, RangType rangType = RangType.None, long offset = -1, int count = 20, bool withScore = false)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.CoderForRandByScore(type, key, min, max, rangType, offset, count, withScore);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoRangByScore, type, key, min, max, rangType, offset, count, withScore);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public async Task <ResponseData> DoWithKeyValueAsync(RequestType type, string key, string value, TimeSpan timeSpan)
{
return(await TaskHelper.Run(() =>
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Coder(type, type.ToString(), key, value);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return (ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoWithKeyValue, type, key, value);
}
else
{
return result;
}
}
}).WithCancellationTimeout(timeSpan));
}
public ResponseData <string> DoWithID(RequestType type, string id, string key, string value)
{
id.KeyCheck();
key.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.Request(type, id, key, value);
var sresult = RedisCoder.Decoder <string>(type, cts.Token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData <string>)OnRedirect.Invoke(sresult.Data, OperationType.DoWithID, type, id, key, value));
}
else
{
return(sresult);
}
}
}
}
catch (TaskCanceledException tex)
{
result.Type = ResponseType.Error;
result.Data = "Action Timeout";
}
catch (Exception ex)
{
result.Type = ResponseType.Error;
result.Data = ex.Message;
}
return(result);
}
public ResponseData DoWithID(RequestType type, string id, string key, string value)
{
id.KeyCheck();
key.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(type, id, key, value);
var sresult = RedisCoder.Decoder(type, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(sresult.Data, OperationType.DoWithID, type, id, key, value));
}
else
{
return(sresult);
}
}
}, _actionTimeout).Result;
}
catch (TaskCanceledException tex)
{
result.Type = ResponseType.Error;
result.Data = "Action Timeout";
}
catch (Exception ex)
{
result.Type = ResponseType.Error;
result.Data = ex.Message;
}
return(result);
}
public ResponseData DoBatchWithIDKeys(RequestType type, string id, params string[] keys)
{
List <string> list = new List <string>();
list.Add(type.ToString());
list.Add(id);
list.AddRange(keys);
var cmd = RedisCoder.Coder(type, list.ToArray());
Request(cmd);
var result = RedisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithIDKeys, type, id, keys));
}
else
{
return(result);
}
}
public void DoExpire(RequestType type, string key, string value, int seconds)
{
lock (_syncLocker)
{
var cmd = _redisCoder.Coder(type, type.ToString(), key, value);
_cnn.Send(cmd);
var result = _redisCoder.Decoder();
if (result.Type == ResponseType.Redirect)
{
_cnn = OnRedirect.Invoke(result.Data);
_redisCoder = _cnn.RedisCoder;
cmd = _redisCoder.Coder(type, type.ToString(), key, value);
_cnn.Send(cmd);
_redisCoder.Decoder();
}
cmd = _redisCoder.Coder(RequestType.EXPIRE, string.Format("{0} {1} {2}", type.ToString(), key, seconds));
_cnn.Send(cmd);
_redisCoder.Decoder();
}
}
public ResponseData DoBatchWithIDDic(RequestType type, string id, Dictionary <string, string> dic)
{
id.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.RequestForDicWidthID(type, id, dic);
var result = RedisCoder.Decoder(type, token);
if (result != null && result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoBatchWithIDDic, type, id, dic));
}
else
{
return(result);
}
}
}, _actionTimeout).Result;
}
catch (TaskCanceledException tex)
{
result.Type = ResponseType.Error;
result.Data = "Action Timeout";
}
catch (Exception ex)
{
result.Type = ResponseType.Error;
result.Data = ex.Message;
}
return(result);
}
