/// <summary>
/// 用于不会迁移的命令
/// </summary>
/// <param name="type"></param>
/// <param name="content"></param>
/// <returns></returns>
public ResponseData <string> DoWithOne(RequestType type, string content)
{
content.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.Request(type, content);
return(RedisCoder.Decoder <string>(type, cts.Token));
}
}
}
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="type"></param>
/// <param name="content"></param>
/// <returns></returns>
public ResponseData DoWithOne(RequestType type, string content)
{
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
content.KeyCheck();
RedisCoder.Request(type, content);
return(RedisCoder.Decoder(type, token));
}
}, _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 void DoSub(string[] channels, Action <string, string> onMsg)
{
lock (_syncLocker)
{
RedisCoder.Request(RequestType.SUBSCRIBE, channels);
RedisCoder.IsSubed = true;
TaskHelper.Run(() =>
{
while (RedisCoder.IsSubed)
{
var result = RedisCoder.Decoder(RequestType.SUBSCRIBE);
if (result.Type == ResponseType.Sub)
{
var arr = result.Data.ToArray(false, Environment.NewLine);
onMsg.Invoke(arr[0], arr[1]);
}
if (result.Type == ResponseType.UnSub)
{
break;
}
}
});
}
}
public void DoSub(string[] channels, Action <string, string> onMsg)
{
RedisCoder.Request(RequestType.SUBSCRIBE, channels);
RedisCoder.IsSubed = true;
TaskHelper.Run(() =>
{
lock (SyncRoot)
{
while (RedisCoder.IsSubed)
{
var result = RedisCoder.Decoder(RequestType.SUBSCRIBE, System.Threading.CancellationToken.None);
if (result != null && result.Type == ResponseType.Sub)
{
var arr = result.Data.ToArray(false, Environment.NewLine);
onMsg.Invoke(arr[0], arr[1]);
}
else if (result != null && result.Type == ResponseType.UnSub)
{
break;
}
}
}
});
}
/// <summary>
/// Others Scan
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <param name="offset"></param>
/// <param name="pattern"></param>
/// <param name="count"></param>
/// <returns></returns>
public ScanResponse DoScanKey(RequestType type, string key, int offset = 0, string pattern = "*", int count = -1)
{
key.KeyCheck();
return(TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
if (offset < 0)
{
offset = 0;
}
if (!string.IsNullOrEmpty(pattern))
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern, RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern);
}
}
else
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString());
}
}
var result = RedisCoder.Decoder(type, token);
if (result == null)
{
return null;
}
if (result.Type == ResponseType.Redirect)
{
return (ScanResponse)OnRedirect.Invoke(result.Data, OperationType.DoScanKey, type, key, offset, pattern, count);
}
else
{
if (result.Type == ResponseType.Lines)
{
return result.ToScanResponse();
}
return null;
}
}
}, _actionTimeout).Result);
}
/// <summary>
/// 用于不会迁移的命令
/// </summary>
/// <param name="type"></param>
/// <param name="content"></param>
/// <returns></returns>
public ResponseData DoWithOne(RequestType type, string content)
{
lock (_syncLocker)
{
content.KeyCheck();
RedisCoder.Request(type, content);
return(RedisCoder.Decoder(type));
}
}
/// <summary>
/// Others Scan
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <param name="offset"></param>
/// <param name="pattern"></param>
/// <param name="count"></param>
/// <returns></returns>
public ScanResponse DoScanKey(RequestType type, string key, int offset = 0, string pattern = "*", int count = -1)
{
key.KeyCheck();
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
if (offset < 0)
{
offset = 0;
}
if (!string.IsNullOrEmpty(pattern))
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern, RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern);
}
}
else
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString());
}
}
var result = RedisCoder.Decoder <string>(type, cts.Token);
if (result == null)
{
return(null);
}
if (result.Type == ResponseType.Redirect)
{
return((ScanResponse)OnRedirect.Invoke(result.Data, OperationType.DoScanKey, type, key, offset, pattern, count));
}
else
{
if (result.Type == ResponseType.Lines)
{
return(result.ToScanResponse());
}
return(null);
}
}
}
}
public void DoExpireAt(string key, int timestamp)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(RequestType.EXPIREAT, key, timestamp.ToString());
var result = RedisCoder.Decoder(RequestType.EXPIREAT);
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpireAt, key, timestamp);
return;
}
}
}
public void DoExpire(string key, int seconds)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(RequestType.EXPIRE, key, seconds.ToString());
var result = RedisCoder.Decoder(RequestType.EXPIRE);
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpire, key, seconds);
return;
}
}
}
/// <summary>
/// Others Scan
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <param name="offset"></param>
/// <param name="pattern"></param>
/// <param name="count"></param>
/// <returns></returns>
public ScanResponse DoScanKey(RequestType type, string key, int offset = 0, string pattern = "*", int count = -1)
{
lock (_syncLocker)
{
key.KeyCheck();
if (offset < 0)
{
offset = 0;
}
if (!string.IsNullOrEmpty(pattern))
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern, RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.MATCH, pattern);
}
}
else
{
if (count > -1)
{
RedisCoder.Request(type, key, offset.ToString(), RedisConst.COUNT, count.ToString());
}
else
{
RedisCoder.Request(type, key, offset.ToString());
}
}
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ScanResponse)OnRedirect.Invoke(result.Data, OperationType.DoScanKey, type, key, offset, pattern, count));
}
else
{
if (result.Type == ResponseType.Lines)
{
return(result.ToScanResponse());
}
return(null);
}
}
}
public void DoExpireInsert(RequestType type, string key, string value, int seconds)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(type, key, value);
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
OnRedirect.Invoke(result.Data, OperationType.DoExpireInsert, key, value, seconds);
return;
}
RedisCoder.Request(RequestType.EXPIRE, string.Format("{0} {1}", key, seconds));
RedisCoder.Decoder(RequestType.EXPIRE);
}
}
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 DoWithKeyValue(RequestType type, string key, string value)
{
lock (_syncLocker)
{
key.KeyCheck();
RedisCoder.Request(type, key, value);
var result = RedisCoder.Decoder(type);
if (result.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(result.Data, OperationType.DoWithKeyValue, type, key, value));
}
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 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 <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 <IEnumerable <IdFiled> > DoStreamRange(params string[] @params)
{
@params.KeyCheck();
ResponseData <IEnumerable <IdFiled> > result = new ResponseData <IEnumerable <IdFiled> >()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(RequestType.XRANGE, @params);
var sresult = RedisCoder.StreamRangeDecoder(token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData <IEnumerable <IdFiled> >)OnRedirect.Invoke(sresult.Data, OperationType.DoBatchWithParams, RequestType.XRANGE, @params));
}
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);
}
/// <summary>
/// DoStreamSub
/// </summary>
/// <param name="type"></param>
/// <param name="keys"></param>
/// <returns></returns>
public ResponseData <IEnumerable <StreamEntry> > DoStreamSub(RequestType type, params string[] keys)
{
keys.KeyCheck();
ResponseData <IEnumerable <StreamEntry> > result = new ResponseData <IEnumerable <StreamEntry> >()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.Request(type, keys);
var sresult = RedisCoder.Decoder(cts.Token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData <IEnumerable <StreamEntry> >)OnRedirect.Invoke(sresult.Data, OperationType.DoBatchWithParams, type, keys));
}
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 <string> DoWithMutiParams(RequestType type, params string[] keys)
{
keys.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(type, keys);
var sresult = RedisCoder.Decoder <string>(type, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData <string>)OnRedirect.Invoke(sresult.Data, OperationType.DoBatchWithParams, type, 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 ResponseData DoRang(RequestType type, string key, double begin = 0, double end = -1)
{
key.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(type, key, begin.ToString(), end.ToString(), "WITHSCORES");
var sresult = RedisCoder.Decoder(type, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(sresult.Data, OperationType.DoRang, type, key, begin, end));
}
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 DoExpireInsert(RequestType type, string key, string value, int seconds)
{
key.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(type, key, value);
var sresult = RedisCoder.Decoder(type, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
return((ResponseData)OnRedirect.Invoke(sresult.Data, OperationType.DoExpireInsert, key, value, seconds));
}
RedisCoder.Request(RequestType.EXPIRE, string.Format("{0} {1}", key, seconds));
return(RedisCoder.Decoder(RequestType.EXPIRE, token));
}
}, _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 <string> DoExpireInsert(RequestType type, string key, string value, int seconds)
{
key.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.Request(type, 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.DoExpireInsert, key, value, seconds));
}
RedisCoder.Request(RequestType.EXPIRE, string.Format("{0} {1}", key, seconds));
return(RedisCoder.Decoder <string>(RequestType.EXPIRE, cts.Token));
}
}
}
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 <string> DoExpireAt(string key, int timestamp)
{
key.KeyCheck();
ResponseData <string> result = new ResponseData <string>()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
lock (SyncRoot)
{
using (var cts = new CancellationTokenSource(_actionTimeout))
{
RedisCoder.Request(RequestType.EXPIREAT, key, timestamp.ToString());
var sresult = RedisCoder.Decoder <string>(RequestType.EXPIREAT, cts.Token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
sresult = (ResponseData <string>)OnRedirect.Invoke(sresult.Data, OperationType.DoExpireAt, key, timestamp);
}
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 DoExpireAt(string key, int timestamp)
{
key.KeyCheck();
ResponseData result = new ResponseData()
{
Type = ResponseType.Empty, Data = "未知的命令"
};
try
{
result = TaskHelper.Run((token) =>
{
lock (SyncRoot)
{
RedisCoder.Request(RequestType.EXPIREAT, key, timestamp.ToString());
var sresult = RedisCoder.Decoder(RequestType.EXPIREAT, token);
if (sresult != null && sresult.Type == ResponseType.Redirect)
{
sresult = (ResponseData)OnRedirect.Invoke(sresult.Data, OperationType.DoExpireAt, key, timestamp);
}
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);
}