1. using Newtonsoft.Json;
  2. using RedLockNet.SERedis;
  3. using RedLockNet.SERedis.Configuration;
  4. using StackExchange.Redis;
  5. using System;
  6. using System.Collections.Generic;
  7. using System.Linq;
  8. using System.Threading.Tasks;
  9.  
  10. namespace 秒杀系统
  11. {
  12.     public class RedisHelper
  13.     {
  14.         private static readonly string RedisHost = "127.0.0.1:6379";
  15.         private static readonly string RedisHost1 = "127.0.0.2:6379";
  16.         private static readonly string RedisPwd = "sa123456";
  17.  
  18.         private static readonly int RedisDbIndex = ;
  19.         private static readonly object LockObject = new object();
  20.  
  21.         private static ConnectionMultiplexer _connection;
  22.  
  23.         public static ConnectionMultiplexer Connection
  24.         {
  25.             get
  26.             {
  27.                 if (_connection == null)
  28.                 {
  29.                     lock (LockObject)
  30.                     {
  31.                         if (_connection == null || !_connection.IsConnected)
  32.                         {
  33.                             var config = new ConfigurationOptions
  34.                             {
  35.                                 AbortOnConnectFail = false,
  36.                                 ConnectRetry = ,
  37.                                 ConnectTimeout = ,
  38.                                 SyncTimeout = ,
  39.                                 EndPoints = { { RedisHost } },
  40.                                 AllowAdmin = true,
  41.                                 KeepAlive = ,
  42.                                 Password = RedisPwd
  43.                             };
  44.                             _connection = ConnectionMultiplexer.Connect(config);
  45.                             //注册如下事件
  46.                             _connection.ConnectionFailed += MuxerConnectionFailed;
  47.                             _connection.ErrorMessage += MuxerErrorMessage;
  48.                             _connection.InternalError += MuxerInternalError;
  49.                         }
  50.                     }
  51.                 }
  52.                 return _connection;
  53.             }
  54.         }
  55.  
  56.         public static RedLockFactory redLockFactory;
  57.  
  58.         public static RedLockFactory RedlockFactory
  59.         {
  60.             get
  61.             {
  62.                 if (redLockFactory != null) return redLockFactory;
  63.                 var multiplexers = new List<RedLockMultiplexer>()
  64.                 {
  65.                     Connection
  66.                 };
  67.                 var redlockFactory = RedLockFactory.Create(multiplexers);
  68.                 return redlockFactory;
  69.             }
  70.         }
  71.  
  72.         /// <summary>
  73.         /// 获取redis的DB
  74.         /// </summary>
  75.         /// <returns></returns>
  76.         private static IDatabase GetDatabase()
  77.         {
  78.             if (Connection == null || !Connection.IsConnected)
  79.             {
  80.                 throw new Exception("redis连接有误");
  81.             }
  82.             return Connection.GetDatabase(RedisDbIndex);
  83.         }
  84.  
  85.         #region 记录redis的连接日志
  86.  
  87.         /// <summary>
  88.         /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
  89.         /// </summary>
  90.         /// <param name="sender"></param>
  91.         /// <param name="e"></param>
  92.         private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
  93.         {
  94.         }
  95.  
  96.         /// <summary>
  97.         /// redis类库错误
  98.         /// </summary>
  99.         /// <param name="sender"></param>
  100.         /// <param name="e"></param>
  101.         private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
  102.         {
  103.         }
  104.  
  105.         /// <summary>
  106.         /// 发生错误时
  107.         /// </summary>
  108.         /// <param name="sender"></param>
  109.         /// <param name="e"></param>
  110.         private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
  111.         {
  112.         }
  113.  
  114.         #endregion 记录redis的连接日志
  115.  
  116.         #region String
  117.  
  118.         #region 同步方法
  119.  
  120.         /// <summary>
  121.         /// 保存单个key value
  122.         /// </summary>
  123.         /// <param name="key">Redis Key</param>
  124.         /// <param name="value">保存的值</param>
  125.         /// <param name="secondTimeout">过期时间</param>
  126.         /// <returns></returns>
  127.         public static bool StringSet(string key, string value, int secondTimeout)
  128.         {
  129.             return Do(db => db.StringSet(key, value, TimeSpan.FromSeconds(secondTimeout)));
  130.         }
  131.  
  132.         /// <summary>
  133.         /// 保存多个key value
  134.         /// </summary>
  135.         /// <param name="keyValues">键值对</param>
  136.         /// <returns></returns>
  137.         public static bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
  138.         {
  139.             List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
  140.                 keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(p.Key, p.Value)).ToList();
  141.             return Do(db => db.StringSet(newkeyValues.ToArray()));
  142.         }
  143.  
  144.         /// <summary>
  145.         /// 保存一个对象
  146.         /// </summary>
  147.         /// <typeparam name="T"></typeparam>
  148.         /// <param name="key"></param>
  149.         /// <param name="obj"></param>
  150.         /// <param name="secondTimeout"></param>
  151.         /// <returns></returns>
  152.         public static bool StringSet<T>(string key, T obj, int secondTimeout)
  153.         {
  154.             var json = ConvertJson(obj);
  155.             return Do(db => db.StringSet(key, json, TimeSpan.FromSeconds(secondTimeout)));
  156.         }
  157.  
  158.         /// <summary>
  159.         /// 获取单个key的值
  160.         /// </summary>
  161.         /// <param name="key">Redis Key</param>
  162.         /// <returns></returns>
  163.         public static string StringGet(string key)
  164.         {
  165.             return Do(db => db.StringGet(key));
  166.         }
  167.  
  168.         /// <summary>
  169.         /// 获取一个key的对象
  170.         /// </summary>
  171.         /// <typeparam name="T"></typeparam>
  172.         /// <param name="key"></param>
  173.         /// <returns></returns>
  174.         public static T StringGet<T>(string key)
  175.         {
  176.             return Do(db => ConvertObj<T>(db.StringGet(key)));
  177.         }
  178.  
  179.         /// <summary>
  180.         /// 为数字增长val
  181.         /// </summary>
  182.         /// <param name="key"></param>
  183.         /// <param name="val">可以为负</param>
  184.         /// <returns>增长后的值</returns>
  185.         public static long StringIncrement(string key, long val = )
  186.         {
  187.             return Do(db => db.StringIncrement(key, val));
  188.         }
  189.  
  190.         /// <summary>
  191.         /// 为数字减少val
  192.         /// </summary>
  193.         /// <param name="key"></param>
  194.         /// <param name="val">可以为负</param>
  195.         /// <returns>减少后的值</returns>
  196.         public static long StringDecrement(string key, long val = )
  197.         {
  198.             return Do(db => db.StringDecrement(key, val));
  199.         }
  200.  
  201.         /// <summary>
  202.         /// 为数字增长val
  203.         /// </summary>
  204.         /// <param name="key"></param>
  205.         /// <param name="val">可以为负</param>
  206.         /// <returns>增长后的值</returns>
  207.         public static double StringIncrement(string key, double val = )
  208.         {
  209.             return Do(db => db.StringIncrement(key, val));
  210.         }
  211.  
  212.         /// <summary>
  213.         /// 为数字减少val
  214.         /// </summary>
  215.         /// <param name="key"></param>
  216.         /// <param name="val">可以为负</param>
  217.         /// <returns>减少后的值</returns>
  218.         public static double StringDecrement(string key, double val = )
  219.         {
  220.             return Do(db => db.StringDecrement(key, val));
  221.         }
  222.  
  223.         #endregion 同步方法
  224.  
  225.         #region 异步方法
  226.  
  227.         /// <summary>
  228.         /// 保存单个key value
  229.         /// </summary>
  230.         /// <param name="key">Redis Key</param>
  231.         /// <param name="value">保存的值</param>
  232.         /// <param name="secondTimeout">过期时间</param>
  233.         /// <returns></returns>
  234.         public static async Task<bool> StringSetAsync(string key, string value, int secondTimeout)
  235.         {
  236.             return await Do(db => db.StringSetAsync(key, value, TimeSpan.FromSeconds(secondTimeout)));
  237.         }
  238.  
  239.         /// <summary>
  240.         /// 保存多个key value
  241.         /// </summary>
  242.         /// <param name="keyValues">键值对</param>
  243.         /// <returns></returns>
  244.         public static async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
  245.         {
  246.             List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
  247.                 keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(p.Key, p.Value)).ToList();
  248.             return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
  249.         }
  250.  
  251.         /// <summary>
  252.         /// 保存一个对象
  253.         /// </summary>
  254.         /// <typeparam name="T"></typeparam>
  255.         /// <param name="key"></param>
  256.         /// <param name="obj"></param>
  257.         /// <param name="secondTimeout"></param>
  258.         /// <returns></returns>
  259.         public static async Task<bool> StringSetAsync<T>(string key, T obj, int secondTimeout)
  260.         {
  261.             string json = ConvertJson(obj);
  262.             return await Do(db => db.StringSetAsync(key, json, TimeSpan.FromSeconds(secondTimeout)));
  263.         }
  264.  
  265.         /// <summary>
  266.         /// 获取单个key的值
  267.         /// </summary>
  268.         /// <param name="key">Redis Key</param>
  269.         /// <returns></returns>
  270.         public static async Task<string> StringGetAsync(string key)
  271.         {
  272.             return await Do(db => db.StringGetAsync(key));
  273.         }
  274.  
  275.         /// <summary>
  276.         /// 获取一个key的对象
  277.         /// </summary>
  278.         /// <typeparam name="T"></typeparam>
  279.         /// <param name="key"></param>
  280.         /// <returns></returns>
  281.         public static async Task<T> StringGetAsync<T>(string key)
  282.         {
  283.             string result = await Do(db => db.StringGetAsync(key));
  284.             return ConvertObj<T>(result);
  285.         }
  286.  
  287.         /// <summary>
  288.         /// 为数字增长val
  289.         /// </summary>
  290.         /// <param name="key"></param>
  291.         /// <param name="val">可以为负</param>
  292.         /// <returns>增长后的值</returns>
  293.         public static async Task<long> StringIncrementAsync(string key, long val = )
  294.         {
  295.             return await Do(db => db.StringIncrementAsync(key, val));
  296.         }
  297.  
  298.         /// <summary>
  299.         /// 为数字减少val
  300.         /// </summary>
  301.         /// <param name="key"></param>
  302.         /// <param name="val">可以为负</param>
  303.         /// <returns>减少后的值</returns>
  304.         public static async Task<long> StringDecrementAsync(string key, long val = )
  305.         {
  306.             return await Do(db => db.StringDecrementAsync(key, val));
  307.         }
  308.  
  309.         /// <summary>
  310.         /// 为数字增长val
  311.         /// </summary>
  312.         /// <param name="key"></param>
  313.         /// <param name="val">可以为负</param>
  314.         /// <returns>增长后的值</returns>
  315.         public static async Task<double> StringIncrementAsync(string key, double val = )
  316.         {
  317.             return await Do(db => db.StringIncrementAsync(key, val));
  318.         }
  319.  
  320.         /// <summary>
  321.         /// 为数字减少val
  322.         /// </summary>
  323.         /// <param name="key"></param>
  324.         /// <param name="val">可以为负</param>
  325.         /// <returns>减少后的值</returns>
  326.         public static async Task<double> StringDecrementAsync(string key, double val = )
  327.         {
  328.             return await Do(db => db.StringDecrementAsync(key, val));
  329.         }
  330.  
  331.         #endregion 异步方法
  332.  
  333.         #endregion String
  334.  
  335.         #region Hash
  336.  
  337.         #region 同步方法
  338.  
  339.         /// <summary>
  340.         /// 判断某个数据是否已经被缓存
  341.         /// </summary>
  342.         /// <param name="key"></param>
  343.         /// <param name="dataKey"></param>
  344.         /// <returns></returns>
  345.         public static bool HashExists(string key, string dataKey)
  346.         {
  347.             return Do(db => db.HashExists(key, dataKey));
  348.         }
  349.  
  350.         /// <summary>
  351.         /// 存储数据到hash表
  352.         /// </summary>
  353.         /// <typeparam name="T"></typeparam>
  354.         /// <param name="key"></param>
  355.         /// <param name="dataKey"></param>
  356.         /// <param name="t"></param>
  357.         /// <returns></returns>
  358.         public static bool HashSet<T>(string key, string dataKey, T t)
  359.         {
  360.             return Do(db =>
  361.             {
  362.                 string json = ConvertJson(t);
  363.                 return db.HashSet(key, dataKey, json);
  364.             });
  365.         }
  366.  
  367.         /// <summary>
  368.         /// 移除hash中的某值
  369.         /// </summary>
  370.         /// <param name="key"></param>
  371.         /// <param name="dataKey"></param>
  372.         /// <returns></returns>
  373.         public static bool HashDel(string key, string dataKey)
  374.         {
  375.             return Do(db => db.HashDelete(key, dataKey));
  376.         }
  377.  
  378.         /// <summary>
  379.         /// 移除hash中的多个值
  380.         /// </summary>
  381.         /// <param name="key"></param>
  382.         /// <param name="dataKeys"></param>
  383.         /// <returns></returns>
  384.         public static long HashDel(string key, List<RedisValue> dataKeys)
  385.         {
  386.             return Do(db => db.HashDelete(key, dataKeys.ToArray()));
  387.         }
  388.  
  389.         /// <summary>
  390.         /// 从hash表获取数据
  391.         /// </summary>
  392.         /// <typeparam name="T"></typeparam>
  393.         /// <param name="key"></param>
  394.         /// <param name="dataKey"></param>
  395.         /// <returns></returns>
  396.         public static T HashGet<T>(string key, string dataKey)
  397.         {
  398.             return Do(db =>
  399.             {
  400.                 if (!HashExists(key, dataKey)) return default(T);
  401.                 string value = db.HashGet(key, dataKey);
  402.                 return ConvertObj<T>(value);
  403.             });
  404.         }
  405.  
  406.         /// <summary>
  407.         /// 为数字增长val
  408.         /// </summary>
  409.         /// <param name="key"></param>
  410.         /// <param name="dataKey"></param>
  411.         /// <param name="val">可以为负</param>
  412.         /// <returns>增长后的值</returns>
  413.         public static double HashIncrement(string key, string dataKey, double val = )
  414.         {
  415.             return Do(db => db.HashIncrement(key, dataKey, val));
  416.         }
  417.  
  418.         /// <summary>
  419.         /// 为数字减少val
  420.         /// </summary>
  421.         /// <param name="key"></param>
  422.         /// <param name="dataKey"></param>
  423.         /// <param name="val">可以为负</param>
  424.         /// <returns>减少后的值</returns>
  425.         public static double HashDecrement(string key, string dataKey, double val = )
  426.         {
  427.             return Do(db => db.HashDecrement(key, dataKey, val));
  428.         }
  429.  
  430.         /// <summary>
  431.         /// 获取hashkey所有Redis key
  432.         /// </summary>
  433.         /// <typeparam name="T"></typeparam>
  434.         /// <param name="key"></param>
  435.         /// <returns></returns>
  436.         public static List<T> HashKeys<T>(string key)
  437.         {
  438.             return Do(db =>
  439.             {
  440.                 RedisValue[] values = db.HashKeys(key);
  441.                 return ConvetList<T>(values);
  442.             });
  443.         }
  444.  
  445.         /// <summary>
  446.         /// 获取hashkey所有Redis key
  447.         /// </summary>
  448.         /// <typeparam name="T"></typeparam>
  449.         /// <returns></returns>
  450.         public static List<T> HashGetAll<T>(string key)
  451.         {
  452.             var values = Do(db => db.HashGetAll(key));
  453.             return ConvetList<T>(values);
  454.         }
  455.  
  456.         #endregion 同步方法
  457.  
  458.         #region 异步方法
  459.  
  460.         /// <summary>
  461.         /// 判断某个数据是否已经被缓存
  462.         /// </summary>
  463.         /// <param name="key"></param>
  464.         /// <param name="dataKey"></param>
  465.         /// <returns></returns>
  466.         public static async Task<bool> HashExistsAsync(string key, string dataKey)
  467.         {
  468.             return await Do(db => db.HashExistsAsync(key, dataKey));
  469.         }
  470.  
  471.         /// <summary>
  472.         /// 存储数据到hash表
  473.         /// </summary>
  474.         /// <typeparam name="T"></typeparam>
  475.         /// <param name="key"></param>
  476.         /// <param name="dataKey"></param>
  477.         /// <param name="t"></param>
  478.         /// <returns></returns>
  479.         public static async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
  480.         {
  481.             return await Do(db =>
  482.             {
  483.                 string json = ConvertJson(t);
  484.                 return db.HashSetAsync(key, dataKey, json);
  485.             });
  486.         }
  487.  
  488.         /// <summary>
  489.         /// 移除hash中的某值
  490.         /// </summary>
  491.         /// <param name="key"></param>
  492.         /// <param name="dataKey"></param>
  493.         /// <returns></returns>
  494.         public static async Task<bool> HashDelAsync(string key, string dataKey)
  495.         {
  496.             return await Do(db => db.HashDeleteAsync(key, dataKey));
  497.         }
  498.  
  499.         /// <summary>
  500.         /// 移除hash中的多个值
  501.         /// </summary>
  502.         /// <param name="key"></param>
  503.         /// <param name="dataKeys"></param>
  504.         /// <returns></returns>
  505.         public static async Task<long> HashDelAsync(string key, List<RedisValue> dataKeys)
  506.         {
  507.             return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
  508.         }
  509.  
  510.         /// <summary>
  511.         /// 从hash表获取数据
  512.         /// </summary>
  513.         /// <typeparam name="T"></typeparam>
  514.         /// <param name="key"></param>
  515.         /// <param name="dataKey"></param>
  516.         /// <returns></returns>
  517.         public static async Task<T> HashGeAsync<T>(string key, string dataKey)
  518.         {
  519.             string value = await Do(db => db.HashGetAsync(key, dataKey));
  520.             return ConvertObj<T>(value);
  521.         }
  522.  
  523.         /// <summary>
  524.         /// 为数字增长val
  525.         /// </summary>
  526.         /// <param name="key"></param>
  527.         /// <param name="dataKey"></param>
  528.         /// <param name="val">可以为负</param>
  529.         /// <returns>增长后的值</returns>
  530.         public static async Task<double> HashIncrementAsync(string key, string dataKey, double val = )
  531.         {
  532.             return await Do(db => db.HashIncrementAsync(key, dataKey, val));
  533.         }
  534.  
  535.         /// <summary>
  536.         /// 为数字减少val
  537.         /// </summary>
  538.         /// <param name="key"></param>
  539.         /// <param name="dataKey"></param>
  540.         /// <param name="val">可以为负</param>
  541.         /// <returns>减少后的值</returns>
  542.         public static async Task<long> HashDecrementAsync(string key, string dataKey, long val = )
  543.         {
  544.             return await Do(db => db.HashDecrementAsync(key, dataKey, val));
  545.         }
  546.  
  547.         /// <summary>
  548.         /// 为数字增长val
  549.         /// </summary>
  550.         /// <param name="key"></param>
  551.         /// <param name="dataKey"></param>
  552.         /// <param name="val">可以为负</param>
  553.         /// <returns>增长后的值</returns>
  554.         public static async Task<long> HashIncrementAsync(string key, string dataKey, long val = )
  555.         {
  556.             return await Do(db => db.HashIncrementAsync(key, dataKey, val));
  557.         }
  558.  
  559.         /// <summary>
  560.         /// 为数字减少val
  561.         /// </summary>
  562.         /// <param name="key"></param>
  563.         /// <param name="dataKey"></param>
  564.         /// <param name="val">可以为负</param>
  565.         /// <returns>减少后的值</returns>
  566.         public static async Task<double> HashDecrementAsync(string key, string dataKey, double val = )
  567.         {
  568.             return await Do(db => db.HashDecrementAsync(key, dataKey, val));
  569.         }
  570.  
  571.         /// <summary>
  572.         /// 获取hashkey所有Redis key
  573.         /// </summary>
  574.         /// <typeparam name="T"></typeparam>
  575.         /// <param name="key"></param>
  576.         /// <returns></returns>
  577.         public static async Task<List<T>> HashKeysAsync<T>(string key)
  578.         {
  579.             RedisValue[] values = await Do(db => db.HashKeysAsync(key));
  580.             return ConvetList<T>(values);
  581.         }
  582.  
  583.         /// <summary>
  584.         /// 获取hashkey所有Redis key
  585.         /// </summary>
  586.         /// <typeparam name="T"></typeparam>
  587.         /// <param name="key"></param>
  588.         /// <returns></returns>
  589.         public static async Task<List<T>> HashGetAllAsync<T>(string key)
  590.         {
  591.             var values = await Do(db => db.HashGetAllAsync(key));
  592.             return ConvetList<T>(values);
  593.         }
  594.  
  595.         #endregion 异步方法
  596.  
  597.         #endregion Hash
  598.  
  599.         #region List
  600.  
  601.         #region 同步方法
  602.  
  603.         /// <summary>
  604.         /// 移除指定ListId的内部List的值
  605.         /// </summary>
  606.         /// <param name="key"></param>
  607.         /// <param name="value"></param>
  608.         public static void ListRemove<T>(string key, T value)
  609.         {
  610.             Do(db => db.ListRemove(key, ConvertJson(value)));
  611.         }
  612.  
  613.         /// <summary>
  614.         /// 获取指定key的List
  615.         /// </summary>
  616.         /// <param name="key"></param>
  617.         /// <returns></returns>
  618.         public static List<T> ListRange<T>(string key)
  619.         {
  620.             return Do(redis =>
  621.             {
  622.                 var values = redis.ListRange(key);
  623.                 return ConvetList<T>(values);
  624.             });
  625.         }
  626.  
  627.         /// <summary>
  628.         /// 入队
  629.         /// </summary>
  630.         /// <param name="key"></param>
  631.         /// <param name="value"></param>
  632.         public static void ListRightPush<T>(string key, T value)
  633.         {
  634.             Do(db => db.ListRightPush(key, ConvertJson(value)));
  635.         }
  636.  
  637.         /// <summary>
  638.         /// 出队
  639.         /// </summary>
  640.         /// <typeparam name="T"></typeparam>
  641.         /// <param name="key"></param>
  642.         /// <returns></returns>
  643.         public static T ListRightPop<T>(string key)
  644.         {
  645.             return Do(db =>
  646.             {
  647.                 var value = db.ListRightPop(key);
  648.                 return ConvertObj<T>(value);
  649.             });
  650.         }
  651.  
  652.         /// <summary>
  653.         /// 入栈
  654.         /// </summary>
  655.         /// <typeparam name="T"></typeparam>
  656.         /// <param name="key"></param>
  657.         /// <param name="value"></param>
  658.         public static void ListLeftPush<T>(string key, T value)
  659.         {
  660.             Do(db => db.ListLeftPush(key, ConvertJson(value)));
  661.         }
  662.  
  663.         /// <summary>
  664.         /// 出栈
  665.         /// </summary>
  666.         /// <typeparam name="T"></typeparam>
  667.         /// <param name="key"></param>
  668.         /// <returns></returns>
  669.         public static T ListLeftPop<T>(string key)
  670.         {
  671.             return Do(db =>
  672.             {
  673.                 var value = db.ListLeftPop(key);
  674.                 return ConvertObj<T>(value);
  675.             });
  676.         }
  677.  
  678.         /// <summary>
  679.         /// 获取集合中的数量
  680.         /// </summary>
  681.         /// <param name="key"></param>
  682.         /// <returns></returns>
  683.         public static long ListLength(string key)
  684.         {
  685.             return Do(redis => redis.ListLength(key));
  686.         }
  687.  
  688.         #endregion 同步方法
  689.  
  690.         #region 异步方法
  691.  
  692.         /// <summary>
  693.         /// 移除指定ListId的内部List的值
  694.         /// </summary>
  695.         /// <param name="key"></param>
  696.         /// <param name="value"></param>
  697.         public static async Task<long> ListRemoveAsync<T>(string key, T value)
  698.         {
  699.             return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
  700.         }
  701.  
  702.         /// <summary>
  703.         /// 获取指定key的List
  704.         /// </summary>
  705.         /// <param name="key"></param>
  706.         /// <returns></returns>
  707.         public static async Task<List<T>> ListRangeAsync<T>(string key)
  708.         {
  709.             var values = await Do(redis => redis.ListRangeAsync(key));
  710.             return ConvetList<T>(values);
  711.         }
  712.  
  713.         /// <summary>
  714.         /// 入队
  715.         /// </summary>
  716.         /// <param name="key"></param>
  717.         /// <param name="value"></param>
  718.         public static async Task<long> ListRightPushAsync<T>(string key, T value)
  719.         {
  720.             return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
  721.         }
  722.  
  723.         /// <summary>
  724.         /// 出队
  725.         /// </summary>
  726.         /// <typeparam name="T"></typeparam>
  727.         /// <param name="key"></param>
  728.         /// <returns></returns>
  729.         public static async Task<T> ListRightPopAsync<T>(string key)
  730.         {
  731.             var value = await Do(db => db.ListRightPopAsync(key));
  732.             return ConvertObj<T>(value);
  733.         }
  734.  
  735.         /// <summary>
  736.         /// 入栈
  737.         /// </summary>
  738.         /// <typeparam name="T"></typeparam>
  739.         /// <param name="key"></param>
  740.         /// <param name="value"></param>
  741.         public static async Task<long> ListLeftPushAsync<T>(string key, T value)
  742.         {
  743.             return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
  744.         }
  745.  
  746.         /// <summary>
  747.         /// 出栈
  748.         /// </summary>
  749.         /// <typeparam name="T"></typeparam>
  750.         /// <param name="key"></param>
  751.         /// <returns></returns>
  752.         public static async Task<T> ListLeftPopAsync<T>(string key)
  753.         {
  754.             var value = await Do(db => db.ListLeftPopAsync(key));
  755.             return ConvertObj<T>(value);
  756.         }
  757.  
  758.         /// <summary>
  759.         /// 获取集合中的数量
  760.         /// </summary>
  761.         /// <param name="key"></param>
  762.         /// <returns></returns>
  763.         public static async Task<long> ListLengthAsync(string key)
  764.         {
  765.             return await Do(redis => redis.ListLengthAsync(key));
  766.         }
  767.  
  768.         #endregion 异步方法
  769.  
  770.         #endregion List
  771.  
  772.         #region SortedSet 有序集合
  773.  
  774.         #region 同步方法
  775.  
  776.         /// <summary>
  777.         /// 添加
  778.         /// </summary>
  779.         /// <param name="key"></param>
  780.         /// <param name="value"></param>
  781.         /// <param name="score"></param>
  782.         public static bool SortedSetAdd<T>(string key, T value, double score)
  783.         {
  784.             return Do(redis => redis.SortedSetAdd(key, ConvertJson<T>(value), score));
  785.         }
  786.  
  787.         /// <summary>
  788.         /// 删除
  789.         /// </summary>
  790.         /// <param name="key"></param>
  791.         /// <param name="value"></param>
  792.         public static bool SortedSetRemove<T>(string key, T value)
  793.         {
  794.             return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
  795.         }
  796.  
  797.         /// <summary>
  798.         /// 获取全部
  799.         /// </summary>
  800.         /// <param name="key"></param>
  801.         /// <returns></returns>
  802.         public static List<T> SortedSetRangeByRank<T>(string key)
  803.         {
  804.             return Do(redis =>
  805.             {
  806.                 var values = redis.SortedSetRangeByRank(key);
  807.                 return ConvetList<T>(values);
  808.             });
  809.         }
  810.  
  811.         /// <summary>
  812.         /// 获取集合中的数量
  813.         /// </summary>
  814.         /// <param name="key"></param>
  815.         /// <returns></returns>
  816.         public static long SortedSetLength(string key)
  817.         {
  818.             return Do(redis => redis.SortedSetLength(key));
  819.         }
  820.  
  821.         #endregion 同步方法
  822.  
  823.         #region 异步方法
  824.  
  825.         /// <summary>
  826.         /// 添加
  827.         /// </summary>
  828.         /// <param name="key"></param>
  829.         /// <param name="value"></param>
  830.         /// <param name="score"></param>
  831.         public static async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
  832.         {
  833.             return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson<T>(value), score));
  834.         }
  835.  
  836.         /// <summary>
  837.         /// 删除
  838.         /// </summary>
  839.         /// <param name="key"></param>
  840.         /// <param name="value"></param>
  841.         public static async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
  842.         {
  843.             return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
  844.         }
  845.  
  846.         /// <summary>
  847.         /// 获取全部
  848.         /// </summary>
  849.         /// <param name="key"></param>
  850.         /// <returns></returns>
  851.         public static async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
  852.         {
  853.             var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
  854.             return ConvetList<T>(values);
  855.         }
  856.  
  857.         /// <summary>
  858.         /// 获取集合中的数量
  859.         /// </summary>
  860.         /// <param name="key"></param>
  861.         /// <returns></returns>
  862.         public static async Task<long> SortedSetLengthAsync(string key)
  863.         {
  864.             return await Do(redis => redis.SortedSetLengthAsync(key));
  865.         }
  866.  
  867.         #endregion 异步方法
  868.  
  869.         #endregion SortedSet 有序集合
  870.  
  871.         #region key
  872.  
  873.         /// <summary>
  874.         /// 删除单个key
  875.         /// </summary>
  876.         /// <param name="key">redis key</param>
  877.         /// <returns>是否删除成功</returns>
  878.         public static bool KeyDel(string key)
  879.         {
  880.             return Do(db => db.KeyDelete(key));
  881.         }
  882.  
  883.         /// <summary>
  884.         /// 删除多个key
  885.         /// </summary>
  886.         /// <param name="keys">rediskey</param>
  887.         /// <returns>成功删除的个数</returns>
  888.         public static long KeyDel(List<string> keys)
  889.         {
  890.             return Do(db => db.KeyDelete(ConvertRedisKeys(keys)));
  891.         }
  892.  
  893.         /// <summary>
  894.         /// 判断key是否存储
  895.         /// </summary>
  896.         /// <param name="key">redis key</param>
  897.         /// <returns></returns>
  898.         public static bool KeyExists(string key)
  899.         {
  900.             return Do(db => db.KeyExists(key));
  901.         }
  902.  
  903.         /// <summary>
  904.         /// 设置Key的时间
  905.         /// </summary>
  906.         /// <param name="key">redis key</param>
  907.         /// <param name="secondTimeout"></param>
  908.         /// <returns></returns>
  909.         public static bool KeyExpire(string key, int secondTimeout)
  910.         {
  911.             return Do(db => db.KeyExpire(key, TimeSpan.FromSeconds(secondTimeout)));
  912.         }
  913.  
  914.         #endregion key
  915.  
  916.         #region 辅助方法
  917.  
  918.         private static T Do<T>(Func<IDatabase, T> func)
  919.         {
  920.             try
  921.             {
  922.                 var database = GetDatabase();
  923.                 return func(database);
  924.             }
  925.             catch (Exception ex)
  926.             {
  927.                 return default(T);
  928.             }
  929.         }
  930.  
  931.         private static string ConvertJson<T>(T value)
  932.         {
  933.             string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
  934.             return result;
  935.         }
  936.  
  937.         private static T ConvertObj<T>(RedisValue value)
  938.         {
  939.             if (value.IsNullOrEmpty)
  940.             {
  941.                 return default(T);
  942.             }
  943.             return JsonConvert.DeserializeObject<T>(value.ToString());
  944.         }
  945.  
  946.         private static List<T> ConvetList<T>(RedisValue[] values)
  947.         {
  948.             List<T> result = new List<T>();
  949.             foreach (var item in values)
  950.             {
  951.                 var model = ConvertObj<T>(item);
  952.                 result.Add(model);
  953.             }
  954.             return result;
  955.         }
  956.  
  957.         private static RedisKey[] ConvertRedisKeys(List<string> redisKeys)
  958.         {
  959.             return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
  960.         }
  961.  
  962.         private static List<T> ConvetList<T>(HashEntry[] values)
  963.         {
  964.             List<T> result = new List<T>();
  965.             foreach (var item in values)
  966.             {
  967.                 if (!item.Value.IsNullOrEmpty)
  968.                 {
  969.                     var model = ConvertObj<T>(item.Value);
  970.                     result.Add(model);
  971.                 }
  972.             }
  973.             return result;
  974.         }
  975.  
  976.         #endregion 辅助方法
  977.  
  978.         public static IBatch CreateBatch()
  979.         {
  980.             return GetDatabase().CreateBatch();
  981.         }
  982.  
  983.         public static ITransaction CreateTransaction()
  984.         {
  985.             return GetDatabase().CreateTransaction();
  986.         }
  987.  
  988.         //使用Keys *模糊匹配Key
  989.         public static List<string> GetMatchKeys(string key)
  990.         {
  991.             var result = (string[])GetDatabase().ScriptEvaluate(LuaScript.Prepare("return redis.call('KEYS',@keypattern)"), new { keypattern = key });
  992.             return result.ToList();
  993.         }
  994.  
  995.         //使用SCAN模糊匹配Key
  996.         public static List<string> ScanMatchKeys(string key)
  997.         {
  998.             var result = (string[])GetDatabase().ScriptEvaluate(
  999.                 LuaScript.Prepare("local dbsize=redis.call('dbsize') local res=redis.call('scan',0,'match',KEYS[1],'count',dbsize) return res[2]"),
  1000.                 new RedisKey[] { key });
  1001.             return result.ToList();
  1002.         }
  1003.     }
  1004. }

RedisHelper帮助类的更多相关文章

  1. Java类的继承与多态特性-入门笔记

    相信对于继承和多态的概念性我就不在怎么解释啦!不管你是.Net还是Java面向对象编程都是比不缺少一堂课~~Net如此Java亦也有同样的思想成分包含其中. 继承,多态,封装是Java面向对象的3大特 ...

  2. Windows下Redis缓存服务器的使用 .NET StackExchange.Redis Redis Desktop Manager

    Redis缓存服务器是一款key/value数据库,读110000次/s,写81000次/s,因为是内存操作所以速度飞快,常见用法是存用户token.短信验证码等 官网显示Redis本身并没有Wind ...

  3. Python 之路：Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    一.Memcached Memcached是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负债.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速 ...

  4. .NET Core开发者的福音之玩转Redis的又一傻瓜式神器推荐

    作者:依乐祝 原本链接:https://www.cnblogs.com/yilezhu/p/9947905.html 引子 为什么写这篇文章呢?因为.NET Core的生态越来越好了!之前玩转.net ...

  5. 【每日更新】【Redis学习】

    5. Redis订阅和发布模式和Redis事务 -------------------Redis事务------------------- 1.概念:     redis中的事务是一组命令的集合.事务 ...

  6. Windows下Redis缓存服务器的使用 .NET StackExchange.Redis Redis Desktop Manager 转发非原创

    Windows下Redis缓存服务器的使用 .NET StackExchange.Redis Redis Desktop Manager   Redis缓存服务器是一款key/value数据库,读11 ...

  7. [翻译] C# 8.0 新特性 Redis基本使用及百亿数据量中的使用技巧分享（附视频地址及观看指南） 【由浅至深】redis 实现发布订阅的几种方式 .NET Core开发者的福音之玩转Redis的又一傻瓜式神器推荐

    [翻译] C# 8.0 新特性 2018-11-13 17:04 by Rwing, 1179 阅读, 24 评论, 收藏, 编辑 原文: Building C# 8.0[译注:原文主标题如此,但内容 ...

  8. C#版-Redis缓存服务器在Windows下的使用

    Redis缓存服务器是一款key/value数据库,读110000次/s,写81000次/s,因为是内存操作所以速度飞快,常见用法是存用户token.短信验证码等 官网显示Redis本身并没有Wind ...

  9. Redis缓存相关

    Redis缓存服务搭建及实现数据读写 RedisHelper帮助类 /// <summary> /// Redis 帮助类文件 /// </summary> public cl ...

随机推荐

  1. UIAutomator简介

    简介 Android 4.3发布的时候包含了一种新的测试工具–uiautomator,uiautomator是用来做UI测试的.也就是普通的手工测试,点击每个控件元素 看看输出的结果是否符合预期.比如 ...

  2. 倍增\ tarjan求lca

    对于每个节点v,记录anc[v][k],表示从它向上走2k步后到达的节点(如果越过了根节点,那么anc[v][k]就是根节点). dfs函数对树进行的dfs,先求出anc[v][0],再利用anc[v ...

  3. mongoDB 文档概念

    mongoDB 文档概念 什么是文档 文档是 mongodb 基本的数据组织单元,类似于mysql 中的记录 文档由多个键值对组成,每个键值对表达一个数据项 属于 bson 数据 ps:  bson ...

  4. 在Magento 2中创建管理员菜单

    在Magento 2中创建管理员菜单 第1步:创建menu.xml 第2步:添加菜单项 第3步:刷新Magento缓存 第1步:创建menu.xml 创建名为:menu.xml文件的管理菜单文件 ap ...

  5. js侧边菜单

    目标 实现一个侧边栏菜单,最多二级,可以收起展开.用于系统左侧的主菜单. 大多数系统都会有这样的菜单,用于导航功能,切换到不同的操作页面.在单页应用系统中,菜单一般是固定在左侧,分组节点上配图标,高亮 ...

  6. Shell入门及实践

    解释器 解释器是一种命令解释器,主要作用是对命令进行运行和解释,将需要执行的操作传递给操作系统内核并执行 #!/bin/bash(默认),指定解释器 #!/bin/bash #这是第一个shell脚本 ...

  7. jdbc批处理进行多条数据插入

    package cn.linjun.demo; import java.sql.Connection; import java.sql.DriverManager; import java.sql.S ...

  8. go 数组 切片 字典 结构体

    数组 ##数组的定义与赋值: 1. var num [3]int num = [3]int{1,2,3} 2. var num [3]int = [3]int {1,2,3} 3. num := [3 ...

  9. tex中pdf外链

    \documentclass{article} \usepackage{hyperref} \begin{document} \href{run:d:/my folder/test.pdf}{This ...

  10. MySQL5.6.39修改密码

    5.6.39 苹果->系统偏好设置->最下边点mysql 在弹出页面中 关闭mysql服务(点击stop mysql server) step2: 进入终端输入:cd /usr/local ...