封装一个Redis服务组件
结构说明
ServiceCollectionExtensions类
1 using com.project.Redis.Common; 2 using Microsoft.Extensions.Configuration; 3 using Microsoft.Extensions.DependencyInjection; 4 using System; 5 6 namespace com.project.Redis 7 { 8 public static class ServiceCollectionExtensions 9 { 10 public static IServiceCollection AddRedis(this IServiceCollection services, IConfiguration configuration, string sectionName = "Redis") 11 { 12 if (services == null) 13 { 14 throw new ArgumentNullException(nameof(services)); 15 } 16 services.Configure<RedisOptions>(configuration.GetSection(sectionName)); 17 services.AddSingleton<IRedisBuilder, RedisBuilder>(); 18 return services; 19 } 20 21 //public static IServiceCollection AddRedis(this IServiceCollection services, IConfiguration configuration) 22 //{ 23 // return new RedisBuilder(services, configuration); 24 //} 25 } 26 }
RedisOptions类
1 using System; 2 using System.Collections.Generic; 3 using System.Text; 4 5 namespace com.project.Redis.Common 6 { 7 public class RedisOptions 8 { 9 public string Ip { get; set; } 10 public int Port { get; set; } 11 public string Password { get; set; } 12 public int DefaultDatabase { get; set; } = 1; 13 14 /// <summary> 15 /// 需要连接的其他Database索引 16 /// </summary> 17 public string OtherDatabase { get; set; } = string.Empty; 18 19 /// <summary> 20 /// The asynchronous method automatically uses pipeline, and the 10W concurrent time is 450ms (welcome to feedback) 默认值：false 21 /// </summary> 22 public bool AsyncPipeline { get; set; } = false; 23 24 /// <summary> 25 /// 默认连接池数量是50个，也就是说一个微服务通过单例创建redisclient以后，通过CLIENT LIST可以查看到redisserver的连接数为50个。 26 /// 默认值：50 27 /// </summary> 28 public int Poolsize { get; set; } = 50; 29 30 /// <summary> 31 /// Idle time of elements in the connection pool (MS), suitable for connecting to remote redis server 32 /// 默认值：2000 33 /// </summary> 34 public int IdleTimeout { get; set; } = 2000; 35 36 /// <summary> 37 /// Connection timeout (MS) 38 /// 默认值：5000 39 /// </summary> 40 public int ConnectTimeout { get; set; } = 5000; 41 42 /// <summary> 43 /// Send / receive timeout (MS) 44 /// 默认值：10000 45 /// </summary> 46 public int SyncTimeout { get; set; } = 10000; 47 48 /// <summary> 49 /// Preheat connections, receive values such as preheat = 5 preheat 5 connections 50 /// 默认值：5 51 /// </summary> 52 public int Preheat { get; set; } = 5; 53 54 /// <summary> 55 /// Follow system exit event to release automatically 56 /// 默认值：true 57 /// </summary> 58 public bool AutoDispose { get; set; } = true; 59 60 /// <summary> 61 /// Enable encrypted transmission 62 /// 默认值：false 63 /// </summary> 64 public bool SSL { get; set; } = false; 65 66 /// <summary> 67 /// 是否尝试集群模式，阿里云、腾讯云集群需要设置此选项为 false 68 /// true 69 /// </summary> 70 public bool Testcluster { get; set; } = true; 71 72 /// <summary> 73 /// Execution error, retry attempts 74 /// 默认值：0 75 /// </summary> 76 public int Tryit { get; set; } = 0; 77 78 /// <summary> 79 /// Connection name, use client list command to view 80 /// 客户端连接名称，在RedisServer上面使用Client list可以查看 81 /// 默认值：<Empty> 82 /// </summary> 83 public string Name { get; set; } = string.Empty; 84 85 /// <summary> 86 /// key前辍，所有方法都会附带此前辍，csredis.Set(prefix + "key", 111); 87 /// 默认值：<Empty> 88 /// </summary> 89 public string Prefix { get; set; } = string.Empty; 90 91 /// <summary> 92 /// 是否为redis集群，redis采用哨兵机制进行集群 93 /// 默认值：false 94 /// </summary> 95 public bool RedisCluster { get; set; } = false; 96 } 97 }
IRedisBuilder 接口类
1 namespace com.project.Redis 2 { 3 public interface IRedisBuilder 4 { 5 /// <summary> 6 /// 得到CSRedisClient操作对象 7 /// </summary> 8 /// <returns></returns> 9 public CSRedis.CSRedisClient GetCSRedisClient(); 10 /// <summary> 11 /// 得到CSRedisClient操作对象 12 /// </summary> 13 /// <param name="databaseIndex">database Index</param> 14 /// <returns></returns> 15 public CSRedis.CSRedisClient GetCSRedisClient(int databaseIndex); 16 } 17 }
RedisBuilder 类
1 using com.project.Redis.Common; 2 using CSRedis; 3 using Microsoft.Extensions.Options; 4 using System; 5 using System.Collections.Generic; 6 7 namespace com.project.Redis 8 { 9 /// <summary> 10 /// CSRedis客户端内部已经实现了连接池的管理， 11 /// 因此在全局单例CsRedisClient对象即可 12 /// </summary> 13 public class RedisBuilder : IRedisBuilder 14 { 15 private CSRedis.CSRedisClient _client; 16 /// <summary> 17 /// Redis操作客户端对象集合 18 /// </summary> 19 private Dictionary<int, CSRedis.CSRedisClient> _csredisclients; 20 /// <summary> 21 /// Redis连接参数 22 /// </summary> 23 private readonly RedisOptions _redisOptions; 24 25 public RedisBuilder(IOptionsMonitor<RedisOptions> optionAccs) 26 { 27 _redisOptions = optionAccs.CurrentValue; 28 //127.0.0.1[:6379],password=123456,defaultDatabase=13,poolsize=50,ssl=false,writeBuffer=10240,prefix=key前辍 29 string connectionStringPrefix = string.Format("{0}:{1},password={2},poolsize={3},connectTimeout={4},ssl={5},writeBuffer=10240", 30 _redisOptions.Ip, 31 _redisOptions.Port, 32 _redisOptions.Password, 33 _redisOptions.Poolsize, 34 _redisOptions.ConnectTimeout, 35 _redisOptions.SSL); 36 37 //测试 redis-cluster 不能设置 defaultDatabase 38 string defaultConnectionString = connectionStringPrefix; 39 if (!_redisOptions.RedisCluster) 40 defaultConnectionString += $",defaultDatabase={_redisOptions.DefaultDatabase}"; 41 if (!string.IsNullOrEmpty(_redisOptions.Prefix)) 42 defaultConnectionString += $",prefix={_redisOptions.Prefix}"; 43 _client = new CSRedis.CSRedisClient(defaultConnectionString); 44 45 if (!string.IsNullOrEmpty(_redisOptions.OtherDatabase)) 46 { 47 _csredisclients = new Dictionary<int, CSRedisClient>(); 48 if (_redisOptions.OtherDatabase.IndexOf(",") == -1) 49 { 50 string otherDatabaseConnectionString = connectionStringPrefix; 51 otherDatabaseConnectionString += $",defaultDatabase={_redisOptions.OtherDatabase}"; 52 if (!string.IsNullOrEmpty(_redisOptions.Prefix)) 53 otherDatabaseConnectionString += $",prefix={_redisOptions.Prefix}"; 54 _csredisclients.Add(Convert.ToInt32(_redisOptions.OtherDatabase), new CSRedis.CSRedisClient(otherDatabaseConnectionString)); 55 } 56 else 57 { 58 string[] otherDatabaseIndex = _redisOptions.OtherDatabase.Split(","); 59 foreach (string index in otherDatabaseIndex) 60 { 61 string otherDatabaseConnectionString = connectionStringPrefix; 62 otherDatabaseConnectionString += $",defaultDatabase={index}"; 63 if (!string.IsNullOrEmpty(_redisOptions.Prefix)) 64 otherDatabaseConnectionString += $",prefix={_redisOptions.Prefix}"; 65 _csredisclients.Add(Convert.ToInt32(index), new CSRedis.CSRedisClient(otherDatabaseConnectionString)); 66 } 67 } 68 } 69 } 70 71 /// <summary> 72 /// 得到CSRedisClient操作对象 73 /// </summary> 74 /// <returns></returns> 75 public CSRedisClient GetCSRedisClient() 76 { 77 return _client; 78 } 79 80 /// <summary> 81 /// 得到CSRedisClient操作对象 82 /// </summary> 83 /// <param name="databaseIndex">database Index</param> 84 /// <returns></returns> 85 public CSRedisClient GetCSRedisClient(int databaseIndex) 86 { 87 return _csredisclients[databaseIndex]; 88 } 89 } 90 }
CSRedisClient类
1 using CSRedis.Internal.ObjectPool; 2 using System; 3 using System.Collections.Concurrent; 4 using System.Collections.Generic; 5 using System.Diagnostics; 6 using System.Linq; 7 using System.Text.RegularExpressions; 8 using System.Threading; 9 using System.Threading.Tasks; 10 11 #if net40 12 #else 13 namespace CSRedis 14 { 15 public partial class CSRedisClient 16 { 17 18 ConcurrentDictionary<string, AutoPipe> _autoPipe = new ConcurrentDictionary<string, AutoPipe>(); 19 class AutoPipe 20 { 21 public Object<RedisClient> Client; 22 public long GetTimes; 23 public long TimesZore; 24 public bool IsSingleEndPipe; 25 public Exception ReturnException; 26 } 27 async Task<AutoPipe> GetClientAsync(RedisClientPool pool) 28 { 29 if (pool._policy._asyncPipeline == false) 30 return new AutoPipe { Client = await pool.GetAsync(), GetTimes = 1, TimesZore = 0, IsSingleEndPipe = false }; 31 32 if (_autoPipe.TryGetValue(pool.Key, out var ap) && ap.IsSingleEndPipe == false) 33 { 34 if (pool.UnavailableException != null) 35 throw new Exception($"【{pool._policy.Name}】状态不可用，等待后台检查程序恢复方可使用。{pool.UnavailableException?.Message}", pool.UnavailableException); 36 Interlocked.Increment(ref ap.GetTimes); 37 return ap; 38 } 39 ap = new AutoPipe { Client = await pool.GetAsync(), GetTimes = 1, TimesZore = 0, IsSingleEndPipe = false }; 40 if (_autoPipe.TryAdd(pool.Key, ap)) 41 { 42 ap.Client.Value._asyncPipe = new ConcurrentQueue<TaskCompletionSource<object>>(); 43 new Thread(() => 44 { 45 var rc = ap.Client.Value; 46 47 void trySetException(Exception ex) 48 { 49 pool.SetUnavailable(ex); 50 while (rc._asyncPipe?.IsEmpty == false) 51 { 52 TaskCompletionSource<object> trytsc = null; 53 if (rc._asyncPipe?.TryDequeue(out trytsc) == true) 54 trytsc.TrySetException(ex); 55 } 56 rc._asyncPipe = null; 57 pool.Return(ap.Client); 58 _autoPipe.TryRemove(pool.Key, out var oldap); 59 } 60 while (true) 61 { 62 Thread.CurrentThread.Join(1); 63 if (rc._asyncPipe?.IsEmpty == false) 64 { 65 try 66 { 67 var ret = rc.EndPipe(); 68 if (ret.Length == 1) ap.IsSingleEndPipe = true; 69 else if (ret.Length > 1) ap.IsSingleEndPipe = false; 70 foreach (var rv in ret) 71 { 72 TaskCompletionSource<object> trytsc = null; 73 if (rc._asyncPipe?.TryDequeue(out trytsc) == true) 74 trytsc.TrySetResult(rv); 75 } 76 } 77 catch (Exception ex) 78 { 79 trySetException(ex); 80 return; 81 } 82 continue; 83 } 84 85 if (ap.ReturnException != null) 86 { 87 trySetException(ap.ReturnException); 88 return; 89 } 90 var tmpTimes = Interlocked.Increment(ref ap.TimesZore); 91 if (tmpTimes >= 10) ap.IsSingleEndPipe = false; 92 if (tmpTimes >= 1000) 93 { 94 rc._asyncPipe = null; 95 pool.Return(ap.Client, ap.ReturnException); 96 _autoPipe.TryRemove(pool.Key, out var oldap); 97 break; 98 } 99 } 100 }).Start(); 101 } 102 return ap; 103 } 104 void ReturnClient(AutoPipe ap, Object<RedisClient> obj, RedisClientPool pool, Exception ex) 105 { 106 if (ap == null) return; 107 var times = Interlocked.Decrement(ref ap.GetTimes); 108 if (times <= 0) 109 Interlocked.Exchange(ref ap.TimesZore, 0); 110 ap.ReturnException = ex; 111 if (_autoPipe.TryGetValue(pool.Key, out var dicap) == false || dicap != ap) 112 pool.Return(ap.Client, ap.ReturnException); 113 } 114 115 async Task<T> GetAndExecuteAsync<T>(RedisClientPool pool, Func<Object<RedisClient>, Task<T>> handerAsync, int jump = 100, int errtimes = 0) 116 { 117 AutoPipe ap = null; 118 Object<RedisClient> obj = null; 119 Exception ex = null; 120 var redirect = ParseClusterRedirect(null); 121 try 122 { 123 ap = await GetClientAsync(pool); 124 obj = ap.Client; 125 while (true) 126 { //因网络出错重试，默认1次 127 try 128 { 129 var ret = await handerAsync(obj); 130 return ret; 131 } 132 catch (RedisException ex3) 133 { 134 redirect = ParseClusterRedirect(ex3); //官方集群跳转 135 if (redirect == null || jump <= 0) 136 { 137 ex = ex3; 138 if (SentinelManager != null && ex.Message.Contains("READONLY")) 139 { //哨兵轮询 140 if (pool.SetUnavailable(ex) == true) 141 BackgroundGetSentinelMasterValue(); 142 } 143 throw ex; 144 } 145 break; 146 } 147 catch (Exception ex2) 148 { 149 ex = ex2; 150 if (pool.UnavailableException != null) throw ex; 151 var isPong = false; 152 try 153 { 154 await obj.Value.PingAsync(); 155 isPong = true; 156 } 157 catch 158 { 159 obj.ResetValue(); 160 } 161 162 if (isPong == false || ++errtimes > pool._policy._tryit) 163 { 164 if (SentinelManager != null) 165 { //哨兵轮询 166 if (pool.SetUnavailable(ex) == true) 167 BackgroundGetSentinelMasterValue(); 168 throw new Exception($"Redis Sentinel Master is switching：{ex.Message}"); 169 } 170 throw ex; //重试次数完成 171 } 172 else 173 { 174 ex = null; 175 Trace.WriteLine($"csredis tryit ({errtimes}) ..."); 176 } 177 } 178 } 179 } 180 finally 181 { 182 ReturnClient(ap, obj, pool, ex); 183 //pool.Return(obj, ex); 184 } 185 if (redirect == null) 186 return await GetAndExecuteAsync<T>(pool, handerAsync, jump - 1, errtimes); 187 188 var redirectHanderAsync = redirect.Value.isMoved ? handerAsync : async redirectObj => 189 { 190 await redirectObj.Value.CallAsync("ASKING"); 191 return await handerAsync(redirectObj); 192 }; 193 return await GetAndExecuteAsync<T>(GetRedirectPool(redirect.Value, pool), redirectHanderAsync, jump - 1); 194 } 195 196 async Task<T> NodesNotSupportAsync<T>(string[] keys, T defaultValue, Func<Object<RedisClient>, string[], Task<T>> callbackAsync) 197 { 198 if (keys == null || keys.Any() == false) return defaultValue; 199 var rules = Nodes.Count > 1 ? keys.Select(a => NodeRuleRaw(a)).Distinct() : new[] { Nodes.FirstOrDefault().Key }; 200 if (rules.Count() > 1) throw new Exception("由于开启了分区模式，keys 分散在多个节点，无法使用此功能"); 201 var pool = Nodes.TryGetValue(rules.First(), out var b) ? b : Nodes.First().Value; 202 string[] rkeys = new string[keys.Length]; 203 for (int a = 0; a < keys.Length; a++) rkeys[a] = string.Concat(pool.Prefix, keys[a]); 204 if (rkeys.Length == 0) return defaultValue; 205 return await GetAndExecuteAsync(pool, conn => callbackAsync(conn, rkeys)); 206 } 207 Task<T> NodesNotSupportAsync<T>(string key, Func<Object<RedisClient>, string, Task<T>> callback) 208 { 209 if (IsMultiNode) throw new Exception("由于开启了分区模式，无法使用此功能"); 210 return ExecuteScalarAsync<T>(key, callback); 211 } 212 213 214 #region 缓存壳 215 /// <summary> 216 /// 缓存壳 217 /// </summary> 218 /// <typeparam name="T">缓存类型</typeparam> 219 /// <param name="key">不含prefix前辍</param> 220 /// <param name="timeoutSeconds">缓存秒数</param> 221 /// <param name="getDataAsync">获取源数据的函数</param> 222 /// <returns></returns> 223 async public Task<T> CacheShellAsync<T>(string key, int timeoutSeconds, Func<Task<T>> getDataAsync) 224 { 225 if (timeoutSeconds == 0) return await getDataAsync(); 226 var cacheValue = await GetAsync(key); 227 if (cacheValue != null) 228 { 229 try 230 { 231 return this.DeserializeObject<T>(cacheValue); 232 } 233 catch 234 { 235 await DelAsync(key); 236 throw; 237 } 238 } 239 var ret = await getDataAsync(); 240 await SetAsync(key, this.SerializeObject(ret), timeoutSeconds); 241 return ret; 242 } 243 /// <summary> 244 /// 缓存壳(哈希表) 245 /// </summary> 246 /// <typeparam name="T">缓存类型</typeparam> 247 /// <param name="key">不含prefix前辍</param> 248 /// <param name="field">字段</param> 249 /// <param name="timeoutSeconds">缓存秒数</param> 250 /// <param name="getDataAsync">获取源数据的函数</param> 251 /// <returns></returns> 252 async public Task<T> CacheShellAsync<T>(string key, string field, int timeoutSeconds, Func<Task<T>> getDataAsync) 253 { 254 if (timeoutSeconds == 0) return await getDataAsync(); 255 var cacheValue = await HGetAsync(key, field); 256 if (cacheValue != null) 257 { 258 try 259 { 260 var value = this.DeserializeObject<(T, long)>(cacheValue); 261 if (DateTime.Now.Subtract(_dt1970.AddSeconds(value.Item2)).TotalSeconds <= timeoutSeconds) return value.Item1; 262 } 263 catch 264 { 265 await HDelAsync(key, field); 266 throw; 267 } 268 } 269 var ret = await getDataAsync(); 270 await HSetAsync(key, field, this.SerializeObject((ret, (long)DateTime.Now.Subtract(_dt1970).TotalSeconds))); 271 return ret; 272 } 273 /// <summary> 274 /// 缓存壳(哈希表)，将 fields 每个元素存储到单独的缓存片，实现最大化复用 275 /// </summary> 276 /// <typeparam name="T">缓存类型</typeparam> 277 /// <param name="key">不含prefix前辍</param> 278 /// <param name="fields">字段</param> 279 /// <param name="timeoutSeconds">缓存秒数</param> 280 /// <param name="getDataAsync">获取源数据的函数，输入参数是没有缓存的 fields，返回值应该是 (field, value)[]</param> 281 /// <returns></returns> 282 async public Task<(string key, T value)[]> CacheShellAsync<T>(string key, string[] fields, int timeoutSeconds, Func<string[], Task<(string, T)[]>> getDataAsync) 283 { 284 fields = fields?.Distinct().ToArray(); 285 if (fields == null || fields.Length == 0) return new (string, T)[0]; 286 if (timeoutSeconds == 0) return await getDataAsync(fields); 287 288 var ret = new (string, T)[fields.Length]; 289 var cacheValue = await HMGetAsync(key, fields); 290 var fieldsMGet = new Dictionary<string, int>(); 291 292 for (var a = 0; a < ret.Length; a++) 293 { 294 if (cacheValue[a] != null) 295 { 296 try 297 { 298 var value = this.DeserializeObject<(T, long)>(cacheValue[a]); 299 if (DateTime.Now.Subtract(_dt1970.AddSeconds(value.Item2)).TotalSeconds <= timeoutSeconds) 300 { 301 ret[a] = (fields[a], value.Item1); 302 continue; 303 } 304 } 305 catch 306 { 307 await HDelAsync(key, fields[a]); 308 throw; 309 } 310 } 311 fieldsMGet.Add(fields[a], a); 312 } 313 314 if (fieldsMGet.Any()) 315 { 316 var getDataIntput = fieldsMGet.Keys.ToArray(); 317 var data = await getDataAsync(getDataIntput); 318 var mset = new object[fieldsMGet.Count * 2]; 319 var msetIndex = 0; 320 foreach (var d in data) 321 { 322 if (fieldsMGet.ContainsKey(d.Item1) == false) throw new Exception($"使用 CacheShell 请确认 getData 返回值 (string, T)[] 中的 Item1 值: {d.Item1} 存在于 输入参数: {string.Join(",", getDataIntput)}"); 323 ret[fieldsMGet[d.Item1]] = d; 324 mset[msetIndex++] = d.Item1; 325 mset[msetIndex++] = this.SerializeObject((d.Item2, (long)DateTime.Now.Subtract(_dt1970).TotalSeconds)); 326 fieldsMGet.Remove(d.Item1); 327 } 328 foreach (var fieldNull in fieldsMGet.Keys) 329 { 330 ret[fieldsMGet[fieldNull]] = (fieldNull, default(T)); 331 mset[msetIndex++] = fieldNull; 332 mset[msetIndex++] = this.SerializeObject((default(T), (long)DateTime.Now.Subtract(_dt1970).TotalSeconds)); 333 } 334 if (mset.Any()) await HMSetAsync(key, mset); 335 } 336 return ret; 337 } 338 #endregion 339 340 #region 分区方式 ExecuteAsync 341 async private Task<T> ExecuteScalarAsync<T>(string key, Func<Object<RedisClient>, string, Task<T>> handerAsync) 342 { 343 if (key == null) return default(T); 344 var pool = NodeRuleRaw == null || Nodes.Count == 1 ? Nodes.First().Value : (Nodes.TryGetValue(NodeRuleRaw(key), out var b) ? b : Nodes.First().Value); 345 key = string.Concat(pool.Prefix, key); 346 return await GetAndExecuteAsync(pool, conn => handerAsync(conn, key)); 347 } 348 async private Task<T[]> ExecuteArrayAsync<T>(string[] key, Func<Object<RedisClient>, string[], Task<T[]>> handerAsync) 349 { 350 if (key == null || key.Any() == false) return new T[0]; 351 if (NodeRuleRaw == null || Nodes.Count == 1) 352 { 353 var pool = Nodes.First().Value; 354 var keys = key.Select(a => string.Concat(pool.Prefix, a)).ToArray(); 355 return await GetAndExecuteAsync(pool, conn => handerAsync(conn, keys)); 356 } 357 var rules = new Dictionary<string, List<(string, int)>>(); 358 for (var a = 0; a < key.Length; a++) 359 { 360 var rule = NodeRuleRaw(key[a]); 361 if (rules.ContainsKey(rule)) rules[rule].Add((key[a], a)); 362 else rules.Add(rule, new List<(string, int)> { (key[a], a) }); 363 } 364 T[] ret = new T[key.Length]; 365 foreach (var r in rules) 366 { 367 var pool = Nodes.TryGetValue(r.Key, out var b) ? b : Nodes.First().Value; 368 var keys = r.Value.Select(a => string.Concat(pool.Prefix, a.Item1)).ToArray(); 369 await GetAndExecuteAsync(pool, async conn => 370 { 371 var vals = await handerAsync(conn, keys); 372 for (var z = 0; z < r.Value.Count; z++) 373 { 374 ret[r.Value[z].Item2] = vals == null || z >= vals.Length ? default(T) : vals[z]; 375 } 376 return 0; 377 }); 378 } 379 return ret; 380 } 381 async private Task<long> ExecuteNonQueryAsync(string[] key, Func<Object<RedisClient>, string[], Task<long>> handerAsync) 382 { 383 if (key == null || key.Any() == false) return 0; 384 if (NodeRuleRaw == null || Nodes.Count == 1) 385 { 386 var pool = Nodes.First().Value; 387 var keys = key.Select(a => string.Concat(pool.Prefix, a)).ToArray(); 388 return await GetAndExecuteAsync(pool, conn => handerAsync(conn, keys)); 389 } 390 var rules = new Dictionary<string, List<string>>(); 391 for (var a = 0; a < key.Length; a++) 392 { 393 var rule = NodeRuleRaw(key[a]); 394 if (rules.ContainsKey(rule)) rules[rule].Add(key[a]); 395 else rules.Add(rule, new List<string> { key[a] }); 396 } 397 long affrows = 0; 398 foreach (var r in rules) 399 { 400 var pool = Nodes.TryGetValue(r.Key, out var b) ? b : Nodes.First().Value; 401 var keys = r.Value.Select(a => string.Concat(pool.Prefix, a)).ToArray(); 402 affrows += await GetAndExecuteAsync(pool, conn => handerAsync(conn, keys)); 403 } 404 return affrows; 405 } 406 #endregion 407 408 #region 服务器命令 409 public partial class NodesServerManagerProvider 410 { 411 412 async Task<(string node, T value)[]> NodesInternalAsync<T>(Func<Object<RedisClient>, Task<T>> handleAsync) 413 { 414 var ret = new List<(string, T)>(); 415 foreach (var pool in _csredis.Nodes.Values) 416 ret.Add((pool.Key, await _csredis.GetAndExecuteAsync(pool, c => handleAsync(c)))); 417 return ret.ToArray(); 418 } 419 420 /// <summary> 421 /// 异步执行一个 AOF（AppendOnly File） 文件重写操作 422 /// </summary> 423 /// <returns></returns> 424 public Task<(string node, string value)[]> BgRewriteAofAsync() => NodesInternalAsync(c => c.Value.BgRewriteAofAsync()); 425 /// <summary> 426 /// 在后台异步保存当前数据库的数据到磁盘 427 /// </summary> 428 /// <returns></returns> 429 public Task<(string node, string value)[]> BgSaveAsync() => NodesInternalAsync(c => c.Value.BgSaveAsync()); 430 /// <summary> 431 /// 关闭客户端连接 432 /// </summary> 433 /// <param name="ip">ip</param> 434 /// <param name="port">端口</param> 435 /// <returns></returns> 436 public Task<(string node, string value)[]> ClientKillAsync(string ip, int port) => NodesInternalAsync(c => c.Value.ClientKillAsync(ip, port)); 437 /// <summary> 438 /// 关闭客户端连接 439 /// </summary> 440 /// <param name="addr">ip:port</param> 441 /// <param name="id">客户唯一标识</param> 442 /// <param name="type">类型：normal | slave | pubsub</param> 443 /// <param name="skipMe">跳过自己</param> 444 /// <returns></returns> 445 public Task<(string node, long value)[]> ClientKillAsync(string addr = null, string id = null, ClientKillType? type = null, bool? skipMe = null) => NodesInternalAsync(c => c.Value.ClientKillAsync(addr, id, type?.ToString(), skipMe)); 446 /// <summary> 447 /// 获取连接到服务器的客户端连接列表 448 /// </summary> 449 /// <returns></returns> 450 public Task<(string node, string value)[]> ClientListAsync() => NodesInternalAsync(c => c.Value.ClientListAsync()); 451 /// <summary> 452 /// 获取连接的名称 453 /// </summary> 454 /// <returns></returns> 455 public Task<(string node, string value)[]> ClientGetNameAsync() => NodesInternalAsync(c => c.Value.ClientGetNameAsync()); 456 /// <summary> 457 /// 在指定时间内终止运行来自客户端的命令 458 /// </summary> 459 /// <param name="timeout">阻塞时间</param> 460 /// <returns></returns> 461 public Task<(string node, string value)[]> ClientPauseAsync(TimeSpan timeout) => NodesInternalAsync(c => c.Value.ClientPauseAsync(timeout)); 462 /// <summary> 463 /// 设置当前连接的名称 464 /// </summary> 465 /// <param name="connectionName">连接名称</param> 466 /// <returns></returns> 467 public Task<(string node, string value)[]> ClientSetNameAsync(string connectionName) => NodesInternalAsync(c => c.Value.ClientSetNameAsync(connectionName)); 468 /// <summary> 469 /// 返回当前服务器时间 470 /// </summary> 471 /// <returns></returns> 472 public Task<(string node, DateTime value)[]> TimeAsync() => NodesInternalAsync(c => c.Value.TimeAsync()); 473 /// <summary> 474 /// 获取指定配置参数的值 475 /// </summary> 476 /// <param name="parameter">参数</param> 477 /// <returns></returns> 478 public Task<(string node, Dictionary<string, string> value)[]> ConfigGetAsync(string parameter) => NodesInternalAsync(async c => (await c.Value.ConfigGetAsync(parameter)).ToDictionary(z => z.Item1, y => y.Item2)); 479 /// <summary> 480 /// 对启动 Redis 服务器时所指定的 redis.conf 配置文件进行改写 481 /// </summary> 482 /// <returns></returns> 483 public Task<(string node, string value)[]> ConfigRewriteAsync() => NodesInternalAsync(c => c.Value.ConfigRewriteAsync()); 484 /// <summary> 485 /// 修改 redis 配置参数，无需重启 486 /// </summary> 487 /// <param name="parameter">参数</param> 488 /// <param name="value">值</param> 489 /// <returns></returns> 490 public Task<(string node, string value)[]> ConfigSetAsync(string parameter, string value) => NodesInternalAsync(c => c.Value.ConfigSetAsync(parameter, value)); 491 /// <summary> 492 /// 重置 INFO 命令中的某些统计数据 493 /// </summary> 494 /// <returns></returns> 495 public Task<(string node, string value)[]> ConfigResetStatAsync() => NodesInternalAsync(c => c.Value.ConfigResetStatAsync()); 496 /// <summary> 497 /// 返回当前数据库的 key 的数量 498 /// </summary> 499 /// <returns></returns> 500 public Task<(string node, long value)[]> DbSizeAsync() => NodesInternalAsync(c => c.Value.DbSizeAsync()); 501 /// <summary> 502 /// 让 Redis 服务崩溃 503 /// </summary> 504 /// <returns></returns> 505 public Task<(string node, string value)[]> DebugSegFaultAsync() => NodesInternalAsync(c => c.Value.DebugSegFaultAsync()); 506 /// <summary> 507 /// 删除所有数据库的所有key 508 /// </summary> 509 /// <returns></returns> 510 public Task<(string node, string value)[]> FlushAllAsync() => NodesInternalAsync(c => c.Value.FlushAllAsync()); 511 /// <summary> 512 /// 删除当前数据库的所有key 513 /// </summary> 514 /// <returns></returns> 515 public Task<(string node, string value)[]> FlushDbAsync() => NodesInternalAsync(c => c.Value.FlushDbAsync()); 516 /// <summary> 517 /// 获取 Redis 服务器的各种信息和统计数值 518 /// </summary> 519 /// <param name="section">部分(all|default|server|clients|memory|persistence|stats|replication|cpu|commandstats|cluster|keyspace)</param> 520 /// <returns></returns> 521 public Task<(string node, string value)[]> InfoAsync(InfoSection? section = null) => NodesInternalAsync(c => c.Value.InfoAsync(section?.ToString())); 522 /// <summary> 523 /// 返回最近一次 Redis 成功将数据保存到磁盘上的时间 524 /// </summary> 525 /// <returns></returns> 526 public Task<(string node, DateTime value)[]> LastSaveAsync() => NodesInternalAsync(c => c.Value.LastSaveAsync()); 527 /// <summary> 528 /// 返回主从实例所属的角色 529 /// </summary> 530 /// <returns></returns> 531 public Task<(string node, RedisRole value)[]> RoleAsync() => NodesInternalAsync(c => c.Value.RoleAsync()); 532 /// <summary> 533 /// 同步保存数据到硬盘 534 /// </summary> 535 /// <returns></returns> 536 public Task<(string node, string value)[]> SaveAsync() => NodesInternalAsync(c => c.Value.SaveAsync()); 537 /// <summary> 538 /// 异步保存数据到硬盘，并关闭服务器 539 /// </summary> 540 /// <param name="isSave">是否保存</param> 541 /// <returns></returns> 542 public Task<(string node, string value)[]> ShutdownAsync(bool isSave = true) => NodesInternalAsync(c => c.Value.ShutdownAsync(isSave)); 543 /// <summary> 544 /// 将服务器转变为指定服务器的从属服务器(slave server)，如果当前服务器已经是某个主服务器(master server)的从属服务器，那么执行 SLAVEOF host port 将使当前服务器停止对旧主服务器的同步，丢弃旧数据集，转而开始对新主服务器进行同步。 545 /// </summary> 546 /// <param name="host">主机</param> 547 /// <param name="port">端口</param> 548 /// <returns></returns> 549 public Task<(string node, string value)[]> SlaveOfAsync(string host, int port) => NodesInternalAsync(c => c.Value.SlaveOfAsync(host, port)); 550 /// <summary> 551 /// 从属服务器执行命令 SLAVEOF NO ONE 将使得这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢弃。 552 /// </summary> 553 /// <returns></returns> 554 public Task<(string node, string value)[]> SlaveOfNoOneAsync() => NodesInternalAsync(c => c.Value.SlaveOfNoOneAsync()); 555 /// <summary> 556 /// 管理 redis 的慢日志，按数量获取 557 /// </summary> 558 /// <param name="count">数量</param> 559 /// <returns></returns> 560 public Task<(string node, RedisSlowLogEntry[] value)[]> SlowLogGetAsync(long? count = null) => NodesInternalAsync(c => c.Value.SlowLogGetAsync(count)); 561 /// <summary> 562 /// 管理 redis 的慢日志，总数量 563 /// </summary> 564 /// <returns></returns> 565 public Task<(string node, long value)[]> SlowLogLenAsync() => NodesInternalAsync(c => c.Value.SlowLogLenAsync()); 566 /// <summary> 567 /// 管理 redis 的慢日志，清空 568 /// </summary> 569 /// <returns></returns> 570 public Task<(string node, string value)[]> SlowLogResetAsync() => NodesInternalAsync(c => c.Value.SlowLogResetAsync()); 571 /// <summary> 572 /// 用于复制功能(replication)的内部命令 573 /// </summary> 574 /// <returns></returns> 575 public Task<(string node, byte[] value)[]> SyncAsync() => NodesInternalAsync(c => c.Value.SyncAsync()); 576 } 577 578 public partial class NodeServerManagerProvider 579 { 580 581 /// <summary> 582 /// 异步执行一个 AOF（AppendOnly File） 文件重写操作 583 /// </summary> 584 /// <returns></returns> 585 public Task<string> BgRewriteAofAsync() => _csredis.GetAndExecute(_pool, c => c.Value.BgRewriteAofAsync()); 586 /// <summary> 587 /// 在后台异步保存当前数据库的数据到磁盘 588 /// </summary> 589 /// <returns></returns> 590 public Task<string> BgSaveAsync() => _csredis.GetAndExecute(_pool, c => c.Value.BgSaveAsync()); 591 /// <summary> 592 /// 关闭客户端连接 593 /// </summary> 594 /// <param name="ip">ip</param> 595 /// <param name="port">端口</param> 596 /// <returns></returns> 597 public Task<string> ClientKillAsync(string ip, int port) => _csredis.GetAndExecute(_pool, c => c.Value.ClientKillAsync(ip, port)); 598 /// <summary> 599 /// 关闭客户端连接 600 /// </summary> 601 /// <param name="addr">ip:port</param> 602 /// <param name="id">客户唯一标识</param> 603 /// <param name="type">类型：normal | slave | pubsub</param> 604 /// <param name="skipMe">跳过自己</param> 605 /// <returns></returns> 606 public Task<long> ClientKillAsync(string addr = null, string id = null, ClientKillType? type = null, bool? skipMe = null) => _csredis.GetAndExecute(_pool, c => c.Value.ClientKillAsync(addr, id, type?.ToString(), skipMe)); 607 /// <summary> 608 /// 获取连接到服务器的客户端连接列表 609 /// </summary> 610 /// <returns></returns> 611 public Task<string> ClientListAsync() => _csredis.GetAndExecute(_pool, c => c.Value.ClientListAsync()); 612 /// <summary> 613 /// 获取连接的名称 614 /// </summary> 615 /// <returns></returns> 616 public Task<string> ClientGetNameAsync() => _csredis.GetAndExecute(_pool, c => c.Value.ClientGetNameAsync()); 617 /// <summary> 618 /// 在指定时间内终止运行来自客户端的命令 619 /// </summary> 620 /// <param name="timeout">阻塞时间</param> 621 /// <returns></returns> 622 public Task<string> ClientPauseAsync(TimeSpan timeout) => _csredis.GetAndExecute(_pool, c => c.Value.ClientPauseAsync(timeout)); 623 /// <summary> 624 /// 设置当前连接的名称 625 /// </summary> 626 /// <param name="connectionName">连接名称</param> 627 /// <returns></returns> 628 public Task<string> ClientSetNameAsync(string connectionName) => _csredis.GetAndExecute(_pool, c => c.Value.ClientSetNameAsync(connectionName)); 629 /// <summary> 630 /// 返回当前服务器时间 631 /// </summary> 632 /// <returns></returns> 633 public Task<DateTime> TimeAsync() => _csredis.GetAndExecute(_pool, c => c.Value.TimeAsync()); 634 /// <summary> 635 /// 获取指定配置参数的值 636 /// </summary> 637 /// <param name="parameter">参数</param> 638 /// <returns></returns> 639 async public Task<Dictionary<string, string>> ConfigGetAsync(string parameter) => (await _csredis.GetAndExecute(_pool, c => c.Value.ConfigGetAsync(parameter))).ToDictionary(z => z.Item1, y => y.Item2); 640 /// <summary> 641 /// 对启动 Redis 服务器时所指定的 redis.conf 配置文件进行改写 642 /// </summary> 643 /// <returns></returns> 644 public Task<string> ConfigRewriteAsync() => _csredis.GetAndExecute(_pool, c => c.Value.ConfigRewriteAsync()); 645 /// <summary> 646 /// 修改 redis 配置参数，无需重启 647 /// </summary> 648 /// <param name="parameter">参数</param> 649 /// <param name="value">值</param> 650 /// <returns></returns> 651 public Task<string> ConfigSetAsync(string parameter, string value) => _csredis.GetAndExecute(_pool, c => c.Value.ConfigSetAsync(parameter, value)); 652 /// <summary> 653 /// 重置 INFO 命令中的某些统计数据 654 /// </summary> 655 /// <returns></returns> 656 public Task<string> ConfigResetStatAsync() => _csredis.GetAndExecute(_pool, c => c.Value.ConfigResetStatAsync()); 657 /// <summary> 658 /// 返回当前数据库的 key 的数量 659 /// </summary> 660 /// <returns></returns> 661 public Task<long> DbSizeAsync() => _csredis.GetAndExecute(_pool, c => c.Value.DbSizeAsync()); 662 /// <summary> 663 /// 让 Redis 服务崩溃 664 /// </summary> 665 /// <returns></returns> 666 public Task<string> DebugSegFaultAsync() => _csredis.GetAndExecute(_pool, c => c.Value.DebugSegFaultAsync()); 667 /// <summary> 668 /// 删除所有数据库的所有key 669 /// </summary> 670 /// <returns></returns> 671 public Task<string> FlushAllAsync() => _csredis.GetAndExecute(_pool, c => c.Value.FlushAllAsync()); 672 /// <summary> 673 /// 删除当前数据库的所有key 674 /// </summary> 675 /// <returns></returns> 676 public Task<string> FlushDbAsync() => _csredis.GetAndExecute(_pool, c => c.Value.FlushDbAsync()); 677 /// <summary> 678 /// 获取 Redis 服务器的各种信息和统计数值 679 /// </summary> 680 /// <param name="section">部分(Server | Clients | Memory | Persistence | Stats | Replication | CPU | Keyspace)</param> 681 /// <returns></returns> 682 public Task<string> InfoAsync(InfoSection? section = null) => _csredis.GetAndExecute(_pool, c => c.Value.InfoAsync(section?.ToString())); 683 /// <summary> 684 /// 返回最近一次 Redis 成功将数据保存到磁盘上的时间 685 /// </summary> 686 /// <returns></returns> 687 public Task<DateTime> LastSaveAsync() => _csredis.GetAndExecute(_pool, c => c.Value.LastSaveAsync()); 688 /// <summary> 689 /// 返回主从实例所属的角色 690 /// </summary> 691 /// <returns></returns> 692 public Task<RedisRole> RoleAsync() => _csredis.GetAndExecute(_pool, c => c.Value.RoleAsync()); 693 /// <summary> 694 /// 同步保存数据到硬盘 695 /// </summary> 696 /// <returns></returns> 697 public Task<string> SaveAsync() => _csredis.GetAndExecute(_pool, c => c.Value.SaveAsync()); 698 /// <summary> 699 /// 异步保存数据到硬盘，并关闭服务器 700 /// </summary> 701 /// <param name="isSave">是否保存</param> 702 /// <returns></returns> 703 public Task<string> ShutdownAsync(bool isSave = true) => _csredis.GetAndExecute(_pool, c => c.Value.ShutdownAsync(isSave)); 704 /// <summary> 705 /// 将服务器转变为指定服务器的从属服务器(slave server)，如果当前服务器已经是某个主服务器(master server)的从属服务器，那么执行 SLAVEOF host port 将使当前服务器停止对旧主服务器的同步，丢弃旧数据集，转而开始对新主服务器进行同步。 706 /// </summary> 707 /// <param name="host">主机</param> 708 /// <param name="port">端口</param> 709 /// <returns></returns> 710 public Task<string> SlaveOfAsync(string host, int port) => _csredis.GetAndExecute(_pool, c => c.Value.SlaveOfAsync(host, port)); 711 /// <summary> 712 /// 从属服务器执行命令 SLAVEOF NO ONE 将使得这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢弃。 713 /// </summary> 714 /// <returns></returns> 715 public Task<string> SlaveOfNoOneAsync() => _csredis.GetAndExecute(_pool, c => c.Value.SlaveOfNoOneAsync()); 716 /// <summary> 717 /// 管理 redis 的慢日志，按数量获取 718 /// </summary> 719 /// <param name="count">数量</param> 720 /// <returns></returns> 721 public Task<RedisSlowLogEntry[]> SlowLogGetAsync(long? count = null) => _csredis.GetAndExecute(_pool, c => c.Value.SlowLogGetAsync(count)); 722 /// <summary> 723 /// 管理 redis 的慢日志，总数量 724 /// </summary> 725 /// <returns></returns> 726 public Task<long> SlowLogLenAsync() => _csredis.GetAndExecute(_pool, c => c.Value.SlowLogLenAsync()); 727 /// <summary> 728 /// 管理 redis 的慢日志，清空 729 /// </summary> 730 /// <returns></returns> 731 public Task<string> SlowLogResetAsync() => _csredis.GetAndExecute(_pool, c => c.Value.SlowLogResetAsync()); 732 /// <summary> 733 /// 用于复制功能(replication)的内部命令 734 /// </summary> 735 /// <returns></returns> 736 public Task<byte[]> SyncAsync() => _csredis.GetAndExecute(_pool, c => c.Value.SyncAsync()); 737 } 738 #endregion 739 740 #region 连接命令 741 /// <summary> 742 /// 验证密码是否正确 743 /// </summary> 744 /// <param name="nodeKey">分区key</param> 745 /// <param name="password">密码</param> 746 /// <returns></returns> 747 [Obsolete("不建议手工执行，连接池自己管理最佳")] 748 private Task<bool> AuthAsync(string nodeKey, string password) => GetAndExecuteAsync(GetNodeOrThrowNotFound(nodeKey), async c => await c.Value.AuthAsync(password) == "OK"); 749 /// <summary> 750 /// 打印字符串 751 /// </summary> 752 /// <param name="nodeKey">分区key</param> 753 /// <param name="message">消息</param> 754 /// <returns></returns> 755 public Task<string> EchoAsync(string nodeKey, string message) => GetAndExecuteAsync(GetNodeOrThrowNotFound(nodeKey), c => c.Value.EchoAsync(message)); 756 /// <summary> 757 /// 打印字符串 758 /// </summary> 759 /// <param name="message">消息</param> 760 /// <returns></returns> 761 public Task<string> EchoAsync(string message) => GetAndExecuteAsync(Nodes.First().Value, c => c.Value.EchoAsync(message)); 762 /// <summary> 763 /// 查看服务是否运行 764 /// </summary> 765 /// <param name="nodeKey">分区key</param> 766 /// <returns></returns> 767 public Task<bool> PingAsync(string nodeKey) => GetAndExecuteAsync(GetNodeOrThrowNotFound(nodeKey), async c => await c.Value.PingAsync() == "PONG"); 768 /// <summary> 769 /// 查看服务是否运行 770 /// </summary> 771 /// <returns></returns> 772 public Task<bool> PingAsync() => GetAndExecuteAsync(Nodes.First().Value, async c => await c.Value.PingAsync() == "PONG"); 773 /// <summary> 774 /// 关闭当前连接 775 /// </summary> 776 /// <param name="nodeKey">分区key</param> 777 /// <returns></returns> 778 [Obsolete("不建议手工执行，连接池自己管理最佳")] 779 private Task<bool> QuitAsync(string nodeKey) => GetAndExecuteAsync(GetNodeOrThrowNotFound(nodeKey), async c => await c.Value.QuitAsync() == "OK"); 780 /// <summary> 781 /// 切换到指定的数据库 782 /// </summary> 783 /// <param name="nodeKey">分区key</param> 784 /// <param name="index">数据库</param> 785 /// <returns></returns> 786 [Obsolete("不建议手工执行，连接池所有连接应该指向同一数据库，若手工修改将导致数据的不一致")] 787 private Task<bool> SelectAsync(string nodeKey, int index) => GetAndExecuteAsync(GetNodeOrThrowNotFound(nodeKey), async c => await c.Value.SelectAsync(index) == "OK"); 788 #endregion 789 790 #region Script 791 /// <summary> 792 /// 执行脚本 793 /// </summary> 794 /// <param name="script">Lua 脚本</param> 795 /// <param name="key">用于定位分区节点，不含prefix前辍</param> 796 /// <param name="args">参数</param> 797 /// <returns></returns> 798 public Task<object> EvalAsync(string script, string key, params object[] args) 799 { 800 var args2 = args?.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 801 return ExecuteScalarAsync(key, (c, k) => c.Value.EvalAsync(script, new[] { k }, args2)); 802 } 803 /// <summary> 804 /// 执行脚本 805 /// </summary> 806 /// <param name="sha1">脚本缓存的sha1</param> 807 /// <param name="key">用于定位分区节点，不含prefix前辍</param> 808 /// <param name="args">参数</param> 809 /// <returns></returns> 810 public Task<object> EvalSHAAsync(string sha1, string key, params object[] args) 811 { 812 var args2 = args?.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 813 return ExecuteScalarAsync(key, (c, k) => c.Value.EvalSHAAsync(sha1, new[] { k }, args2)); 814 } 815 /// <summary> 816 /// 校验所有分区节点中，脚本是否已经缓存。任何分区节点未缓存sha1，都返回false。 817 /// </summary> 818 /// <param name="sha1">脚本缓存的sha1</param> 819 /// <returns></returns> 820 async public Task<bool[]> ScriptExistsAsync(params string[] sha1) 821 { 822 var ret = new List<bool>(); 823 foreach (var pool in Nodes.Values) 824 ret.Add((await GetAndExecuteAsync(pool, c => c.Value.ScriptExistsAsync(sha1)))?.Where(z => z == false).Any() == false); 825 return ret.ToArray(); 826 } 827 /// <summary> 828 /// 清除所有分区节点中，所有 Lua 脚本缓存 829 /// </summary> 830 async public Task ScriptFlushAsync() 831 { 832 foreach (var pool in Nodes.Values) 833 await GetAndExecuteAsync(pool, c => c.Value.ScriptFlushAsync()); 834 } 835 /// <summary> 836 /// 杀死所有分区节点中，当前正在运行的 Lua 脚本 837 /// </summary> 838 async public Task ScriptKillAsync() 839 { 840 foreach (var pool in Nodes.Values) 841 await GetAndExecuteAsync(pool, c => c.Value.ScriptKillAsync()); 842 } 843 /// <summary> 844 /// 在所有分区节点中，缓存脚本后返回 sha1（同样的脚本在任何服务器，缓存后的 sha1 都是相同的） 845 /// </summary> 846 /// <param name="script">Lua 脚本</param> 847 /// <returns></returns> 848 async public Task<string> ScriptLoadAsync(string script) 849 { 850 string sha1 = null; 851 foreach (var pool in Nodes.Values) 852 sha1 = await GetAndExecuteAsync(pool, c => c.Value.ScriptLoadAsync(script)); 853 return sha1; 854 } 855 #endregion 856 857 #region Pub/Sub 858 /// <summary> 859 /// 用于将信息发送到指定分区节点的频道，最终消息发布格式：1|message 860 /// </summary> 861 /// <param name="channel">频道名</param> 862 /// <param name="message">消息文本</param> 863 /// <returns></returns> 864 async public Task<long> PublishAsync(string channel, string message) 865 { 866 var msgid = await HIncrByAsync("csredisclient:Publish:msgid", channel, 1); 867 return await ExecuteScalarAsync(channel, (c, k) => c.Value.PublishAsync(channel, $"{msgid}|{message}")); 868 } 869 /// <summary> 870 /// 用于将信息发送到指定分区节点的频道，与 Publish 方法不同，不返回消息id头，即 1| 871 /// </summary> 872 /// <param name="channel">频道名</param> 873 /// <param name="message">消息文本</param> 874 /// <returns></returns> 875 public Task<long> PublishNoneMessageIdAsync(string channel, string message) => ExecuteScalarAsync(channel, (c, k) => c.Value.PublishAsync(channel, message)); 876 /// <summary> 877 /// 查看所有订阅频道 878 /// </summary> 879 /// <param name="pattern"></param> 880 /// <returns></returns> 881 async public Task<string[]> PubSubChannelsAsync(string pattern) 882 { 883 var ret = new List<string>(); 884 foreach (var pool in Nodes.Values) 885 ret.AddRange(await GetAndExecuteAsync(pool, c => c.Value.PubSubChannelsAsync(pattern))); 886 return ret.ToArray(); 887 } 888 /// <summary> 889 /// 查看所有模糊订阅端的数量 890 /// </summary> 891 /// <returns></returns> 892 [Obsolete("分区模式下，其他客户端的模糊订阅可能不会返回")] 893 public Task<long> PubSubNumPatAsync() => GetAndExecuteAsync(Nodes.First().Value, c => c.Value.PubSubNumPatAsync()); 894 /// <summary> 895 /// 查看所有订阅端的数量 896 /// </summary> 897 /// <param name="channels">频道</param> 898 /// <returns></returns> 899 [Obsolete("分区模式下，其他客户端的订阅可能不会返回")] 900 async public Task<Dictionary<string, long>> PubSubNumSubAsync(params string[] channels) => (await ExecuteArrayAsync(channels, (c, k) => 901 { 902 var prefix = (c.Pool as RedisClientPool).Prefix; 903 return c.Value.PubSubNumSubAsync(k.Select(z => string.IsNullOrEmpty(prefix) == false && z.StartsWith(prefix) ? z.Substring(prefix.Length) : z).ToArray()); 904 })).ToDictionary(z => z.Item1, y => y.Item2); 905 #endregion 906 907 #region HyperLogLog 908 /// <summary> 909 /// 添加指定元素到 HyperLogLog 910 /// </summary> 911 /// <param name="key">不含prefix前辍</param> 912 /// <param name="elements">元素</param> 913 /// <returns></returns> 914 async public Task<bool> PfAddAsync<T>(string key, params T[] elements) 915 { 916 if (elements == null || elements.Any() == false) return false; 917 var args = elements.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 918 return await ExecuteScalarAsync(key, (c, k) => c.Value.PfAddAsync(k, args)); 919 } 920 /// <summary> 921 /// 返回给定 HyperLogLog 的基数估算值 922 /// </summary> 923 /// <param name="keys">不含prefix前辍</param> 924 /// <returns></returns> 925 [Obsolete("分区模式下，若keys分散在多个分区节点时，将报错")] 926 public Task<long> PfCountAsync(params string[] keys) => NodesNotSupportAsync(keys, 0, (c, k) => c.Value.PfCountAsync(k)); 927 /// <summary> 928 /// 将多个 HyperLogLog 合并为一个 HyperLogLog 929 /// </summary> 930 /// <param name="destKey">新的 HyperLogLog，不含prefix前辍</param> 931 /// <param name="sourceKeys">源 HyperLogLog，不含prefix前辍</param> 932 /// <returns></returns> 933 [Obsolete("分区模式下，若keys分散在多个分区节点时，将报错")] 934 public Task<bool> PfMergeAsync(string destKey, params string[] sourceKeys) => NodesNotSupportAsync(new[] { destKey }.Concat(sourceKeys).ToArray(), false, async (c, k) => await c.Value.PfMergeAsync(k.First(), k.Skip(1).ToArray()) == "OK"); 935 #endregion 936 937 #region Sorted Set 938 /// <summary> 939 /// [redis-server 5.0.0] 删除并返回有序集合key中的最多count个具有最高得分的成员。如未指定，count的默认值为1。指定一个大于有序集合的基数的count不会产生错误。 当返回多个元素时候，得分最高的元素将是第一个元素，然后是分数较低的元素。 940 /// </summary> 941 /// <param name="key">不含prefix前辍</param> 942 /// <param name="count">数量</param> 943 /// <returns></returns> 944 async public Task<(string member, decimal score)[]> ZPopMaxAsync(string key, long count) => (await ExecuteScalarAsync(key, (c, k) => c.Value.ZPopMaxAsync(k, count))).Select(a => (a.Item1, a.Item2)).ToArray(); 945 /// <summary> 946 /// [redis-server 5.0.0] 删除并返回有序集合key中的最多count个具有最高得分的成员。如未指定，count的默认值为1。指定一个大于有序集合的基数的count不会产生错误。 当返回多个元素时候，得分最高的元素将是第一个元素，然后是分数较低的元素。 947 /// </summary> 948 /// <param name="key">不含prefix前辍</param> 949 /// <param name="count">数量</param> 950 /// <returns></returns> 951 async public Task<(T member, decimal score)[]> ZPopMaxAsync<T>(string key, long count) => this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZPopMaxBytesAsync(k, count))); 952 /// <summary> 953 /// [redis-server 5.0.0] 删除并返回有序集合key中的最多count个具有最低得分的成员。如未指定，count的默认值为1。指定一个大于有序集合的基数的count不会产生错误。 当返回多个元素时候，得分最低的元素将是第一个元素，然后是分数较高的元素。 954 /// </summary> 955 /// <param name="key">不含prefix前辍</param> 956 /// <param name="count">数量</param> 957 /// <returns></returns> 958 async public Task<(string member, decimal score)[]> ZPopMinAsync(string key, long count) => (await ExecuteScalarAsync(key, (c, k) => c.Value.ZPopMinAsync(k, count))).Select(a => (a.Item1, a.Item2)).ToArray(); 959 /// <summary> 960 /// [redis-server 5.0.0] 删除并返回有序集合key中的最多count个具有最低得分的成员。如未指定，count的默认值为1。指定一个大于有序集合的基数的count不会产生错误。 当返回多个元素时候，得分最低的元素将是第一个元素，然后是分数较高的元素。 961 /// </summary> 962 /// <param name="key">不含prefix前辍</param> 963 /// <param name="count">数量</param> 964 /// <returns></returns> 965 async public Task<(T member, decimal score)[]> ZPopMinAsync<T>(string key, long count) => this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZPopMinBytesAsync(k, count))); 966 967 /// <summary> 968 /// 向有序集合添加一个或多个成员，或者更新已存在成员的分数 969 /// </summary> 970 /// <param name="key">不含prefix前辍</param> 971 /// <param name="scoreMembers">一个或多个成员分数</param> 972 /// <returns></returns> 973 async public Task<long> ZAddAsync(string key, params (decimal, object)[] scoreMembers) 974 { 975 if (scoreMembers == null || scoreMembers.Any() == false) return 0; 976 var args = scoreMembers.Select(a => new Tuple<decimal, object>(a.Item1, this.SerializeRedisValueInternal(a.Item2))).ToArray(); 977 return await ExecuteScalarAsync(key, (c, k) => c.Value.ZAddAsync(k, args)); 978 } 979 /// <summary> 980 /// 获取有序集合的成员数量 981 /// </summary> 982 /// <param name="key">不含prefix前辍</param> 983 /// <returns></returns> 984 public Task<long> ZCardAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.ZCardAsync(k)); 985 /// <summary> 986 /// 计算在有序集合中指定区间分数的成员数量 987 /// </summary> 988 /// <param name="key">不含prefix前辍</param> 989 /// <param name="min">分数最小值 decimal.MinValue 1</param> 990 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 991 /// <returns></returns> 992 public Task<long> ZCountAsync(string key, decimal min, decimal max) => ExecuteScalarAsync(key, (c, k) => c.Value.ZCountAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString())); 993 /// <summary> 994 /// 计算在有序集合中指定区间分数的成员数量 995 /// </summary> 996 /// <param name="key">不含prefix前辍</param> 997 /// <param name="min">分数最小值 -inf (1 1</param> 998 /// <param name="max">分数最大值 +inf (10 10</param> 999 /// <returns></returns> 1000 public Task<long> ZCountAsync(string key, string min, string max) => ExecuteScalarAsync(key, (c, k) => c.Value.ZCountAsync(k, min, max)); 1001 /// <summary> 1002 /// 有序集合中对指定成员的分数加上增量 increment 1003 /// </summary> 1004 /// <param name="key">不含prefix前辍</param> 1005 /// <param name="member">成员</param> 1006 /// <param name="increment">增量值(默认=1)</param> 1007 /// <returns></returns> 1008 public Task<decimal> ZIncrByAsync(string key, string member, decimal increment = 1) 1009 { 1010 var args = this.SerializeRedisValueInternal(member); 1011 return ExecuteScalarAsync(key, (c, k) => c.Value.ZIncrByAsync(k, increment, args)); 1012 } 1013 1014 /// <summary> 1015 /// 计算给定的一个或多个有序集的交集，将结果集存储在新的有序集合 destination 中 1016 /// </summary> 1017 /// <param name="destination">新的有序集合，不含prefix前辍</param> 1018 /// <param name="weights">使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。</param> 1019 /// <param name="aggregate">Sum | Min | Max</param> 1020 /// <param name="keys">一个或多个有序集合，不含prefix前辍</param> 1021 /// <returns></returns> 1022 public Task<long> ZInterStoreAsync(string destination, decimal[] weights, RedisAggregate aggregate, params string[] keys) 1023 { 1024 if (keys == null || keys.Length == 0) throw new Exception("keys 参数不可为空"); 1025 if (weights != null && weights.Length != keys.Length) throw new Exception("weights 和 keys 参数长度必须相同"); 1026 return NodesNotSupportAsync(new[] { destination }.Concat(keys).ToArray(), 0, (c, k) => c.Value.ZInterStoreAsync(k.First(), weights, aggregate, k.Skip(1).ToArray())); 1027 } 1028 1029 /// <summary> 1030 /// 通过索引区间返回有序集合成指定区间内的成员 1031 /// </summary> 1032 /// <param name="key">不含prefix前辍</param> 1033 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1034 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1035 /// <returns></returns> 1036 public Task<string[]> ZRangeAsync(string key, long start, long stop) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeAsync(k, start, stop, false)); 1037 /// <summary> 1038 /// 通过索引区间返回有序集合成指定区间内的成员 1039 /// </summary> 1040 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1041 /// <param name="key">不含prefix前辍</param> 1042 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1043 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1044 /// <returns></returns> 1045 async public Task<T[]> ZRangeAsync<T>(string key, long start, long stop) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesAsync(k, start, stop, false))); 1046 /// <summary> 1047 /// 通过索引区间返回有序集合成指定区间内的成员和分数 1048 /// </summary> 1049 /// <param name="key">不含prefix前辍</param> 1050 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1051 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1052 /// <returns></returns> 1053 async public Task<(string member, decimal score)[]> ZRangeWithScoresAsync(string key, long start, long stop) => (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeWithScoresAsync(k, start, stop))).Select(a => (a.Item1, a.Item2)).ToArray(); 1054 /// <summary> 1055 /// 通过索引区间返回有序集合成指定区间内的成员和分数 1056 /// </summary> 1057 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1058 /// <param name="key">不含prefix前辍</param> 1059 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1060 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1061 /// <returns></returns> 1062 async public Task<(T member, decimal score)[]> ZRangeWithScoresAsync<T>(string key, long start, long stop) => this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesWithScoresAsync(k, start, stop))); 1063 1064 /// <summary> 1065 /// 通过分数返回有序集合指定区间内的成员 1066 /// </summary> 1067 /// <param name="key">不含prefix前辍</param> 1068 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1069 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1070 /// <param name="count">返回多少成员</param> 1071 /// <param name="offset">返回条件偏移位置</param> 1072 /// <returns></returns> 1073 public Task<string[]> ZRangeByScoreAsync(string key, decimal min, decimal max, long? count = null, long offset = 0) => 1074 ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeByScoreAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString(), false, offset, count)); 1075 /// <summary> 1076 /// 通过分数返回有序集合指定区间内的成员 1077 /// </summary> 1078 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1079 /// <param name="key">不含prefix前辍</param> 1080 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1081 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1082 /// <param name="count">返回多少成员</param> 1083 /// <param name="offset">返回条件偏移位置</param> 1084 /// <returns></returns> 1085 async public Task<T[]> ZRangeByScoreAsync<T>(string key, decimal min, decimal max, long? count = null, long offset = 0) => 1086 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesByScoreAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString(), false, offset, count))); 1087 /// <summary> 1088 /// 通过分数返回有序集合指定区间内的成员 1089 /// </summary> 1090 /// <param name="key">不含prefix前辍</param> 1091 /// <param name="min">分数最小值 -inf (1 1</param> 1092 /// <param name="max">分数最大值 +inf (10 10</param> 1093 /// <param name="count">返回多少成员</param> 1094 /// <param name="offset">返回条件偏移位置</param> 1095 /// <returns></returns> 1096 public Task<string[]> ZRangeByScoreAsync(string key, string min, string max, long? count = null, long offset = 0) => 1097 ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeByScoreAsync(k, min, max, false, offset, count)); 1098 /// <summary> 1099 /// 通过分数返回有序集合指定区间内的成员 1100 /// </summary> 1101 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1102 /// <param name="key">不含prefix前辍</param> 1103 /// <param name="min">分数最小值 -inf (1 1</param> 1104 /// <param name="max">分数最大值 +inf (10 10</param> 1105 /// <param name="count">返回多少成员</param> 1106 /// <param name="offset">返回条件偏移位置</param> 1107 /// <returns></returns> 1108 async public Task<T[]> ZRangeByScoreAsync<T>(string key, string min, string max, long? count = null, long offset = 0) => 1109 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesByScoreAsync(k, min, max, false, offset, count))); 1110 1111 /// <summary> 1112 /// 通过分数返回有序集合指定区间内的成员和分数 1113 /// </summary> 1114 /// <param name="key">不含prefix前辍</param> 1115 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1116 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1117 /// <param name="count">返回多少成员</param> 1118 /// <param name="offset">返回条件偏移位置</param> 1119 /// <returns></returns> 1120 async public Task<(string member, decimal score)[]> ZRangeByScoreWithScoresAsync(string key, decimal min, decimal max, long? count = null, long offset = 0) => 1121 (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeByScoreWithScoresAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString(), offset, count))).Select(z => (z.Item1, z.Item2)).ToArray(); 1122 /// <summary> 1123 /// 通过分数返回有序集合指定区间内的成员和分数 1124 /// </summary> 1125 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1126 /// <param name="key">不含prefix前辍</param> 1127 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1128 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1129 /// <param name="count">返回多少成员</param> 1130 /// <param name="offset">返回条件偏移位置</param> 1131 /// <returns></returns> 1132 async public Task<(T member, decimal score)[]> ZRangeByScoreWithScoresAsync<T>(string key, decimal min, decimal max, long? count = null, long offset = 0) => 1133 this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesByScoreWithScoresAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString(), offset, count))); 1134 /// <summary> 1135 /// 通过分数返回有序集合指定区间内的成员和分数 1136 /// </summary> 1137 /// <param name="key">不含prefix前辍</param> 1138 /// <param name="min">分数最小值 -inf (1 1</param> 1139 /// <param name="max">分数最大值 +inf (10 10</param> 1140 /// <param name="count">返回多少成员</param> 1141 /// <param name="offset">返回条件偏移位置</param> 1142 /// <returns></returns> 1143 async public Task<(string member, decimal score)[]> ZRangeByScoreWithScoresAsync(string key, string min, string max, long? count = null, long offset = 0) => 1144 (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeByScoreWithScoresAsync(k, min, max, offset, count))).Select(z => (z.Item1, z.Item2)).ToArray(); 1145 /// <summary> 1146 /// 通过分数返回有序集合指定区间内的成员和分数 1147 /// </summary> 1148 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1149 /// <param name="key">不含prefix前辍</param> 1150 /// <param name="min">分数最小值 -inf (1 1</param> 1151 /// <param name="max">分数最大值 +inf (10 10</param> 1152 /// <param name="count">返回多少成员</param> 1153 /// <param name="offset">返回条件偏移位置</param> 1154 /// <returns></returns> 1155 async public Task<(T member, decimal score)[]> ZRangeByScoreWithScoresAsync<T>(string key, string min, string max, long? count = null, long offset = 0) => 1156 this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesByScoreWithScoresAsync(k, min, max, offset, count))); 1157 1158 /// <summary> 1159 /// 返回有序集合中指定成员的索引 1160 /// </summary> 1161 /// <param name="key">不含prefix前辍</param> 1162 /// <param name="member">成员</param> 1163 /// <returns></returns> 1164 public Task<long?> ZRankAsync(string key, object member) 1165 { 1166 var args = this.SerializeRedisValueInternal(member); 1167 return ExecuteScalarAsync(key, (c, k) => c.Value.ZRankAsync(k, args)); 1168 } 1169 /// <summary> 1170 /// 移除有序集合中的一个或多个成员 1171 /// </summary> 1172 /// <param name="key">不含prefix前辍</param> 1173 /// <param name="member">一个或多个成员</param> 1174 /// <returns></returns> 1175 async public Task<long> ZRemAsync<T>(string key, params T[] member) 1176 { 1177 if (member == null || member.Any() == false) return 0; 1178 var args = member.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 1179 return await ExecuteScalarAsync(key, (c, k) => c.Value.ZRemAsync(k, args)); 1180 } 1181 /// <summary> 1182 /// 移除有序集合中给定的排名区间的所有成员 1183 /// </summary> 1184 /// <param name="key">不含prefix前辍</param> 1185 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1186 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1187 /// <returns></returns> 1188 public Task<long> ZRemRangeByRankAsync(string key, long start, long stop) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRemRangeByRankAsync(k, start, stop)); 1189 /// <summary> 1190 /// 移除有序集合中给定的分数区间的所有成员 1191 /// </summary> 1192 /// <param name="key">不含prefix前辍</param> 1193 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1194 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1195 /// <returns></returns> 1196 public Task<long> ZRemRangeByScoreAsync(string key, decimal min, decimal max) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRemRangeByScoreAsync(k, min == decimal.MinValue ? "-inf" : min.ToString(), max == decimal.MaxValue ? "+inf" : max.ToString())); 1197 /// <summary> 1198 /// 移除有序集合中给定的分数区间的所有成员 1199 /// </summary> 1200 /// <param name="key">不含prefix前辍</param> 1201 /// <param name="min">分数最小值 -inf (1 1</param> 1202 /// <param name="max">分数最大值 +inf (10 10</param> 1203 /// <returns></returns> 1204 public Task<long> ZRemRangeByScoreAsync(string key, string min, string max) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRemRangeByScoreAsync(k, min, max)); 1205 1206 /// <summary> 1207 /// 返回有序集中指定区间内的成员，通过索引，分数从高到底 1208 /// </summary> 1209 /// <param name="key">不含prefix前辍</param> 1210 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1211 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1212 /// <returns></returns> 1213 public Task<string[]> ZRevRangeAsync(string key, long start, long stop) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeAsync(k, start, stop, false)); 1214 /// <summary> 1215 /// 返回有序集中指定区间内的成员，通过索引，分数从高到底 1216 /// </summary> 1217 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1218 /// <param name="key">不含prefix前辍</param> 1219 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1220 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1221 /// <returns></returns> 1222 async public Task<T[]> ZRevRangeAsync<T>(string key, long start, long stop) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesAsync(k, start, stop, false))); 1223 /// <summary> 1224 /// 返回有序集中指定区间内的成员和分数，通过索引，分数从高到底 1225 /// </summary> 1226 /// <param name="key">不含prefix前辍</param> 1227 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1228 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1229 /// <returns></returns> 1230 async public Task<(string member, decimal score)[]> ZRevRangeWithScoresAsync(string key, long start, long stop) => (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeWithScoresAsync(k, start, stop))).Select(a => (a.Item1, a.Item2)).ToArray(); 1231 /// <summary> 1232 /// 返回有序集中指定区间内的成员和分数，通过索引，分数从高到底 1233 /// </summary> 1234 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1235 /// <param name="key">不含prefix前辍</param> 1236 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1237 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1238 /// <returns></returns> 1239 async public Task<(T member, decimal score)[]> ZRevRangeWithScoresAsync<T>(string key, long start, long stop) => this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesWithScoresAsync(k, start, stop))); 1240 1241 /// <summary> 1242 /// 返回有序集中指定分数区间内的成员，分数从高到低排序 1243 /// </summary> 1244 /// <param name="key">不含prefix前辍</param> 1245 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1246 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1247 /// <param name="count">返回多少成员</param> 1248 /// <param name="offset">返回条件偏移位置</param> 1249 /// <returns></returns> 1250 public Task<string[]> ZRevRangeByScoreAsync(string key, decimal max, decimal min, long? count = null, long? offset = 0) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeByScoreAsync(k, max == decimal.MaxValue ? "+inf" : max.ToString(), min == decimal.MinValue ? "-inf" : min.ToString(), false, offset, count)); 1251 /// <summary> 1252 /// 返回有序集中指定分数区间内的成员，分数从高到低排序 1253 /// </summary> 1254 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1255 /// <param name="key">不含prefix前辍</param> 1256 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1257 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1258 /// <param name="count">返回多少成员</param> 1259 /// <param name="offset">返回条件偏移位置</param> 1260 /// <returns></returns> 1261 async public Task<T[]> ZRevRangeByScoreAsync<T>(string key, decimal max, decimal min, long? count = null, long offset = 0) => 1262 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesByScoreAsync(k, max == decimal.MaxValue ? "+inf" : max.ToString(), min == decimal.MinValue ? "-inf" : min.ToString(), false, offset, count))); 1263 /// <summary> 1264 /// 返回有序集中指定分数区间内的成员，分数从高到低排序 1265 /// </summary> 1266 /// <param name="key">不含prefix前辍</param> 1267 /// <param name="max">分数最大值 +inf (10 10</param> 1268 /// <param name="min">分数最小值 -inf (1 1</param> 1269 /// <param name="count">返回多少成员</param> 1270 /// <param name="offset">返回条件偏移位置</param> 1271 /// <returns></returns> 1272 public Task<string[]> ZRevRangeByScoreAsync(string key, string max, string min, long? count = null, long? offset = 0) => ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeByScoreAsync(k, max, min, false, offset, count)); 1273 /// <summary> 1274 /// 返回有序集中指定分数区间内的成员，分数从高到低排序 1275 /// </summary> 1276 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1277 /// <param name="key">不含prefix前辍</param> 1278 /// <param name="max">分数最大值 +inf (10 10</param> 1279 /// <param name="min">分数最小值 -inf (1 1</param> 1280 /// <param name="count">返回多少成员</param> 1281 /// <param name="offset">返回条件偏移位置</param> 1282 /// <returns></returns> 1283 async public Task<T[]> ZRevRangeByScoreAsync<T>(string key, string max, string min, long? count = null, long offset = 0) => 1284 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesByScoreAsync(k, max, min, false, offset, count))); 1285 1286 /// <summary> 1287 /// 返回有序集中指定分数区间内的成员和分数，分数从高到低排序 1288 /// </summary> 1289 /// <param name="key">不含prefix前辍</param> 1290 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1291 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1292 /// <param name="count">返回多少成员</param> 1293 /// <param name="offset">返回条件偏移位置</param> 1294 /// <returns></returns> 1295 async public Task<(string member, decimal score)[]> ZRevRangeByScoreWithScoresAsync(string key, decimal max, decimal min, long? count = null, long offset = 0) => 1296 (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeByScoreWithScoresAsync(k, max == decimal.MaxValue ? "+inf" : max.ToString(), min == decimal.MinValue ? "-inf" : min.ToString(), offset, count))).Select(z => (z.Item1, z.Item2)).ToArray(); 1297 /// <summary> 1298 /// 返回有序集中指定分数区间内的成员和分数，分数从高到低排序 1299 /// </summary> 1300 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1301 /// <param name="key">不含prefix前辍</param> 1302 /// <param name="max">分数最大值 decimal.MaxValue 10</param> 1303 /// <param name="min">分数最小值 decimal.MinValue 1</param> 1304 /// <param name="count">返回多少成员</param> 1305 /// <param name="offset">返回条件偏移位置</param> 1306 /// <returns></returns> 1307 async public Task<(T member, decimal score)[]> ZRevRangeByScoreWithScoresAsync<T>(string key, decimal max, decimal min, long? count = null, long offset = 0) => 1308 this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesByScoreWithScoresAsync(k, max == decimal.MaxValue ? "+inf" : max.ToString(), min == decimal.MinValue ? "-inf" : min.ToString(), offset, count))); 1309 /// <summary> 1310 /// 返回有序集中指定分数区间内的成员和分数，分数从高到低排序 1311 /// </summary> 1312 /// <param name="key">不含prefix前辍</param> 1313 /// <param name="max">分数最大值 +inf (10 10</param> 1314 /// <param name="min">分数最小值 -inf (1 1</param> 1315 /// <param name="count">返回多少成员</param> 1316 /// <param name="offset">返回条件偏移位置</param> 1317 /// <returns></returns> 1318 async public Task<(string member, decimal score)[]> ZRevRangeByScoreWithScoresAsync(string key, string max, string min, long? count = null, long offset = 0) => 1319 (await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeByScoreWithScoresAsync(k, max, min, offset, count))).Select(z => (z.Item1, z.Item2)).ToArray(); 1320 /// <summary> 1321 /// 返回有序集中指定分数区间内的成员和分数，分数从高到低排序 1322 /// </summary> 1323 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1324 /// <param name="key">不含prefix前辍</param> 1325 /// <param name="max">分数最大值 +inf (10 10</param> 1326 /// <param name="min">分数最小值 -inf (1 1</param> 1327 /// <param name="count">返回多少成员</param> 1328 /// <param name="offset">返回条件偏移位置</param> 1329 /// <returns></returns> 1330 async public Task<(T member, decimal score)[]> ZRevRangeByScoreWithScoresAsync<T>(string key, string max, string min, long? count = null, long offset = 0) => 1331 this.DeserializeRedisValueTuple1Internal<T, decimal>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRangeBytesByScoreWithScoresAsync(k, max, min, offset, count))); 1332 1333 /// <summary> 1334 /// 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序 1335 /// </summary> 1336 /// <param name="key">不含prefix前辍</param> 1337 /// <param name="member">成员</param> 1338 /// <returns></returns> 1339 public Task<long?> ZRevRankAsync(string key, object member) 1340 { 1341 var args = this.SerializeRedisValueInternal(member); 1342 return ExecuteScalarAsync(key, (c, k) => c.Value.ZRevRankAsync(k, args)); 1343 } 1344 /// <summary> 1345 /// 返回有序集中，成员的分数值 1346 /// </summary> 1347 /// <param name="key">不含prefix前辍</param> 1348 /// <param name="member">成员</param> 1349 /// <returns></returns> 1350 public Task<decimal?> ZScoreAsync(string key, object member) 1351 { 1352 var args = this.SerializeRedisValueInternal(member); 1353 return ExecuteScalarAsync(key, (c, k) => c.Value.ZScoreAsync(k, args)); 1354 } 1355 1356 /// <summary> 1357 /// 计算给定的一个或多个有序集的并集，将结果集存储在新的有序集合 destination 中 1358 /// </summary> 1359 /// <param name="destination">新的有序集合，不含prefix前辍</param> 1360 /// <param name="weights">使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。</param> 1361 /// <param name="aggregate">Sum | Min | Max</param> 1362 /// <param name="keys">一个或多个有序集合，不含prefix前辍</param> 1363 /// <returns></returns> 1364 public Task<long> ZUnionStoreAsync(string destination, decimal[] weights, RedisAggregate aggregate, params string[] keys) 1365 { 1366 if (keys == null || keys.Length == 0) throw new Exception("keys 参数不可为空"); 1367 if (weights != null && weights.Length != keys.Length) throw new Exception("weights 和 keys 参数长度必须相同"); 1368 return NodesNotSupportAsync(new[] { destination }.Concat(keys).ToArray(), 0, (c, k) => c.Value.ZUnionStoreAsync(k.First(), weights, aggregate, k.Skip(1).ToArray())); 1369 } 1370 1371 /// <summary> 1372 /// 迭代有序集合中的元素 1373 /// </summary> 1374 /// <param name="key">不含prefix前辍</param> 1375 /// <param name="cursor">位置</param> 1376 /// <param name="pattern">模式</param> 1377 /// <param name="count">数量</param> 1378 /// <returns></returns> 1379 async public Task<RedisScan<(string member, decimal score)>> ZScanAsync(string key, long cursor, string pattern = null, long? count = null) 1380 { 1381 var scan = await ExecuteScalarAsync(key, (c, k) => c.Value.ZScanAsync(k, cursor, pattern, count)); 1382 return new RedisScan<(string, decimal)>(scan.Cursor, scan.Items.Select(z => (z.Item1, z.Item2)).ToArray()); 1383 } 1384 /// <summary> 1385 /// 迭代有序集合中的元素 1386 /// </summary> 1387 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1388 /// <param name="key">不含prefix前辍</param> 1389 /// <param name="cursor">位置</param> 1390 /// <param name="pattern">模式</param> 1391 /// <param name="count">数量</param> 1392 /// <returns></returns> 1393 async public Task<RedisScan<(T member, decimal score)>> ZScanAsync<T>(string key, long cursor, string pattern = null, long? count = null) 1394 { 1395 var scan = await ExecuteScalarAsync(key, (c, k) => c.Value.ZScanBytesAsync(k, cursor, pattern, count)); 1396 return new RedisScan<(T, decimal)>(scan.Cursor, this.DeserializeRedisValueTuple1Internal<T, decimal>(scan.Items)); 1397 } 1398 1399 /// <summary> 1400 /// 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序，这个命令可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员。 1401 /// </summary> 1402 /// <param name="key">不含prefix前辍</param> 1403 /// <param name="min">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1404 /// <param name="max">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1405 /// <param name="count">返回多少成员</param> 1406 /// <param name="offset">返回条件偏移位置</param> 1407 /// <returns></returns> 1408 public Task<string[]> ZRangeByLexAsync(string key, string min, string max, long? count = null, long offset = 0) => 1409 ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeByLexAsync(k, min, max, offset, count)); 1410 /// <summary> 1411 /// 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序，这个命令可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员。 1412 /// </summary> 1413 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1414 /// <param name="key">不含prefix前辍</param> 1415 /// <param name="min">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1416 /// <param name="max">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1417 /// <param name="count">返回多少成员</param> 1418 /// <param name="offset">返回条件偏移位置</param> 1419 /// <returns></returns> 1420 async public Task<T[]> ZRangeByLexAsync<T>(string key, string min, string max, long? count = null, long offset = 0) => 1421 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.ZRangeBytesByLexAsync(k, min, max, offset, count))); 1422 1423 /// <summary> 1424 /// 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序，这个命令可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员。 1425 /// </summary> 1426 /// <param name="key">不含prefix前辍</param> 1427 /// <param name="min">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1428 /// <param name="max">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1429 /// <returns></returns> 1430 public Task<long> ZRemRangeByLexAsync(string key, string min, string max) => 1431 ExecuteScalarAsync(key, (c, k) => c.Value.ZRemRangeByLexAsync(k, min, max)); 1432 /// <summary> 1433 /// 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序，这个命令可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员。 1434 /// </summary> 1435 /// <param name="key">不含prefix前辍</param> 1436 /// <param name="min">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1437 /// <param name="max">'(' 表示包含在范围，'[' 表示不包含在范围，'+' 正无穷大，'-' 负无限。 ZRANGEBYLEX zset - + ，命令将返回有序集合中的所有元素</param> 1438 /// <returns></returns> 1439 public Task<long> ZLexCountAsync(string key, string min, string max) => 1440 ExecuteScalarAsync(key, (c, k) => c.Value.ZLexCountAsync(k, min, max)); 1441 #endregion 1442 1443 #region Set 1444 /// <summary> 1445 /// 向集合添加一个或多个成员 1446 /// </summary> 1447 /// <param name="key">不含prefix前辍</param> 1448 /// <param name="members">一个或多个成员</param> 1449 /// <returns></returns> 1450 async public Task<long> SAddAsync<T>(string key, params T[] members) 1451 { 1452 if (members == null || members.Any() == false) return 0; 1453 var args = members.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 1454 return await ExecuteScalarAsync(key, (c, k) => c.Value.SAddAsync(k, args)); 1455 } 1456 /// <summary> 1457 /// 获取集合的成员数 1458 /// </summary> 1459 /// <param name="key">不含prefix前辍</param> 1460 /// <returns></returns> 1461 public Task<long> SCardAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.SCardAsync(k)); 1462 /// <summary> 1463 /// 返回给定所有集合的差集 1464 /// </summary> 1465 /// <param name="keys">不含prefix前辍</param> 1466 /// <returns></returns> 1467 public Task<string[]> SDiffAsync(params string[] keys) => NodesNotSupportAsync(keys, new string[0], (c, k) => c.Value.SDiffAsync(k)); 1468 /// <summary> 1469 /// 返回给定所有集合的差集 1470 /// </summary> 1471 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1472 /// <param name="keys">不含prefix前辍</param> 1473 /// <returns></returns> 1474 async public Task<T[]> SDiffAsync<T>(params string[] keys) => this.DeserializeRedisValueArrayInternal<T>(await NodesNotSupportAsync(keys, new byte[0][], (c, k) => c.Value.SDiffBytesAsync(k))); 1475 /// <summary> 1476 /// 返回给定所有集合的差集并存储在 destination 中 1477 /// </summary> 1478 /// <param name="destination">新的无序集合，不含prefix前辍</param> 1479 /// <param name="keys">一个或多个无序集合，不含prefix前辍</param> 1480 /// <returns></returns> 1481 public Task<long> SDiffStoreAsync(string destination, params string[] keys) => NodesNotSupportAsync(new[] { destination }.Concat(keys).ToArray(), 0, (c, k) => c.Value.SDiffStoreAsync(k.First(), k.Skip(1).ToArray())); 1482 /// <summary> 1483 /// 返回给定所有集合的交集 1484 /// </summary> 1485 /// <param name="keys">不含prefix前辍</param> 1486 /// <returns></returns> 1487 public Task<string[]> SInterAsync(params string[] keys) => NodesNotSupportAsync(keys, new string[0], (c, k) => c.Value.SInterAsync(k)); 1488 /// <summary> 1489 /// 返回给定所有集合的交集 1490 /// </summary> 1491 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1492 /// <param name="keys">不含prefix前辍</param> 1493 /// <returns></returns> 1494 async public Task<T[]> SInterAsync<T>(params string[] keys) => this.DeserializeRedisValueArrayInternal<T>(await NodesNotSupportAsync(keys, new byte[0][], (c, k) => c.Value.SInterBytesAsync(k))); 1495 /// <summary> 1496 /// 返回给定所有集合的交集并存储在 destination 中 1497 /// </summary> 1498 /// <param name="destination">新的无序集合，不含prefix前辍</param> 1499 /// <param name="keys">一个或多个无序集合，不含prefix前辍</param> 1500 /// <returns></returns> 1501 public Task<long> SInterStoreAsync(string destination, params string[] keys) => NodesNotSupportAsync(new[] { destination }.Concat(keys).ToArray(), 0, (c, k) => c.Value.SInterStoreAsync(k.First(), k.Skip(1).ToArray())); 1502 /// <summary> 1503 /// 判断 member 元素是否是集合 key 的成员 1504 /// </summary> 1505 /// <param name="key">不含prefix前辍</param> 1506 /// <param name="member">成员</param> 1507 /// <returns></returns> 1508 public Task<bool> SIsMemberAsync(string key, object member) 1509 { 1510 var args = this.SerializeRedisValueInternal(member); 1511 return ExecuteScalarAsync(key, (c, k) => c.Value.SIsMemberAsync(k, args)); 1512 } 1513 /// <summary> 1514 /// 返回集合中的所有成员 1515 /// </summary> 1516 /// <param name="key">不含prefix前辍</param> 1517 /// <returns></returns> 1518 public Task<string[]> SMembersAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.SMembersAsync(k)); 1519 /// <summary> 1520 /// 返回集合中的所有成员 1521 /// </summary> 1522 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1523 /// <param name="key">不含prefix前辍</param> 1524 /// <returns></returns> 1525 async public Task<T[]> SMembersAsync<T>(string key) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.SMembersBytesAsync(k))); 1526 /// <summary> 1527 /// 将 member 元素从 source 集合移动到 destination 集合 1528 /// </summary> 1529 /// <param name="source">无序集合key，不含prefix前辍</param> 1530 /// <param name="destination">目标无序集合key，不含prefix前辍</param> 1531 /// <param name="member">成员</param> 1532 /// <returns></returns> 1533 async public Task<bool> SMoveAsync(string source, string destination, object member) 1534 { 1535 string rule = string.Empty; 1536 if (Nodes.Count > 1) 1537 { 1538 var rule1 = NodeRuleRaw(source); 1539 var rule2 = NodeRuleRaw(destination); 1540 if (rule1 != rule2) 1541 { 1542 if (await SRemAsync(source, member) <= 0) return false; 1543 return await SAddAsync(destination, member) > 0; 1544 } 1545 rule = rule1; 1546 } 1547 var pool = Nodes.TryGetValue(rule, out var b) ? b : Nodes.First().Value; 1548 var key1 = string.Concat(pool.Prefix, source); 1549 var key2 = string.Concat(pool.Prefix, destination); 1550 var args = this.SerializeRedisValueInternal(member); 1551 return await GetAndExecuteAsync(pool, conn => conn.Value.SMoveAsync(key1, key2, args)); 1552 } 1553 /// <summary> 1554 /// 移除并返回集合中的一个随机元素 1555 /// </summary> 1556 /// <param name="key">不含prefix前辍</param> 1557 /// <returns></returns> 1558 public Task<string> SPopAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.SPopAsync(k)); 1559 /// <summary> 1560 /// 移除并返回集合中的一个随机元素 1561 /// </summary> 1562 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1563 /// <param name="key">不含prefix前辍</param> 1564 /// <returns></returns> 1565 async public Task<T> SPopAsync<T>(string key) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.SPopBytesAsync(k))); 1566 /// <summary> 1567 /// [redis-server 3.2] 移除并返回集合中的一个或多个随机元素 1568 /// </summary> 1569 /// <param name="key">不含prefix前辍</param> 1570 /// <param name="count">移除并返回的个数</param> 1571 /// <returns></returns> 1572 public Task<string[]> SPopAsync(string key, long count) => ExecuteScalarAsync(key, (c, k) => c.Value.SPopAsync(k, count)); 1573 /// <summary> 1574 /// [redis-server 3.2] 移除并返回集合中的一个或多个随机元素 1575 /// </summary> 1576 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1577 /// <param name="key">不含prefix前辍</param> 1578 /// <param name="count">移除并返回的个数</param> 1579 /// <returns></returns> 1580 async public Task<T[]> SPopAsync<T>(string key, long count) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.SPopBytesAsync(k, count))); 1581 /// <summary> 1582 /// 返回集合中的一个随机元素 1583 /// </summary> 1584 /// <param name="key">不含prefix前辍</param> 1585 /// <returns></returns> 1586 public Task<string> SRandMemberAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.SRandMemberAsync(k)); 1587 /// <summary> 1588 /// 返回集合中的一个随机元素 1589 /// </summary> 1590 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1591 /// <param name="key">不含prefix前辍</param> 1592 /// <returns></returns> 1593 async public Task<T> SRandMemberAsync<T>(string key) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.SRandMemberBytesAsync(k))); 1594 /// <summary> 1595 /// 返回集合中一个或多个随机数的元素 1596 /// </summary> 1597 /// <param name="key">不含prefix前辍</param> 1598 /// <param name="count">返回个数</param> 1599 /// <returns></returns> 1600 public Task<string[]> SRandMembersAsync(string key, int count = 1) => ExecuteScalarAsync(key, (c, k) => c.Value.SRandMembersAsync(k, count)); 1601 /// <summary> 1602 /// 返回集合中一个或多个随机数的元素 1603 /// </summary> 1604 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1605 /// <param name="key">不含prefix前辍</param> 1606 /// <param name="count">返回个数</param> 1607 /// <returns></returns> 1608 async public Task<T[]> SRandMembersAsync<T>(string key, int count = 1) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.SRandMembersBytesAsync(k, count))); 1609 /// <summary> 1610 /// 移除集合中一个或多个成员 1611 /// </summary> 1612 /// <param name="key">不含prefix前辍</param> 1613 /// <param name="members">一个或多个成员</param> 1614 /// <returns></returns> 1615 async public Task<long> SRemAsync<T>(string key, params T[] members) 1616 { 1617 if (members == null || members.Any() == false) return 0; 1618 var args = members.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 1619 return await ExecuteScalarAsync(key, (c, k) => c.Value.SRemAsync(k, args)); 1620 } 1621 /// <summary> 1622 /// 返回所有给定集合的并集 1623 /// </summary> 1624 /// <param name="keys">不含prefix前辍</param> 1625 /// <returns></returns> 1626 public Task<string[]> SUnionAsync(params string[] keys) => NodesNotSupportAsync(keys, new string[0], (c, k) => c.Value.SUnionAsync(k)); 1627 /// <summary> 1628 /// 返回所有给定集合的并集 1629 /// </summary> 1630 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1631 /// <param name="keys">不含prefix前辍</param> 1632 /// <returns></returns> 1633 async public Task<T[]> SUnionAsync<T>(params string[] keys) => this.DeserializeRedisValueArrayInternal<T>(await NodesNotSupportAsync(keys, new byte[0][], (c, k) => c.Value.SUnionBytesAsync(k))); 1634 /// <summary> 1635 /// 所有给定集合的并集存储在 destination 集合中 1636 /// </summary> 1637 /// <param name="destination">新的无序集合，不含prefix前辍</param> 1638 /// <param name="keys">一个或多个无序集合，不含prefix前辍</param> 1639 /// <returns></returns> 1640 public Task<long> SUnionStoreAsync(string destination, params string[] keys) => NodesNotSupportAsync(new[] { destination }.Concat(keys).ToArray(), 0, (c, k) => c.Value.SUnionStoreAsync(k.First(), k.Skip(1).ToArray())); 1641 /// <summary> 1642 /// 迭代集合中的元素 1643 /// </summary> 1644 /// <param name="key">不含prefix前辍</param> 1645 /// <param name="cursor">位置</param> 1646 /// <param name="pattern">模式</param> 1647 /// <param name="count">数量</param> 1648 /// <returns></returns> 1649 public Task<RedisScan<string>> SScanAsync(string key, long cursor, string pattern = null, long? count = null) => ExecuteScalarAsync(key, (c, k) => c.Value.SScanAsync(k, cursor, pattern, count)); 1650 /// <summary> 1651 /// 迭代集合中的元素 1652 /// </summary> 1653 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1654 /// <param name="key">不含prefix前辍</param> 1655 /// <param name="cursor">位置</param> 1656 /// <param name="pattern">模式</param> 1657 /// <param name="count">数量</param> 1658 /// <returns></returns> 1659 async public Task<RedisScan<T>> SScanAsync<T>(string key, long cursor, string pattern = null, long? count = null) 1660 { 1661 var scan = await ExecuteScalarAsync(key, (c, k) => c.Value.SScanBytesAsync(k, cursor, pattern, count)); 1662 return new RedisScan<T>(scan.Cursor, this.DeserializeRedisValueArrayInternal<T>(scan.Items)); 1663 } 1664 #endregion 1665 1666 #region List 1667 /// <summary> 1668 /// 通过索引获取列表中的元素 1669 /// </summary> 1670 /// <param name="key">不含prefix前辍</param> 1671 /// <param name="index">索引</param> 1672 /// <returns></returns> 1673 public Task<string> LIndexAsync(string key, long index) => ExecuteScalarAsync(key, (c, k) => c.Value.LIndexAsync(k, index)); 1674 /// <summary> 1675 /// 通过索引获取列表中的元素 1676 /// </summary> 1677 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1678 /// <param name="key">不含prefix前辍</param> 1679 /// <param name="index">索引</param> 1680 /// <returns></returns> 1681 async public Task<T> LIndexAsync<T>(string key, long index) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.LIndexBytesAsync(k, index))); 1682 /// <summary> 1683 /// 在列表中的元素前面插入元素 1684 /// </summary> 1685 /// <param name="key">不含prefix前辍</param> 1686 /// <param name="pivot">列表的元素</param> 1687 /// <param name="value">新元素</param> 1688 /// <returns></returns> 1689 public Task<long> LInsertBeforeAsync(string key, object pivot, object value) 1690 { 1691 var args = this.SerializeRedisValueInternal(value); 1692 return ExecuteScalarAsync(key, (c, k) => c.Value.LInsertAsync(k, RedisInsert.Before, pivot, args)); 1693 } 1694 /// <summary> 1695 /// 在列表中的元素后面插入元素 1696 /// </summary> 1697 /// <param name="key">不含prefix前辍</param> 1698 /// <param name="pivot">列表的元素</param> 1699 /// <param name="value">新元素</param> 1700 /// <returns></returns> 1701 public Task<long> LInsertAfterAsync(string key, object pivot, object value) 1702 { 1703 var args = this.SerializeRedisValueInternal(value); 1704 return ExecuteScalarAsync(key, (c, k) => c.Value.LInsertAsync(k, RedisInsert.After, pivot, args)); 1705 } 1706 /// <summary> 1707 /// 获取列表长度 1708 /// </summary> 1709 /// <param name="key">不含prefix前辍</param> 1710 /// <returns></returns> 1711 public Task<long> LLenAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.LLenAsync(k)); 1712 /// <summary> 1713 /// 移出并获取列表的第一个元素 1714 /// </summary> 1715 /// <param name="key">不含prefix前辍</param> 1716 /// <returns></returns> 1717 public Task<string> LPopAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.LPopAsync(k)); 1718 /// <summary> 1719 /// 移出并获取列表的第一个元素 1720 /// </summary> 1721 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1722 /// <param name="key">不含prefix前辍</param> 1723 /// <returns></returns> 1724 async public Task<T> LPopAsync<T>(string key) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.LPopBytesAsync(k))); 1725 /// <summary> 1726 /// 将一个或多个值插入到列表头部 1727 /// </summary> 1728 /// <param name="key">不含prefix前辍</param> 1729 /// <param name="value">一个或多个值</param> 1730 /// <returns>执行 LPUSH 命令后，列表的长度</returns> 1731 async public Task<long> LPushAsync<T>(string key, params T[] value) 1732 { 1733 if (value == null || value.Any() == false) return 0; 1734 var args = value.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 1735 return await ExecuteScalarAsync(key, (c, k) => c.Value.LPushAsync(k, args)); 1736 } 1737 /// <summary> 1738 /// 将一个值插入到已存在的列表头部 1739 /// </summary> 1740 /// <param name="key">不含prefix前辍</param> 1741 /// <param name="value">值</param> 1742 /// <returns>执行 LPUSHX 命令后，列表的长度。</returns> 1743 public Task<long> LPushXAsync(string key, object value) 1744 { 1745 var args = this.SerializeRedisValueInternal(value); 1746 return ExecuteScalarAsync(key, (c, k) => c.Value.LPushXAsync(k, args)); 1747 } 1748 /// <summary> 1749 /// 获取列表指定范围内的元素 1750 /// </summary> 1751 /// <param name="key">不含prefix前辍</param> 1752 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1753 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1754 /// <returns></returns> 1755 public Task<string[]> LRangeAsync(string key, long start, long stop) => ExecuteScalarAsync(key, (c, k) => c.Value.LRangeAsync(k, start, stop)); 1756 /// <summary> 1757 /// 获取列表指定范围内的元素 1758 /// </summary> 1759 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1760 /// <param name="key">不含prefix前辍</param> 1761 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1762 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1763 /// <returns></returns> 1764 async public Task<T[]> LRangeAsync<T>(string key, long start, long stop) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.LRangeBytesAsync(k, start, stop))); 1765 /// <summary> 1766 /// 根据参数 count 的值，移除列表中与参数 value 相等的元素 1767 /// </summary> 1768 /// <param name="key">不含prefix前辍</param> 1769 /// <param name="count">移除的数量，大于0时从表头删除数量count，小于0时从表尾删除数量-count，等于0移除所有</param> 1770 /// <param name="value">元素</param> 1771 /// <returns></returns> 1772 public Task<long> LRemAsync(string key, long count, object value) 1773 { 1774 var args = this.SerializeRedisValueInternal(value); 1775 return ExecuteScalarAsync(key, (c, k) => c.Value.LRemAsync(k, count, args)); 1776 } 1777 /// <summary> 1778 /// 通过索引设置列表元素的值 1779 /// </summary> 1780 /// <param name="key">不含prefix前辍</param> 1781 /// <param name="index">索引</param> 1782 /// <param name="value">值</param> 1783 /// <returns></returns> 1784 async public Task<bool> LSetAsync(string key, long index, object value) 1785 { 1786 var args = this.SerializeRedisValueInternal(value); 1787 return await ExecuteScalar(key, (c, k) => c.Value.LSetAsync(k, index, args)) == "OK"; 1788 } 1789 /// <summary> 1790 /// 对一个列表进行修剪，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除 1791 /// </summary> 1792 /// <param name="key">不含prefix前辍</param> 1793 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 1794 /// <param name="stop">结束位置，0表示第一个元素，-1表示最后一个元素</param> 1795 /// <returns></returns> 1796 public Task<bool> LTrimAsync(string key, long start, long stop) => ExecuteScalarAsync(key, async (c, k) => await c.Value.LTrimAsync(k, start, stop) == "OK"); 1797 /// <summary> 1798 /// 移除并获取列表最后一个元素 1799 /// </summary> 1800 /// <param name="key">不含prefix前辍</param> 1801 /// <returns></returns> 1802 public Task<string> RPopAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.RPopAsync(k)); 1803 /// <summary> 1804 /// 移除并获取列表最后一个元素 1805 /// </summary> 1806 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1807 /// <param name="key">不含prefix前辍</param> 1808 /// <returns></returns> 1809 async public Task<T> RPopAsync<T>(string key) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.RPopBytesAsync(k))); 1810 /// <summary> 1811 /// 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。 1812 /// 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。 1813 /// </summary> 1814 /// <param name="source">源key，不含prefix前辍</param> 1815 /// <param name="destination">目标key，不含prefix前辍</param> 1816 /// <returns></returns> 1817 public Task<string> RPopLPushAsync(string source, string destination) => NodesNotSupportAsync(new[] { source, destination }, null, (c, k) => c.Value.RPopLPushAsync(k.First(), k.Last())); 1818 /// <summary> 1819 /// 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。 1820 /// 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。 1821 /// </summary> 1822 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1823 /// <param name="source">源key，不含prefix前辍</param> 1824 /// <param name="destination">目标key，不含prefix前辍</param> 1825 /// <returns></returns> 1826 async public Task<T> RPopLPushAsync<T>(string source, string destination) => this.DeserializeRedisValueInternal<T>(await NodesNotSupportAsync(new[] { source, destination }, null, (c, k) => c.Value.RPopBytesLPushAsync(k.First(), k.Last()))); 1827 /// <summary> 1828 /// 在列表中添加一个或多个值 1829 /// </summary> 1830 /// <param name="key">不含prefix前辍</param> 1831 /// <param name="value">一个或多个值</param> 1832 /// <returns>执行 RPUSH 命令后，列表的长度</returns> 1833 async public Task<long> RPushAsync<T>(string key, params T[] value) 1834 { 1835 if (value == null || value.Any() == false) return 0; 1836 var args = value.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 1837 return await ExecuteScalarAsync(key, (c, k) => c.Value.RPushAsync(k, args)); 1838 } 1839 /// <summary> 1840 /// 为已存在的列表添加值 1841 /// </summary> 1842 /// <param name="key">不含prefix前辍</param> 1843 /// <param name="value">一个或多个值</param> 1844 /// <returns>执行 RPUSHX 命令后，列表的长度</returns> 1845 public Task<long> RPushXAsync(string key, object value) 1846 { 1847 var args = this.SerializeRedisValueInternal(value); 1848 return ExecuteScalar(key, (c, k) => c.Value.RPushXAsync(k, args)); 1849 } 1850 #endregion 1851 1852 #region Hash 1853 /// <summary> 1854 /// [redis-server 3.2.0] 返回hash指定field的value的字符串长度，如果hash或者field不存在，返回0. 1855 /// </summary> 1856 /// <param name="key">不含prefix前辍</param> 1857 /// <param name="field">字段</param> 1858 /// <returns></returns> 1859 public Task<long> HStrLenAsync(string key, string field) => ExecuteScalarAsync(key, (c, k) => c.Value.HStrLenAsync(k, field)); 1860 /// <summary> 1861 /// 删除一个或多个哈希表字段 1862 /// </summary> 1863 /// <param name="key">不含prefix前辍</param> 1864 /// <param name="fields">字段</param> 1865 /// <returns></returns> 1866 async public Task<long> HDelAsync(string key, params string[] fields) => fields == null || fields.Any() == false ? 0 : 1867 await ExecuteScalarAsync(key, (c, k) => c.Value.HDelAsync(k, fields)); 1868 /// <summary> 1869 /// 查看哈希表 key 中，指定的字段是否存在 1870 /// </summary> 1871 /// <param name="key">不含prefix前辍</param> 1872 /// <param name="field">字段</param> 1873 /// <returns></returns> 1874 public Task<bool> HExistsAsync(string key, string field) => ExecuteScalarAsync(key, (c, k) => c.Value.HExistsAsync(k, field)); 1875 /// <summary> 1876 /// 获取存储在哈希表中指定字段的值 1877 /// </summary> 1878 /// <param name="key">不含prefix前辍</param> 1879 /// <param name="field">字段</param> 1880 /// <returns></returns> 1881 public Task<string> HGetAsync(string key, string field) => ExecuteScalarAsync(key, (c, k) => c.Value.HGetAsync(k, field)); 1882 /// <summary> 1883 /// 获取存储在哈希表中指定字段的值 1884 /// </summary> 1885 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1886 /// <param name="key">不含prefix前辍</param> 1887 /// <param name="field">字段</param> 1888 /// <returns></returns> 1889 async public Task<T> HGetAsync<T>(string key, string field) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.HGetBytesAsync(k, field))); 1890 /// <summary> 1891 /// 获取在哈希表中指定 key 的所有字段和值 1892 /// </summary> 1893 /// <param name="key">不含prefix前辍</param> 1894 /// <returns></returns> 1895 public Task<Dictionary<string, string>> HGetAllAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.HGetAllAsync(k)); 1896 /// <summary> 1897 /// 获取在哈希表中指定 key 的所有字段和值 1898 /// </summary> 1899 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1900 /// <param name="key">不含prefix前辍</param> 1901 /// <returns></returns> 1902 async public Task<Dictionary<string, T>> HGetAllAsync<T>(string key) => this.DeserializeRedisValueDictionaryInternal<string, T>(await ExecuteScalarAsync(key, (c, k) => c.Value.HGetAllBytesAsync(k))); 1903 /// <summary> 1904 /// 为哈希表 key 中的指定字段的整数值加上增量 increment 1905 /// </summary> 1906 /// <param name="key">不含prefix前辍</param> 1907 /// <param name="field">字段</param> 1908 /// <param name="value">增量值(默认=1)</param> 1909 /// <returns></returns> 1910 public Task<long> HIncrByAsync(string key, string field, long value = 1) => ExecuteScalarAsync(key, (c, k) => c.Value.HIncrByAsync(k, field, value)); 1911 /// <summary> 1912 /// 为哈希表 key 中的指定字段的整数值加上增量 increment 1913 /// </summary> 1914 /// <param name="key">不含prefix前辍</param> 1915 /// <param name="field">字段</param> 1916 /// <param name="value">增量值(默认=1)</param> 1917 /// <returns></returns> 1918 public Task<decimal> HIncrByFloatAsync(string key, string field, decimal value) => ExecuteScalarAsync(key, (c, k) => c.Value.HIncrByFloatAsync(k, field, value)); 1919 /// <summary> 1920 /// 获取所有哈希表中的字段 1921 /// </summary> 1922 /// <param name="key">不含prefix前辍</param> 1923 /// <returns></returns> 1924 public Task<string[]> HKeysAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.HKeysAsync(k)); 1925 /// <summary> 1926 /// 获取哈希表中字段的数量 1927 /// </summary> 1928 /// <param name="key">不含prefix前辍</param> 1929 /// <returns></returns> 1930 public Task<long> HLenAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.HLenAsync(k)); 1931 /// <summary> 1932 /// 获取存储在哈希表中多个字段的值 1933 /// </summary> 1934 /// <param name="key">不含prefix前辍</param> 1935 /// <param name="fields">字段</param> 1936 /// <returns></returns> 1937 async public Task<string[]> HMGetAsync(string key, params string[] fields) => fields == null || fields.Any() == false ? new string[0] : 1938 await ExecuteScalarAsync(key, (c, k) => c.Value.HMGetAsync(k, fields)); 1939 /// <summary> 1940 /// 获取存储在哈希表中多个字段的值 1941 /// </summary> 1942 /// <typeparam name="T">byte[] 或其他类型</typeparam> 1943 /// <param name="key">不含prefix前辍</param> 1944 /// <param name="fields">一个或多个字段</param> 1945 /// <returns></returns> 1946 async public Task<T[]> HMGetAsync<T>(string key, params string[] fields) => fields == null || fields.Any() == false ? new T[0] : 1947 this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.HMGetBytesAsync(k, fields))); 1948 /// <summary> 1949 /// 同时将多个 field-value (域-值)对设置到哈希表 key 中 1950 /// </summary> 1951 /// <param name="key">不含prefix前辍</param> 1952 /// <param name="keyValues">key1 value1 [key2 value2]</param> 1953 /// <returns></returns> 1954 async public Task<bool> HMSetAsync(string key, params object[] keyValues) 1955 { 1956 if (keyValues == null || keyValues.Any() == false) return false; 1957 if (keyValues.Length % 2 != 0) throw new Exception("keyValues 参数是键值对，不应该出现奇数(数量)，请检查使用姿势。"); 1958 var parms = new List<object>(); 1959 for (var a = 0; a < keyValues.Length; a += 2) 1960 { 1961 var k = string.Concat(keyValues[a]); 1962 var v = keyValues[a + 1]; 1963 if (string.IsNullOrEmpty(k)) throw new Exception("keyValues 参数是键值对，并且 key 不可为空"); 1964 parms.Add(k); 1965 parms.Add(this.SerializeRedisValueInternal(v)); 1966 } 1967 return await ExecuteScalarAsync(key, (c, k) => c.Value.HMSetAsync(k, parms.ToArray())) == "OK"; 1968 } 1969 1970 async public Task<bool> HMSetAsync(string key, Dictionary<string,string> keyValues) 1971 { 1972 if (keyValues == null || keyValues.Any() == false) return false; 1973 var parms = new List<object>(); 1974 foreach(var item in keyValues) 1975 { 1976 parms.Add(item.Key); 1977 parms.Add(this.SerializeRedisValueInternal(item.Value)); 1978 } 1979 return await ExecuteScalarAsync(key, (c, k) => c.Value.HMSetAsync(k, parms.ToArray())) == "OK"; 1980 } 1981 /// <summary> 1982 /// 将哈希表 key 中的字段 field 的值设为 value 1983 /// </summary> 1984 /// <param name="key">不含prefix前辍</param> 1985 /// <param name="field">字段</param> 1986 /// <param name="value">值</param> 1987 /// <returns>如果字段是哈希表中的一个新建字段，并且值设置成功，返回true。如果哈希表中域字段已经存在且旧值已被新值覆盖，返回false。</returns> 1988 public Task<bool> HSetAsync(string key, string field, object value) 1989 { 1990 var args = this.SerializeRedisValueInternal(value); 1991 return ExecuteScalarAsync(key, (c, k) => c.Value.HSetAsync(k, field, args)); 1992 } 1993 /// <summary> 1994 /// 只有在字段 field 不存在时，设置哈希表字段的值 1995 /// </summary> 1996 /// <param name="key">不含prefix前辍</param> 1997 /// <param name="field">字段</param> 1998 /// <param name="value">值(string 或 byte[])</param> 1999 /// <returns></returns> 2000 public Task<bool> HSetNxAsync(string key, string field, object value) 2001 { 2002 var args = this.SerializeRedisValueInternal(value); 2003 return ExecuteScalarAsync(key, (c, k) => c.Value.HSetNxAsync(k, field, args)); 2004 } 2005 /// <summary> 2006 /// 获取哈希表中所有值 2007 /// </summary> 2008 /// <param name="key">不含prefix前辍</param> 2009 /// <returns></returns> 2010 public Task<string[]> HValsAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.HValsAsync(k)); 2011 /// <summary> 2012 /// 获取哈希表中所有值 2013 /// </summary> 2014 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2015 /// <param name="key">不含prefix前辍</param> 2016 /// <returns></returns> 2017 async public Task<T[]> HValsAsync<T>(string key) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.HValsBytesAsync(k))); 2018 /// <summary> 2019 /// 迭代哈希表中的键值对 2020 /// </summary> 2021 /// <param name="key">不含prefix前辍</param> 2022 /// <param name="cursor">位置</param> 2023 /// <param name="pattern">模式</param> 2024 /// <param name="count">数量</param> 2025 /// <returns></returns> 2026 async public Task<RedisScan<(string field, string value)>> HScanAsync(string key, long cursor, string pattern = null, long? count = null) 2027 { 2028 var scan = await ExecuteScalarAsync(key, (c, k) => c.Value.HScanAsync(k, cursor, pattern, count)); 2029 return new RedisScan<(string, string)>(scan.Cursor, scan.Items.Select(z => (z.Item1, z.Item2)).ToArray()); 2030 } 2031 /// <summary> 2032 /// 迭代哈希表中的键值对 2033 /// </summary> 2034 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2035 /// <param name="key">不含prefix前辍</param> 2036 /// <param name="cursor">位置</param> 2037 /// <param name="pattern">模式</param> 2038 /// <param name="count">数量</param> 2039 /// <returns></returns> 2040 async public Task<RedisScan<(string field, T value)>> HScanAsync<T>(string key, long cursor, string pattern = null, long? count = null) 2041 { 2042 var scan = await ExecuteScalarAsync(key, (c, k) => c.Value.HScanBytesAsync(k, cursor, pattern, count)); 2043 return new RedisScan<(string, T)>(scan.Cursor, scan.Items.Select(z => (z.Item1, this.DeserializeRedisValueInternal<T>(z.Item2))).ToArray()); 2044 } 2045 #endregion 2046 2047 #region String 2048 /// <summary> 2049 /// 如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾 2050 /// </summary> 2051 /// <param name="key">不含prefix前辍</param> 2052 /// <param name="value">字符串</param> 2053 /// <returns>追加指定值之后， key 中字符串的长度</returns> 2054 public Task<long> AppendAsync(string key, object value) 2055 { 2056 var args = this.SerializeRedisValueInternal(value); 2057 return ExecuteScalarAsync(key, (c, k) => c.Value.AppendAsync(k, args)); 2058 } 2059 /// <summary> 2060 /// 计算给定位置被设置为 1 的比特位的数量 2061 /// </summary> 2062 /// <param name="key">不含prefix前辍</param> 2063 /// <param name="start">开始位置</param> 2064 /// <param name="end">结束位置</param> 2065 /// <returns></returns> 2066 public Task<long> BitCountAsync(string key, long start, long end) => ExecuteScalarAsync(key, (c, k) => c.Value.BitCountAsync(k, start, end)); 2067 /// <summary> 2068 /// 对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上 2069 /// </summary> 2070 /// <param name="op">And | Or | XOr | Not</param> 2071 /// <param name="destKey">不含prefix前辍</param> 2072 /// <param name="keys">不含prefix前辍</param> 2073 /// <returns>保存到 destkey 的长度，和输入 key 中最长的长度相等</returns> 2074 async public Task<long> BitOpAsync(RedisBitOp op, string destKey, params string[] keys) 2075 { 2076 if (string.IsNullOrEmpty(destKey)) throw new Exception("destKey 不能为空"); 2077 if (keys == null || keys.Length == 0) throw new Exception("keys 不能为空"); 2078 return await NodesNotSupportAsync(new[] { destKey }.Concat(keys).ToArray(), 0, (c, k) => c.Value.BitOpAsync(op, k.First(), k.Skip(1).ToArray())); 2079 } 2080 /// <summary> 2081 /// 对 key 所储存的值，查找范围内第一个被设置为1或者0的bit位 2082 /// </summary> 2083 /// <param name="key">不含prefix前辍</param> 2084 /// <param name="bit">查找值</param> 2085 /// <param name="start">开始位置，-1是最后一个，-2是倒数第二个</param> 2086 /// <param name="end">结果位置，-1是最后一个，-2是倒数第二个</param> 2087 /// <returns>返回范围内第一个被设置为1或者0的bit位</returns> 2088 public Task<long> BitPosAsync(string key, bool bit, long? start = null, long? end = null) => ExecuteScalarAsync(key, (c, k) => c.Value.BitPosAsync(k, bit, start, end)); 2089 /// <summary> 2090 /// 获取指定 key 的值 2091 /// </summary> 2092 /// <param name="key">不含prefix前辍</param> 2093 /// <returns></returns> 2094 public Task<string> GetAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.GetAsync(k)); 2095 /// <summary> 2096 /// 获取指定 key 的值 2097 /// </summary> 2098 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2099 /// <param name="key">不含prefix前辍</param> 2100 /// <returns></returns> 2101 async public Task<T> GetAsync<T>(string key) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.GetBytesAsync(k))); 2102 /// <summary> 2103 /// 对 key 所储存的值，获取指定偏移量上的位(bit) 2104 /// </summary> 2105 /// <param name="key">不含prefix前辍</param> 2106 /// <param name="offset">偏移量</param> 2107 /// <returns></returns> 2108 public Task<bool> GetBitAsync(string key, uint offset) => ExecuteScalarAsync(key, (c, k) => c.Value.GetBitAsync(k, offset)); 2109 /// <summary> 2110 /// 返回 key 中字符串值的子字符 2111 /// </summary> 2112 /// <param name="key">不含prefix前辍</param> 2113 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 2114 /// <param name="end">结束位置，0表示第一个元素，-1表示最后一个元素</param> 2115 /// <returns></returns> 2116 public Task<string> GetRangeAsync(string key, long start, long end) => ExecuteScalarAsync(key, (c, k) => c.Value.GetRangeAsync(k, start, end)); 2117 /// <summary> 2118 /// 返回 key 中字符串值的子字符 2119 /// </summary> 2120 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2121 /// <param name="key">不含prefix前辍</param> 2122 /// <param name="start">开始位置，0表示第一个元素，-1表示最后一个元素</param> 2123 /// <param name="end">结束位置，0表示第一个元素，-1表示最后一个元素</param> 2124 /// <returns></returns> 2125 async public Task<T> GetRangeAsync<T>(string key, long start, long end) => this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.GetRangeBytesAsync(k, start, end))); 2126 /// <summary> 2127 /// 将给定 key 的值设为 value ，并返回 key 的旧值(old value) 2128 /// </summary> 2129 /// <param name="key">不含prefix前辍</param> 2130 /// <param name="value">值</param> 2131 /// <returns></returns> 2132 public Task<string> GetSetAsync(string key, object value) 2133 { 2134 var args = this.SerializeRedisValueInternal(value); 2135 return ExecuteScalarAsync(key, (c, k) => c.Value.GetSetAsync(k, args)); 2136 } 2137 /// <summary> 2138 /// 将给定 key 的值设为 value ，并返回 key 的旧值(old value) 2139 /// </summary> 2140 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2141 /// <param name="key">不含prefix前辍</param> 2142 /// <param name="value">值</param> 2143 /// <returns></returns> 2144 async public Task<T> GetSetAsync<T>(string key, object value) 2145 { 2146 var args = this.SerializeRedisValueInternal(value); 2147 return this.DeserializeRedisValueInternal<T>(await ExecuteScalarAsync(key, (c, k) => c.Value.GetSetBytesAsync(k, args))); 2148 } 2149 /// <summary> 2150 /// 将 key 所储存的值加上给定的增量值（increment） 2151 /// </summary> 2152 /// <param name="key">不含prefix前辍</param> 2153 /// <param name="value">增量值(默认=1)</param> 2154 /// <returns></returns> 2155 public Task<long> IncrByAsync(string key, long value = 1) => ExecuteScalarAsync(key, (c, k) => c.Value.IncrByAsync(k, value)); 2156 /// <summary> 2157 /// 将 key 所储存的值加上给定的浮点增量值（increment） 2158 /// </summary> 2159 /// <param name="key">不含prefix前辍</param> 2160 /// <param name="value">增量值(默认=1)</param> 2161 /// <returns></returns> 2162 public Task<decimal> IncrByFloatAsync(string key, decimal value) => ExecuteScalarAsync(key, (c, k) => c.Value.IncrByFloatAsync(k, value)); 2163 /// <summary> 2164 /// 将 key 中储存的数字值减一。 2165 /// </summary> 2166 /// <param name="key">不含prefix前辍</param> 2167 /// <returns></returns> 2168 public long Decr(string key) => ExecuteScalar(key, (c, k) => c.Value.Decr(key)); 2169 /// <summary> 2170 /// 将 key 中储存的数字值减一。 2171 /// </summary> 2172 /// <param name="key">不含prefix前辍</param> 2173 /// <returns></returns> 2174 public Task<long> DecrAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.DecrAsync(key)); 2175 /// <summary> 2176 /// key 所储存的值减去给定的减量值（decrement） 。 2177 /// </summary> 2178 /// <param name="key">不含prefix前辍</param> 2179 /// <param name="value">增量值(默认=1)</param> 2180 /// <returns></returns> 2181 public long DecrBy(string key, long value = 1) => ExecuteScalar(key, (c, k) => c.Value.DecrBy(k, value)); 2182 /// <summary> 2183 /// key 所储存的值减去给定的减量值（decrement） 。 2184 /// </summary> 2185 /// <param name="key">不含prefix前辍</param> 2186 /// <param name="value">增量值(默认=1)</param> 2187 /// <returns></returns> 2188 public Task<long> DecrByAsync(string key, long value = 1) => ExecuteScalarAsync(key, (c, k) => c.Value.DecrByAsync(k, value)); 2189 /// <summary> 2190 /// 获取多个指定 key 的值(数组) 2191 /// </summary> 2192 /// <param name="keys">不含prefix前辍</param> 2193 /// <returns></returns> 2194 public Task<string[]> MGetAsync(params string[] keys) => ExecuteArrayAsync(keys, (c, k) => c.Value.MGetAsync(k)); 2195 /// <summary> 2196 /// 获取多个指定 key 的值(数组) 2197 /// </summary> 2198 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2199 /// <param name="keys">不含prefix前辍</param> 2200 /// <returns></returns> 2201 async public Task<T[]> MGetAsync<T>(params string[] keys) => this.DeserializeRedisValueArrayInternal<T>(await ExecuteArrayAsync(keys, (c, k) => c.Value.MGetBytesAsync(k))); 2202 /// <summary> 2203 /// 同时设置一个或多个 key-value 对 2204 /// </summary> 2205 /// <param name="keyValues">key1 value1 [key2 value2]</param> 2206 /// <returns></returns> 2207 public Task<bool> MSetAsync(params object[] keyValues) => MSetInternalAsync(RedisExistence.Xx, keyValues); 2208 /// <summary> 2209 /// 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在 2210 /// </summary> 2211 /// <param name="keyValues">key1 value1 [key2 value2]</param> 2212 /// <returns></returns> 2213 public Task<bool> MSetNxAsync(params object[] keyValues) => MSetInternalAsync(RedisExistence.Nx, keyValues); 2214 async internal Task<bool> MSetInternalAsync(RedisExistence exists, params object[] keyValues) 2215 { 2216 if (keyValues == null || keyValues.Any() == false) return false; 2217 if (keyValues.Length % 2 != 0) throw new Exception("keyValues 参数是键值对，不应该出现奇数(数量)，请检查使用姿势。"); 2218 var dic = new Dictionary<string, object>(); 2219 for (var a = 0; a < keyValues.Length; a += 2) 2220 { 2221 var k = string.Concat(keyValues[a]); 2222 var v = this.SerializeRedisValueInternal(keyValues[a + 1]); 2223 if (string.IsNullOrEmpty(k)) throw new Exception("keyValues 参数是键值对，并且 key 不可为空"); 2224 if (dic.ContainsKey(k)) dic[k] = v; 2225 else dic.Add(k, v); 2226 } 2227 Func<Object<RedisClient>, string[], Task<long>> handle = async (c, k) => 2228 { 2229 var prefix = (c.Pool as RedisClientPool)?.Prefix; 2230 var parms = new object[k.Length * 2]; 2231 for (var a = 0; a < k.Length; a++) 2232 { 2233 parms[a * 2] = k[a]; 2234 parms[a * 2 + 1] = dic[string.IsNullOrEmpty(prefix) ? k[a] : k[a].Substring(prefix.Length)]; 2235 } 2236 if (exists == RedisExistence.Nx) return await c.Value.MSetNxAsync(parms) ? 1 : 0; 2237 return await c.Value.MSetAsync(parms) == "OK" ? 1 : 0; 2238 }; 2239 if (exists == RedisExistence.Nx) return await NodesNotSupportAsync(dic.Keys.ToArray(), 0, handle) > 0; 2240 return await ExecuteNonQueryAsync(dic.Keys.ToArray(), handle) > 0; 2241 } 2242 /// <summary> 2243 /// 设置指定 key 的值，所有写入参数object都支持string | byte[] | 数值 | 对象 2244 /// </summary> 2245 /// <param name="key">不含prefix前辍</param> 2246 /// <param name="value">值</param> 2247 /// <param name="expireSeconds">过期(秒单位)</param> 2248 /// <param name="exists">Nx, Xx</param> 2249 /// <returns></returns> 2250 async public Task<bool> SetAsync(string key, object value, int expireSeconds = -1, RedisExistence? exists = null) 2251 { 2252 object redisValule = this.SerializeRedisValueInternal(value); 2253 if (expireSeconds <= 0 && exists == null) return await ExecuteScalarAsync(key, (c, k) => c.Value.SetAsync(k, redisValule)) == "OK"; 2254 if (expireSeconds <= 0 && exists != null) return await ExecuteScalarAsync(key, (c, k) => c.Value.SetAsync(k, redisValule, null, exists)) == "OK"; 2255 if (expireSeconds > 0 && exists == null) return await ExecuteScalarAsync(key, (c, k) => c.Value.SetAsync(k, redisValule, expireSeconds, null)) == "OK"; 2256 if (expireSeconds > 0 && exists != null) return await ExecuteScalarAsync(key, (c, k) => c.Value.SetAsync(k, redisValule, expireSeconds, exists)) == "OK"; 2257 return false; 2258 } 2259 async public Task<bool> SetAsync(string key, object value, TimeSpan expire, RedisExistence? exists = null) 2260 { 2261 object redisValule = this.SerializeRedisValueInternal(value); 2262 if (expire <= TimeSpan.Zero && exists == null) return await ExecuteScalar(key, (c, k) => c.Value.SetAsync(k, redisValule)) == "OK"; 2263 if (expire <= TimeSpan.Zero && exists != null) return await ExecuteScalar(key, (c, k) => c.Value.SetAsync(k, redisValule, null, exists)) == "OK"; 2264 if (expire > TimeSpan.Zero && exists == null) return await ExecuteScalar(key, (c, k) => c.Value.SetAsync(k, redisValule, expire, null)) == "OK"; 2265 if (expire > TimeSpan.Zero && exists != null) return await ExecuteScalar(key, (c, k) => c.Value.SetAsync(k, redisValule, expire, exists)) == "OK"; 2266 return false; 2267 } 2268 /// <summary> 2269 /// 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit) 2270 /// </summary> 2271 /// <param name="key">不含prefix前辍</param> 2272 /// <param name="offset">偏移量</param> 2273 /// <param name="value">值</param> 2274 /// <returns></returns> 2275 public Task<bool> SetBitAsync(string key, uint offset, bool value) => ExecuteScalarAsync(key, (c, k) => c.Value.SetBitAsync(k, offset, value)); 2276 /// <summary> 2277 /// 只有在 key 不存在时设置 key 的值 2278 /// </summary> 2279 /// <param name="key">不含prefix前辍</param> 2280 /// <param name="value">值</param> 2281 /// <returns></returns> 2282 public Task<bool> SetNxAsync(string key, object value) 2283 { 2284 var args = this.SerializeRedisValueInternal(value); 2285 return ExecuteScalarAsync(key, (c, k) => c.Value.SetNxAsync(k, args)); 2286 } 2287 /// <summary> 2288 /// 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始 2289 /// </summary> 2290 /// <param name="key">不含prefix前辍</param> 2291 /// <param name="offset">偏移量</param> 2292 /// <param name="value">值</param> 2293 /// <returns>被修改后的字符串长度</returns> 2294 public Task<long> SetRangeAsync(string key, uint offset, object value) 2295 { 2296 var args = this.SerializeRedisValueInternal(value); 2297 return ExecuteScalarAsync(key, (c, k) => c.Value.SetRangeAsync(k, offset, args)); 2298 } 2299 /// <summary> 2300 /// 返回 key 所储存的字符串值的长度 2301 /// </summary> 2302 /// <param name="key">不含prefix前辍</param> 2303 /// <returns></returns> 2304 public Task<long> StrLenAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.StrLenAsync(k)); 2305 #endregion 2306 2307 #region Key 2308 /// <summary> 2309 /// [redis-server 3.2.1] 修改指定key(s) 最后访问时间 若key不存在，不做操作 2310 /// </summary> 2311 /// <param name="key">不含prefix前辍</param> 2312 /// <returns></returns> 2313 public Task<long> TouchAsync(params string[] key) => ExecuteNonQueryAsync(key, (c, k) => c.Value.TouchAsync(k)); 2314 /// <summary> 2315 /// [redis-server 4.0.0] Delete a key, 该命令和DEL十分相似：删除指定的key(s),若key不存在则该key被跳过。但是，相比DEL会产生阻塞，该命令会在另一个线程中回收内存，因此它是非阻塞的。 这也是该命令名字的由来：仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。 2316 /// </summary> 2317 /// <param name="key">不含prefix前辍</param> 2318 /// <returns></returns> 2319 public Task<long> UnLinkAsync(params string[] key) => ExecuteNonQueryAsync(key, (c, k) => c.Value.UnLinkAsync(k)); 2320 /// <summary> 2321 /// 用于在 key 存在时删除 key 2322 /// </summary> 2323 /// <param name="key">不含prefix前辍</param> 2324 /// <returns></returns> 2325 public Task<long> DelAsync(params string[] key) => ExecuteNonQueryAsync(key, (c, k) => c.Value.DelAsync(k)); 2326 /// <summary> 2327 /// 序列化给定 key ，并返回被序列化的值 2328 /// </summary> 2329 /// <param name="key">不含prefix前辍</param> 2330 /// <returns></returns> 2331 public Task<byte[]> DumpAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.DumpAsync(k)); 2332 /// <summary> 2333 /// 检查给定 key 是否存在 2334 /// </summary> 2335 /// <param name="key">不含prefix前辍</param> 2336 /// <returns></returns> 2337 public Task<bool> ExistsAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.ExistsAsync(k)); 2338 /// <summary> 2339 /// [redis-server 3.0] 检查给定多个 key 是否存在 2340 /// </summary> 2341 /// <param name="keys">不含prefix前辍</param> 2342 /// <returns></returns> 2343 public Task<long> ExistsAsync(string[] keys) => NodesNotSupportAsync(keys, 0, (c, k) => c.Value.ExistsAsync(k)); 2344 /// <summary> 2345 /// 为给定 key 设置过期时间 2346 /// </summary> 2347 /// <param name="key">不含prefix前辍</param> 2348 /// <param name="seconds">过期秒数</param> 2349 /// <returns></returns> 2350 public Task<bool> ExpireAsync(string key, int seconds) => ExecuteScalarAsync(key, (c, k) => c.Value.ExpireAsync(k, seconds)); 2351 /// <summary> 2352 /// 为给定 key 设置过期时间 2353 /// </summary> 2354 /// <param name="key">不含prefix前辍</param> 2355 /// <param name="expire">过期时间</param> 2356 /// <returns></returns> 2357 public Task<bool> ExpireAsync(string key, TimeSpan expire) => ExecuteScalarAsync(key, (c, k) => c.Value.ExpireAsync(k, expire)); 2358 /// <summary> 2359 /// 为给定 key 设置过期时间 2360 /// </summary> 2361 /// <param name="key">不含prefix前辍</param> 2362 /// <param name="expire">过期时间</param> 2363 /// <returns></returns> 2364 public Task<bool> ExpireAtAsync(string key, DateTime expire) => ExecuteScalarAsync(key, (c, k) => c.Value.ExpireAtAsync(k, expire)); 2365 /// <summary> 2366 /// 查找所有分区节点中符合给定模式(pattern)的 key 2367 /// </summary> 2368 /// <param name="pattern">如：runoob*</param> 2369 /// <returns></returns> 2370 async public Task<string[]> KeysAsync(string pattern) 2371 { 2372 List<string> ret = new List<string>(); 2373 foreach (var pool in Nodes) 2374 ret.AddRange(await GetAndExecuteAsync(pool.Value, conn => conn.Value.KeysAsync(pattern))); 2375 return ret.ToArray(); 2376 } 2377 /// <summary> 2378 /// 将当前数据库的 key 移动到给定的数据库 db 当中 2379 /// </summary> 2380 /// <param name="key">不含prefix前辍</param> 2381 /// <param name="database">数据库</param> 2382 /// <returns></returns> 2383 public Task<bool> MoveAsync(string key, int database) => ExecuteScalarAsync(key, (c, k) => c.Value.MoveAsync(k, database)); 2384 /// <summary> 2385 /// 该返回给定 key 锁储存的值所使用的内部表示(representation) 2386 /// </summary> 2387 /// <param name="key">不含prefix前辍</param> 2388 /// <returns></returns> 2389 public Task<string> ObjectEncodingAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.ObjectEncodingAsync(k)); 2390 /// <summary> 2391 /// 该返回给定 key 引用所储存的值的次数。此命令主要用于除错 2392 /// </summary> 2393 /// <param name="key">不含prefix前辍</param> 2394 /// <returns></returns> 2395 public Task<long?> ObjectRefCountAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.ObjectAsync(RedisObjectSubCommand.RefCount, k)); 2396 /// <summary> 2397 /// 返回给定 key 自储存以来的空转时间(idle， 没有被读取也没有被写入)，以秒为单位 2398 /// </summary> 2399 /// <param name="key">不含prefix前辍</param> 2400 /// <returns></returns> 2401 public Task<long?> ObjectIdleTimeAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.ObjectAsync(RedisObjectSubCommand.IdleTime, k)); 2402 /// <summary> 2403 /// 移除 key 的过期时间，key 将持久保持 2404 /// </summary> 2405 /// <param name="key">不含prefix前辍</param> 2406 /// <returns></returns> 2407 public Task<bool> PersistAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.PersistAsync(k)); 2408 /// <summary> 2409 /// 为给定 key 设置过期时间（毫秒） 2410 /// </summary> 2411 /// <param name="key">不含prefix前辍</param> 2412 /// <param name="milliseconds">过期毫秒数</param> 2413 /// <returns></returns> 2414 public Task<bool> PExpireAsync(string key, int milliseconds) => ExecuteScalarAsync(key, (c, k) => c.Value.PExpireAsync(k, milliseconds)); 2415 /// <summary> 2416 /// 为给定 key 设置过期时间（毫秒） 2417 /// </summary> 2418 /// <param name="key">不含prefix前辍</param> 2419 /// <param name="expire">过期时间</param> 2420 /// <returns></returns> 2421 public Task<bool> PExpireAsync(string key, TimeSpan expire) => ExecuteScalarAsync(key, (c, k) => c.Value.PExpireAsync(k, expire)); 2422 /// <summary> 2423 /// 为给定 key 设置过期时间（毫秒） 2424 /// </summary> 2425 /// <param name="key">不含prefix前辍</param> 2426 /// <param name="expire">过期时间</param> 2427 /// <returns></returns> 2428 public Task<bool> PExpireAtAsync(string key, DateTime expire) => ExecuteScalarAsync(key, (c, k) => c.Value.PExpireAtAsync(k, expire)); 2429 /// <summary> 2430 /// 以毫秒为单位返回 key 的剩余的过期时间 2431 /// </summary> 2432 /// <param name="key">不含prefix前辍</param> 2433 /// <returns></returns> 2434 public Task<long> PTtlAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.PTtlAsync(k)); 2435 /// <summary> 2436 /// 从所有节点中随机返回一个 key 2437 /// </summary> 2438 /// <returns>返回的 key 如果包含 prefix前辍，则会去除后返回</returns> 2439 public Task<string> RandomKeyAsync() => GetAndExecuteAsync(Nodes[NodesIndex[_rnd.Next(0, NodesIndex.Count)]], async c => 2440 { 2441 var rk = await c.Value.RandomKeyAsync(); 2442 var prefix = (c.Pool as RedisClientPool).Prefix; 2443 if (string.IsNullOrEmpty(prefix) == false && rk.StartsWith(prefix)) return rk.Substring(prefix.Length); 2444 return rk; 2445 }); 2446 /// <summary> 2447 /// 修改 key 的名称 2448 /// </summary> 2449 /// <param name="key">旧名称，不含prefix前辍</param> 2450 /// <param name="newKey">新名称，不含prefix前辍</param> 2451 /// <returns></returns> 2452 async public Task<bool> RenameAsync(string key, string newKey) 2453 { 2454 string rule = string.Empty; 2455 if (Nodes.Count > 1) 2456 { 2457 var rule1 = NodeRuleRaw(key); 2458 var rule2 = NodeRuleRaw(newKey); 2459 if (rule1 != rule2) 2460 { 2461 var ret = StartPipe(a => a.Dump(key).Del(key)); 2462 int.TryParse(ret[1]?.ToString(), out var tryint); 2463 if (ret[0] == null || tryint <= 0) return false; 2464 return await RestoreAsync(newKey, (byte[])ret[0]); 2465 } 2466 rule = rule1; 2467 } 2468 var pool = Nodes.TryGetValue(rule, out var b) ? b : Nodes.First().Value; 2469 var key1 = string.Concat(pool.Prefix, key); 2470 var key2 = string.Concat(pool.Prefix, newKey); 2471 return await GetAndExecuteAsync(pool, conn => conn.Value.RenameAsync(key1, key2)) == "OK"; 2472 } 2473 /// <summary> 2474 /// 修改 key 的名称 2475 /// </summary> 2476 /// <param name="key">旧名称，不含prefix前辍</param> 2477 /// <param name="newKey">新名称，不含prefix前辍</param> 2478 /// <returns></returns> 2479 public Task<bool> RenameNxAsync(string key, string newKey) => NodesNotSupportAsync(new[] { key, newKey }, false, (c, k) => c.Value.RenameNxAsync(k.First(), k.Last())); 2480 /// <summary> 2481 /// 反序列化给定的序列化值，并将它和给定的 key 关联 2482 /// </summary> 2483 /// <param name="key">不含prefix前辍</param> 2484 /// <param name="serializedValue">序列化值</param> 2485 /// <returns></returns> 2486 public Task<bool> RestoreAsync(string key, byte[] serializedValue) => ExecuteScalarAsync(key, async (c, k) => await c.Value.RestoreAsync(k, 0, serializedValue) == "OK"); 2487 /// <summary> 2488 /// 反序列化给定的序列化值，并将它和给定的 key 关联 2489 /// </summary> 2490 /// <param name="key">不含prefix前辍</param> 2491 /// <param name="ttlMilliseconds">毫秒为单位为 key 设置生存时间</param> 2492 /// <param name="serializedValue">序列化值</param> 2493 /// <returns></returns> 2494 public Task<bool> RestoreAsync(string key, long ttlMilliseconds, byte[] serializedValue) => ExecuteScalarAsync(key, async (c, k) => await c.Value.RestoreAsync(k, ttlMilliseconds, serializedValue) == "OK"); 2495 /// <summary> 2496 /// 返回给定列表、集合、有序集合 key 中经过排序的元素，参数资料：http://doc.redisfans.com/key/sort.html 2497 /// </summary> 2498 /// <param name="key">列表、集合、有序集合，不含prefix前辍</param> 2499 /// <param name="offset">偏移量</param> 2500 /// <param name="count">数量</param> 2501 /// <param name="by">排序字段</param> 2502 /// <param name="dir">排序方式</param> 2503 /// <param name="isAlpha">对字符串或数字进行排序</param> 2504 /// <param name="get">根据排序的结果来取出相应的键值</param> 2505 /// <returns></returns> 2506 public Task<string[]> SortAsync(string key, long? count = null, long offset = 0, string by = null, RedisSortDir? dir = null, bool? isAlpha = null, params string[] get) => 2507 NodesNotSupportAsync(key, (c, k) => c.Value.SortAsync(k, offset, count, by, dir, isAlpha, get)); 2508 /// <summary> 2509 /// 保存给定列表、集合、有序集合 key 中经过排序的元素，参数资料：http://doc.redisfans.com/key/sort.html 2510 /// </summary> 2511 /// <param name="key">列表、集合、有序集合，不含prefix前辍</param> 2512 /// <param name="destination">目标key，不含prefix前辍</param> 2513 /// <param name="offset">偏移量</param> 2514 /// <param name="count">数量</param> 2515 /// <param name="by">排序字段</param> 2516 /// <param name="dir">排序方式</param> 2517 /// <param name="isAlpha">对字符串或数字进行排序</param> 2518 /// <param name="get">根据排序的结果来取出相应的键值</param> 2519 /// <returns></returns> 2520 public Task<long> SortAndStoreAsync(string key, string destination, long? count = null, long offset = 0, string by = null, RedisSortDir? dir = null, bool? isAlpha = null, params string[] get) => 2521 NodesNotSupportAsync(key, (c, k) => c.Value.SortAndStoreAsync(k, (c.Pool as RedisClientPool)?.Prefix + destination, offset, count, by, dir, isAlpha, get)); 2522 /// <summary> 2523 /// 以秒为单位，返回给定 key 的剩余生存时间 2524 /// </summary> 2525 /// <param name="key">不含prefix前辍</param> 2526 /// <returns></returns> 2527 public Task<long> TtlAsync(string key) => ExecuteScalarAsync(key, (c, k) => c.Value.TtlAsync(k)); 2528 /// <summary> 2529 /// 返回 key 所储存的值的类型 2530 /// </summary> 2531 /// <param name="key">不含prefix前辍</param> 2532 /// <returns></returns> 2533 async public Task<KeyType> TypeAsync(string key) => Enum.TryParse(await ExecuteScalarAsync(key, (c, k) => c.Value.TypeAsync(k)), true, out KeyType tryenum) ? tryenum : KeyType.None; 2534 /// <summary> 2535 /// 迭代当前数据库中的数据库键 2536 /// </summary> 2537 /// <param name="cursor">位置</param> 2538 /// <param name="pattern">模式</param> 2539 /// <param name="count">数量</param> 2540 /// <returns></returns> 2541 public Task<RedisScan<string>> ScanAsync(long cursor, string pattern = null, long? count = null) => NodesNotSupportAsync("ScanAsync", (c, k) => c.Value.ScanAsync(cursor, pattern, count)); 2542 /// <summary> 2543 /// 迭代当前数据库中的数据库键 2544 /// </summary> 2545 /// <typeparam name="T">byte[] 或其他类型</typeparam> 2546 /// <param name="cursor">位置</param> 2547 /// <param name="pattern">模式</param> 2548 /// <param name="count">数量</param> 2549 /// <returns></returns> 2550 async public Task<RedisScan<T>> ScanAsync<T>(long cursor, string pattern = null, long? count = null) 2551 { 2552 var scan = await NodesNotSupportAsync("ScanAsync<T>", (c, k) => c.Value.ScanBytesAsync(cursor, pattern, count)); 2553 return new RedisScan<T>(scan.Cursor, this.DeserializeRedisValueArrayInternal<T>(scan.Items)); 2554 } 2555 #endregion 2556 2557 #region Geo redis-server 3.2 2558 /// <summary> 2559 /// 将指定的地理空间位置（纬度、经度、成员）添加到指定的key中。这些数据将会存储到sorted set这样的目的是为了方便使用GEORADIUS或者GEORADIUSBYMEMBER命令对数据进行半径查询等操作。 2560 /// </summary> 2561 /// <param name="key">不含prefix前辍</param> 2562 /// <param name="longitude">经度</param> 2563 /// <param name="latitude">纬度</param> 2564 /// <param name="member">成员</param> 2565 /// <returns>是否成功</returns> 2566 async public Task<bool> GeoAddAsync(string key, decimal longitude, decimal latitude, object member) => await GeoAddAsync(key, (longitude, latitude, member)) == 1; 2567 /// <summary> 2568 /// 将指定的地理空间位置（纬度、经度、成员）添加到指定的key中。这些数据将会存储到sorted set这样的目的是为了方便使用GEORADIUS或者GEORADIUSBYMEMBER命令对数据进行半径查询等操作。 2569 /// </summary> 2570 /// <param name="key">不含prefix前辍</param> 2571 /// <param name="values">批量添加的值</param> 2572 /// <returns>添加到sorted set元素的数目，但不包括已更新score的元素。</returns> 2573 async public Task<long> GeoAddAsync(string key, params (decimal longitude, decimal latitude, object member)[] values) 2574 { 2575 if (values == null || values.Any() == false) return 0; 2576 var args = values.Select(z => (z.longitude, z.latitude, this.SerializeRedisValueInternal(z.member))).ToArray(); 2577 return await ExecuteScalarAsync(key, (c, k) => c.Value.GeoAddAsync(k, args)); 2578 } 2579 /// <summary> 2580 /// 返回两个给定位置之间的距离。如果两个位置之间的其中一个不存在， 那么命令返回空值。GEODIST 命令在计算距离时会假设地球为完美的球形， 在极限情况下， 这一假设最大会造成 0.5% 的误差。 2581 /// </summary> 2582 /// <param name="key">不含prefix前辍</param> 2583 /// <param name="member1">成员1</param> 2584 /// <param name="member2">成员2</param> 2585 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2586 /// <returns>计算出的距离会以双精度浮点数的形式被返回。 如果给定的位置元素不存在， 那么命令返回空值。</returns> 2587 public Task<decimal?> GeoDistAsync(string key, object member1, object member2, GeoUnit unit = GeoUnit.m) 2588 { 2589 var args1 = this.SerializeRedisValueInternal(member1); 2590 var args2 = this.SerializeRedisValueInternal(member2); 2591 return ExecuteScalarAsync(key, (c, k) => c.Value.GeoDistAsync(k, args1, args2, unit)); 2592 } 2593 /// <summary> 2594 /// 返回一个或多个位置元素的 Geohash 表示。通常使用表示位置的元素使用不同的技术，使用Geohash位置52点整数编码。由于编码和解码过程中所使用的初始最小和最大坐标不同，编码的编码也不同于标准。 2595 /// </summary> 2596 /// <param name="key">不含prefix前辍</param> 2597 /// <param name="members">多个查询的成员</param> 2598 /// <returns>一个数组， 数组的每个项都是一个 geohash 。 命令返回的 geohash 的位置与用户给定的位置元素的位置一一对应。</returns> 2599 async public Task<string[]> GeoHashAsync(string key, object[] members) 2600 { 2601 if (members == null || members.Any() == false) return new string[0]; 2602 var args = members.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 2603 return await ExecuteScalarAsync(key, (c, k) => c.Value.GeoHashAsync(k, args)); 2604 } 2605 /// <summary> 2606 /// 从key里返回所有给定位置元素的位置（经度和纬度）。 2607 /// </summary> 2608 /// <param name="key">不含prefix前辍</param> 2609 /// <param name="members">多个查询的成员</param> 2610 /// <returns>GEOPOS 命令返回一个数组， 数组中的每个项都由两个元素组成： 第一个元素为给定位置元素的经度， 而第二个元素则为给定位置元素的纬度。当给定的位置元素不存在时， 对应的数组项为空值。</returns> 2611 async public Task<(decimal longitude, decimal latitude)?[]> GeoPosAsync(string key, object[] members) 2612 { 2613 if (members == null || members.Any() == false) return new (decimal, decimal)?[0]; 2614 var args = members.Select(z => this.SerializeRedisValueInternal(z)).ToArray(); 2615 return await ExecuteScalarAsync(key, (c, k) => c.Value.GeoPosAsync(k, args)); 2616 } 2617 2618 /// <summary> 2619 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。 2620 /// </summary> 2621 /// <param name="key">不含prefix前辍</param> 2622 /// <param name="longitude">经度</param> 2623 /// <param name="latitude">纬度</param> 2624 /// <param name="radius">距离</param> 2625 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2626 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2627 /// <param name="sorting">排序</param> 2628 /// <returns></returns> 2629 async public Task<string[]> GeoRadiusAsync(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2630 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusAsync(k, longitude, latitude, radius, unit, count, sorting, false, false, false))).Select(a => a.member).ToArray(); 2631 /// <summary> 2632 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。 2633 /// </summary> 2634 /// <param name="key">不含prefix前辍</param> 2635 /// <param name="longitude">经度</param> 2636 /// <param name="latitude">纬度</param> 2637 /// <param name="radius">距离</param> 2638 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2639 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2640 /// <param name="sorting">排序</param> 2641 /// <returns></returns> 2642 async public Task<T[]> GeoRadiusAsync<T>(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2643 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesAsync(k, longitude, latitude, radius, unit, count, sorting, false, false, false))).Select(a => this.DeserializeRedisValueInternal<T>(a.member)).ToArray(); 2644 2645 /// <summary> 2646 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离）。 2647 /// </summary> 2648 /// <param name="key">不含prefix前辍</param> 2649 /// <param name="longitude">经度</param> 2650 /// <param name="latitude">纬度</param> 2651 /// <param name="radius">距离</param> 2652 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2653 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2654 /// <param name="sorting">排序</param> 2655 /// <returns></returns> 2656 async public Task<(string member, decimal dist)[]> GeoRadiusWithDistAsync(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2657 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusAsync(k, longitude, latitude, radius, unit, count, sorting, false, true, false))).Select(a => (a.member, a.dist)).ToArray(); 2658 /// <summary> 2659 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离）。 2660 /// </summary> 2661 /// <param name="key">不含prefix前辍</param> 2662 /// <param name="longitude">经度</param> 2663 /// <param name="latitude">纬度</param> 2664 /// <param name="radius">距离</param> 2665 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2666 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2667 /// <param name="sorting">排序</param> 2668 /// <returns></returns> 2669 async public Task<(T member, decimal dist)[]> GeoRadiusWithDistAsync<T>(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2670 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesAsync(k, longitude, latitude, radius, unit, count, sorting, false, true, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.dist)).ToArray(); 2671 2672 /// <summary> 2673 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含经度、纬度）。 2674 /// </summary> 2675 /// <param name="key">不含prefix前辍</param> 2676 /// <param name="longitude">经度</param> 2677 /// <param name="latitude">纬度</param> 2678 /// <param name="radius">距离</param> 2679 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2680 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2681 /// <param name="sorting">排序</param> 2682 /// <returns></returns> 2683 async private Task<(string member, decimal longitude, decimal latitude)[]> GeoRadiusWithCoordAsync(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2684 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusAsync(k, longitude, latitude, radius, unit, count, sorting, true, false, false))).Select(a => (a.member, a.longitude, a.latitude)).ToArray(); 2685 /// <summary> 2686 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含经度、纬度）。 2687 /// </summary> 2688 /// <param name="key">不含prefix前辍</param> 2689 /// <param name="longitude">经度</param> 2690 /// <param name="latitude">纬度</param> 2691 /// <param name="radius">距离</param> 2692 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2693 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2694 /// <param name="sorting">排序</param> 2695 /// <returns></returns> 2696 async private Task<(T member, decimal longitude, decimal latitude)[]> GeoRadiusWithCoordAsync<T>(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2697 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesAsync(k, longitude, latitude, radius, unit, count, sorting, true, false, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.longitude, a.latitude)).ToArray(); 2698 2699 /// <summary> 2700 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离、经度、纬度）。 2701 /// </summary> 2702 /// <param name="key">不含prefix前辍</param> 2703 /// <param name="longitude">经度</param> 2704 /// <param name="latitude">纬度</param> 2705 /// <param name="radius">距离</param> 2706 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2707 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2708 /// <param name="sorting">排序</param> 2709 /// <returns></returns> 2710 async public Task<(string member, decimal dist, decimal longitude, decimal latitude)[]> GeoRadiusWithDistAndCoordAsync(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2711 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusAsync(k, longitude, latitude, radius, unit, count, sorting, true, true, false))).Select(a => (a.member, a.dist, a.longitude, a.latitude)).ToArray(); 2712 /// <summary> 2713 /// 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离、经度、纬度）。 2714 /// </summary> 2715 /// <param name="key">不含prefix前辍</param> 2716 /// <param name="longitude">经度</param> 2717 /// <param name="latitude">纬度</param> 2718 /// <param name="radius">距离</param> 2719 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2720 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2721 /// <param name="sorting">排序</param> 2722 /// <returns></returns> 2723 async public Task<(T member, decimal dist, decimal longitude, decimal latitude)[]> GeoRadiusWithDistAndCoordAsync<T>(string key, decimal longitude, decimal latitude, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2724 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesAsync(k, longitude, latitude, radius, unit, count, sorting, true, true, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.dist, a.longitude, a.latitude)).ToArray(); 2725 2726 /// <summary> 2727 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。 2728 /// </summary> 2729 /// <param name="key">不含prefix前辍</param> 2730 /// <param name="member">成员</param> 2731 /// <param name="radius">距离</param> 2732 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2733 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2734 /// <param name="sorting">排序</param> 2735 /// <returns></returns> 2736 async public Task<string[]> GeoRadiusByMemberAsync(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2737 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusByMemberAsync(k, member, radius, unit, count, sorting, false, false, false))).Select(a => a.member).ToArray(); 2738 /// <summary> 2739 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。 2740 /// </summary> 2741 /// <param name="key">不含prefix前辍</param> 2742 /// <param name="member">成员</param> 2743 /// <param name="radius">距离</param> 2744 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2745 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2746 /// <param name="sorting">排序</param> 2747 /// <returns></returns> 2748 async public Task<T[]> GeoRadiusByMemberAsync<T>(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2749 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesByMemberAsync(k, member, radius, unit, count, sorting, false, false, false))).Select(a => this.DeserializeRedisValueInternal<T>(a.member)).ToArray(); 2750 2751 /// <summary> 2752 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离）。 2753 /// </summary> 2754 /// <param name="key">不含prefix前辍</param> 2755 /// <param name="member">成员</param> 2756 /// <param name="radius">距离</param> 2757 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2758 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2759 /// <param name="sorting">排序</param> 2760 /// <returns></returns> 2761 async public Task<(string member, decimal dist)[]> GeoRadiusByMemberWithDistAsync(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2762 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusByMemberAsync(k, member, radius, unit, count, sorting, false, true, false))).Select(a => (a.member, a.dist)).ToArray(); 2763 /// <summary> 2764 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离）。 2765 /// </summary> 2766 /// <param name="key">不含prefix前辍</param> 2767 /// <param name="member">成员</param> 2768 /// <param name="radius">距离</param> 2769 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2770 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2771 /// <param name="sorting">排序</param> 2772 /// <returns></returns> 2773 async public Task<(T member, decimal dist)[]> GeoRadiusByMemberWithDistAsync<T>(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2774 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesByMemberAsync(k, member, radius, unit, count, sorting, false, true, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.dist)).ToArray(); 2775 2776 /// <summary> 2777 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含经度、纬度）。 2778 /// </summary> 2779 /// <param name="key">不含prefix前辍</param> 2780 /// <param name="member">成员</param> 2781 /// <param name="radius">距离</param> 2782 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2783 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2784 /// <param name="sorting">排序</param> 2785 /// <returns></returns> 2786 async private Task<(string member, decimal longitude, decimal latitude)[]> GeoRadiusByMemberWithCoordAsync(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2787 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusByMemberAsync(k, member, radius, unit, count, sorting, true, false, false))).Select(a => (a.member, a.longitude, a.latitude)).ToArray(); 2788 /// <summary> 2789 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含经度、纬度）。 2790 /// </summary> 2791 /// <param name="key">不含prefix前辍</param> 2792 /// <param name="member">成员</param> 2793 /// <param name="radius">距离</param> 2794 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2795 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2796 /// <param name="sorting">排序</param> 2797 /// <returns></returns> 2798 async private Task<(T member, decimal longitude, decimal latitude)[]> GeoRadiusByMemberWithCoordAsync<T>(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2799 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesByMemberAsync(k, member, radius, unit, count, sorting, true, false, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.longitude, a.latitude)).ToArray(); 2800 2801 /// <summary> 2802 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离、经度、纬度）。 2803 /// </summary> 2804 /// <param name="key">不含prefix前辍</param> 2805 /// <param name="member">成员</param> 2806 /// <param name="radius">距离</param> 2807 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2808 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2809 /// <param name="sorting">排序</param> 2810 /// <returns></returns> 2811 async public Task<(string member, decimal dist, decimal longitude, decimal latitude)[]> GeoRadiusByMemberWithDistAndCoordAsync(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2812 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusByMemberAsync(k, member, radius, unit, count, sorting, true, true, false))).Select(a => (a.member, a.dist, a.longitude, a.latitude)).ToArray(); 2813 /// <summary> 2814 /// 以给定的成员为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素（包含距离、经度、纬度）。 2815 /// </summary> 2816 /// <param name="key">不含prefix前辍</param> 2817 /// <param name="member">成员</param> 2818 /// <param name="radius">距离</param> 2819 /// <param name="unit">m 表示单位为米；km 表示单位为千米；mi 表示单位为英里；ft 表示单位为英尺；</param> 2820 /// <param name="count">虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。</param> 2821 /// <param name="sorting">排序</param> 2822 /// <returns></returns> 2823 async public Task<(T member, decimal dist, decimal longitude, decimal latitude)[]> GeoRadiusByMemberWithDistAndCoordAsync<T>(string key, object member, decimal radius, GeoUnit unit = GeoUnit.m, long? count = null, GeoOrderBy? sorting = null) => 2824 (await ExecuteScalarAsync(key, (c, k) => c.Value.GeoRadiusBytesByMemberAsync(k, member, radius, unit, count, sorting, true, true, false))).Select(a => (this.DeserializeRedisValueInternal<T>(a.member), a.dist, a.longitude, a.latitude)).ToArray(); 2825 #endregion 2826 } 2827 } 2828 #endif
使用方式
在Startup中注入
在server中使用
