正文

详解StackExchange.Redis通用封装类分享

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

这篇文章主要介绍了详解StackExchange.Redis通用封装类分享 ，详细的介绍了StackExchange.Redis通用封装，具有一定的参考价值，有需要的可以了解一下。

前两天朋友问我，有没有使用过stackexchange.redis，问我要个封装类，由于之前都是使用servicestack.redis，由于servicestack.redis v4版本后是收费版的，所以现在也很有公司都在使用stackexchange.redis而抛弃servicestack.redis了。其实个人觉得，两个驱动都不错，只是由于servicestack.redis收费导致目前很多公司都是基于v3版本的使用，也有人说v3版本有很多bug，没有维护和升级，不过至少目前我是没发现bug。

不过servicestack.redis同stackexchange.redis比较，抛开收费的来说，确认比stackexchange.redis 更有优势。stackexchange.redis文档很少，更不要说国内的文档了，连github上面对应的介绍文档都是很片面，这点我真的觉得stackexchange.redis的作者至少要完善下文档，很多都是要看源码的例子才有。网上对stackexchange.redis的使用例子也比servicestack.redis少得多，不是说没人用，只是我查来查去，大部分都是基于string类型的数据进行使用的封装类，对于list，sortedset，hash的封装操作都很少，基本都是东写一点，西写一点，很难找到完整的。在参考了一些文章和源码后，这里提供一个自己封装的类，基本提供对于各种类型的使用封装，提供给大家学习使用，如果有哪里写的不好的，大家也可以互相交流。

connectionmultiplexer 封装

首先是 connectionmultiplexer 的封装，connectionmultiplexer对象是stackexchange.redis最中枢的对象。这个类的实例需要被整个应用程序域共享和重用的，所以不需要在每个操作中不停的创建该对象的实例，一般都是使用单例来创建和存放这个对象，这个在官网上也有说明。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/// <summary>
 /// connectionmultiplexer对象管理帮助类
 /// </summary>
 public static class redisconnectionhelp
 {
  //系统自定义key前缀
  public static readonly string syscustomkey = configurationmanager.appsettings["rediskey"] ?? "";
 
  //"127.0.0.1:6379,allowadmin=true
  private static readonly string redisconnectionstring = configurationmanager.connectionstrings["redisexchangehosts"].connectionstring;
 
  private static readonly object locker = new object();
  private static connectionmultiplexer _instance;
  private static readonly concurrentdictionary<string, connectionmultiplexer> connectioncache = new concurrentdictionary<string, connectionmultiplexer>();
 
  /// <summary>
  /// 单例获取
  /// </summary>
  public static connectionmultiplexer instance
  {
   get
   {
    if (_instance == null)
    {
     lock (locker)
     {
      if (_instance == null || !_instance.isconnected)
      {
       _instance = getmanager();
      }
     }
    }
    return _instance;
   }
  }
 
  /// <summary>
  /// 缓存获取
  /// </summary>
  /// <param name="connectionstring"></param>
  /// <returns></returns>
  public static connectionmultiplexer getconnectionmultiplexer(string connectionstring)
  {
   if (!connectioncache.containskey(connectionstring))
   {
    connectioncache[connectionstring] = getmanager(connectionstring);
   }
   return connectioncache[connectionstring];
  }
 
  private static connectionmultiplexer getmanager(string connectionstring = null)
  {
   connectionstring = connectionstring ?? redisconnectionstring;
   var connect = connectionmultiplexer.connect(connectionstring);
 
   //注册如下事件
   connect.connectionfailed += muxerconnectionfailed;
   connect.connectionrestored += muxerconnectionrestored;
   connect.errormessage += muxererrormessage;
   connect.configurationchanged += muxerconfigurationchanged;
   connect.hashslotmoved += muxerhashslotmoved;
   connect.internalerror += muxerinternalerror;
 
   return connect;
  }
 
  #region 事件
 
  /// <summary>
  /// 配置更改时
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxerconfigurationchanged(object sender, endpointeventargs e)
  {
   console.writeline("configuration changed: " + e.endpoint);
  }
 
  /// <summary>
  /// 发生错误时
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxererrormessage(object sender, rediserroreventargs e)
  {
   console.writeline("errormessage: " + e.message);
  }
 
  /// <summary>
  /// 重新建立连接之前的错误
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxerconnectionrestored(object sender, connectionfailedeventargs e)
  {
   console.writeline("connectionrestored: " + e.endpoint);
  }
 
  /// <summary>
  /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxerconnectionfailed(object sender, connectionfailedeventargs e)
  {
   console.writeline("重新连接：endpoint failed: " + e.endpoint + ", " + e.failuretype + (e.exception == null ? "" : (", " + e.exception.message)));
  }
 
  /// <summary>
  /// 更改集群
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxerhashslotmoved(object sender, hashslotmovedeventargs e)
  {
   console.writeline("hashslotmoved:newendpoint" + e.newendpoint + ", oldendpoint" + e.oldendpoint);
  }
 
  /// <summary>
  /// redis类库错误
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void muxerinternalerror(object sender, internalerroreventargs e)
  {
   console.writeline("internalerror:message" + e.exception.message);
  }
 
  #endregion 事件
 }

redishelper 通用操作类封　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public class redishelper
 {
  private int dbnum { get; }
  private readonly connectionmultiplexer _conn;
  public string customkey;
 
  #region 构造函数
 
  public redishelper(int dbnum = 0)
    : this(dbnum, null)
  {
  }
 
  public redishelper(int dbnum, string readwritehosts)
  {
   dbnum = dbnum;
   _conn =
    string.isnullorwhitespace(readwritehosts) ?
    redisconnectionhelp.instance :
    redisconnectionhelp.getconnectionmultiplexer(readwritehosts);
  }
 
#region 辅助方法
 
  private string addsyscustomkey(string oldkey)
  {
   var prefixkey = customkey ?? redisconnectionhelp.syscustomkey;
   return prefixkey + oldkey;
  }
 
  private t do<t>(func<idatabase, t> func)
  {
   var database = _conn.getdatabase(dbnum);
   return func(database);
  }
 
  private string convertjson<t>(t value)
  {
   string result = value is string ? value.tostring() : jsonconvert.serializeobject(value);
   return result;
  }
 
  private t convertobj<t>(redisvalue value)
  {
   return jsonconvert.deserializeobject<t>(value);
  }
 
  private list<t> convetlist<t>(redisvalue[] values)
  {
   list<t> result = new list<t>();
   foreach (var item in values)
   {
    var model = convertobj<t>(item);
    result.add(model);
   }
   return result;
  }
 
  private rediskey[] convertrediskeys(list<string> rediskeys)
  {
   return rediskeys.select(rediskey => (rediskey)rediskey).toarray();
  }
 
  #endregion 辅助方法
 
  #endregion 构造函数
}

其中customkey用来表示系统前缀，addsyscustomkey方法对每个key都进行前缀的添加处理，这里推荐大家在命名redis的key的时候最好的加上前缀，并且使用 ：来分割前缀 ,这里在使用可视化工具查看的时候就比较好区分，比如我的的前缀是 demo:test:（一般是  系统名：业务名：）,然后你查看的时候你会发现整齐，好区分了很多

详解StackExchange.Redis通用封装类分享

string类型的封装

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
#region string
 
  #region 同步方法
 
  /// <summary>
  /// 保存单个key value
  /// </summary>
  /// <param name="key">redis key</param>
  /// <param name="value">保存的值</param>
  /// <param name="expiry">过期时间</param>
  /// <returns></returns>
  public bool stringset(string key, string value, timespan? expiry = default(timespan?))
  {
   key = addsyscustomkey(key);
   return do(db => db.stringset(key, value, expiry));
  }
 
  /// <summary>
  /// 保存多个key value
  /// </summary>
  /// <param name="keyvalues">键值对</param>
  /// <returns></returns>
  public bool stringset(list<keyvaluepair<rediskey, redisvalue>> keyvalues)
  {
   list<keyvaluepair<rediskey, redisvalue>> newkeyvalues =
    keyvalues.select(p => new keyvaluepair<rediskey, redisvalue>(addsyscustomkey(p.key), p.value)).tolist();
   return do(db => db.stringset(newkeyvalues.toarray()));
  }
 
  /// <summary>
  /// 保存一个对象
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="obj"></param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public bool stringset<t>(string key, t obj, timespan? expiry = default(timespan?))
  {
   key = addsyscustomkey(key);
   string json = convertjson(obj);
   return do(db => db.stringset(key, json, expiry));
  }
 
  /// <summary>
  /// 获取单个key的值
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns></returns>
  public string stringget(string key)
  {
   key = addsyscustomkey(key);
   return do(db => db.stringget(key));
  }
 
  /// <summary>
  /// 获取多个key
  /// </summary>
  /// <param name="listkey">redis key集合</param>
  /// <returns></returns>
  public redisvalue[] stringget(list<string> listkey)
  {
   list<string> newkeys = listkey.select(addsyscustomkey).tolist();
   return do(db => db.stringget(convertrediskeys(newkeys)));
  }
 
  /// <summary>
  /// 获取一个key的对象
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public t stringget<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(db => convertobj<t>(db.stringget(key)));
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public double stringincrement(string key, double val = 1)
  {
   key = addsyscustomkey(key);
   return do(db => db.stringincrement(key, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public double stringdecrement(string key, double val = 1)
  {
   key = addsyscustomkey(key);
   return do(db => db.stringdecrement(key, val));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 保存单个key value
  /// </summary>
  /// <param name="key">redis key</param>
  /// <param name="value">保存的值</param>
  /// <param name="expiry">过期时间</param>
  /// <returns></returns>
  public async task<bool> stringsetasync(string key, string value, timespan? expiry = default(timespan?))
  {
   key = addsyscustomkey(key);
   return await do(db => db.stringsetasync(key, value, expiry));
  }
 
  /// <summary>
  /// 保存多个key value
  /// </summary>
  /// <param name="keyvalues">键值对</param>
  /// <returns></returns>
  public async task<bool> stringsetasync(list<keyvaluepair<rediskey, redisvalue>> keyvalues)
  {
   list<keyvaluepair<rediskey, redisvalue>> newkeyvalues =
    keyvalues.select(p => new keyvaluepair<rediskey, redisvalue>(addsyscustomkey(p.key), p.value)).tolist();
   return await do(db => db.stringsetasync(newkeyvalues.toarray()));
  }
 
  /// <summary>
  /// 保存一个对象
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="obj"></param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public async task<bool> stringsetasync<t>(string key, t obj, timespan? expiry = default(timespan?))
  {
   key = addsyscustomkey(key);
   string json = convertjson(obj);
   return await do(db => db.stringsetasync(key, json, expiry));
  }
 
  /// <summary>
  /// 获取单个key的值
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns></returns>
  public async task<string> stringgetasync(string key)
  {
   key = addsyscustomkey(key);
   return await do(db => db.stringgetasync(key));
  }
 
  /// <summary>
  /// 获取多个key
  /// </summary>
  /// <param name="listkey">redis key集合</param>
  /// <returns></returns>
  public async task<redisvalue[]> stringgetasync(list<string> listkey)
  {
   list<string> newkeys = listkey.select(addsyscustomkey).tolist();
   return await do(db => db.stringgetasync(convertrediskeys(newkeys)));
  }
 
  /// <summary>
  /// 获取一个key的对象
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<t> stringgetasync<t>(string key)
  {
   key = addsyscustomkey(key);
   string result = await do(db => db.stringgetasync(key));
   return convertobj<t>(result);
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public async task<double> stringincrementasync(string key, double val = 1)
  {
   key = addsyscustomkey(key);
   return await do(db => db.stringincrementasync(key, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public async task<double> stringdecrementasync(string key, double val = 1)
  {
   key = addsyscustomkey(key);
   return await do(db => db.stringdecrementasync(key, val));
  }
 
  #endregion 异步方法
 
  #endregion string

这里说一下，stackexchange.redis 中对对象的存储是不自带序列化和反序列化的方法，所以在convertjson和convertobj里面我是使用了jsonconvert来操作，如果需要换成其他的序列化和序列化，直接修改这两个方面就好了，另外，stackexchange.redis 相对于servicestack.redis 来说提供了异步的方法，所以这里也同样封装了异步和同步的方法。

list类型的封装

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#region list
 
  #region 同步方法
 
  /// <summary>
  /// 移除指定listid的内部list的值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void listremove<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   do(db => db.listremove(key, convertjson(value)));
  }
 
  /// <summary>
  /// 获取指定key的list
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public list<t> listrange<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(redis =>
   {
    var values = redis.listrange(key);
    return convetlist<t>(values);
   });
  }
 
  /// <summary>
  /// 入队
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void listrightpush<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   do(db => db.listrightpush(key, convertjson(value)));
  }
 
  /// <summary>
  /// 出队
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public t listrightpop<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(db =>
    {
     var value = db.listrightpop(key);
     return convertobj<t>(value);
    });
  }
 
  /// <summary>
  /// 入栈
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void listleftpush<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   do(db => db.listleftpush(key, convertjson(value)));
  }
 
  /// <summary>
  /// 出栈
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public t listleftpop<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(db =>
   {
    var value = db.listleftpop(key);
    return convertobj<t>(value);
   });
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public long listlength(string key)
  {
   key = addsyscustomkey(key);
   return do(redis => redis.listlength(key));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 移除指定listid的内部list的值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async task<long> listremoveasync<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   return await do(db => db.listremoveasync(key, convertjson(value)));
  }
 
  /// <summary>
  /// 获取指定key的list
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<list<t>> listrangeasync<t>(string key)
  {
   key = addsyscustomkey(key);
   var values = await do(redis => redis.listrangeasync(key));
   return convetlist<t>(values);
  }
 
  /// <summary>
  /// 入队
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async task<long> listrightpushasync<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   return await do(db => db.listrightpushasync(key, convertjson(value)));
  }
 
  /// <summary>
  /// 出队
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<t> listrightpopasync<t>(string key)
  {
   key = addsyscustomkey(key);
   var value = await do(db => db.listrightpopasync(key));
   return convertobj<t>(value);
  }
 
  /// <summary>
  /// 入栈
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async task<long> listleftpushasync<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   return await do(db => db.listleftpushasync(key, convertjson(value)));
  }
 
  /// <summary>
  /// 出栈
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<t> listleftpopasync<t>(string key)
  {
   key = addsyscustomkey(key);
   var value = await do(db => db.listleftpopasync(key));
   return convertobj<t>(value);
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<long> listlengthasync(string key)
  {
   key = addsyscustomkey(key);
   return await do(redis => redis.listlengthasync(key));
  }
 
  #endregion 异步方法
 
  #endregion list

hash类型的封装

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
#region hash
 
  #region 同步方法
 
  /// <summary>
  /// 判断某个数据是否已经被缓存
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public bool hashexists(string key, string datakey)
  {
   key = addsyscustomkey(key);
   return do(db => db.hashexists(key, datakey));
  }
 
  /// <summary>
  /// 存储数据到hash表
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="t"></param>
  /// <returns></returns>
  public bool hashset<t>(string key, string datakey, t t)
  {
   key = addsyscustomkey(key);
   return do(db =>
   {
    string json = convertjson(t);
    return db.hashset(key, datakey, json);
   });
  }
 
  /// <summary>
  /// 移除hash中的某值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public bool hashdelete(string key, string datakey)
  {
   key = addsyscustomkey(key);
   return do(db => db.hashdelete(key, datakey));
  }
 
  /// <summary>
  /// 移除hash中的多个值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakeys"></param>
  /// <returns></returns>
  public long hashdelete(string key, list<redisvalue> datakeys)
  {
   key = addsyscustomkey(key);
   //list<redisvalue> datakeys1 = new list<redisvalue>() {"1","2"};
   return do(db => db.hashdelete(key, datakeys.toarray()));
  }
 
  /// <summary>
  /// 从hash表获取数据
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public t hashget<t>(string key, string datakey)
  {
   key = addsyscustomkey(key);
   return do(db =>
   {
    string value = db.hashget(key, datakey);
    return convertobj<t>(value);
   });
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public double hashincrement(string key, string datakey, double val = 1)
  {
   key = addsyscustomkey(key);
   return do(db => db.hashincrement(key, datakey, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public double hashdecrement(string key, string datakey, double val = 1)
  {
   key = addsyscustomkey(key);
   return do(db => db.hashdecrement(key, datakey, val));
  }
 
  /// <summary>
  /// 获取hashkey所有redis key
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public list<t> hashkeys<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(db =>
   {
    redisvalue[] values = db.hashkeys(key);
    return convetlist<t>(values);
   });
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 判断某个数据是否已经被缓存
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public async task<bool> hashexistsasync(string key, string datakey)
  {
   key = addsyscustomkey(key);
   return await do(db => db.hashexistsasync(key, datakey));
  }
 
  /// <summary>
  /// 存储数据到hash表
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="t"></param>
  /// <returns></returns>
  public async task<bool> hashsetasync<t>(string key, string datakey, t t)
  {
   key = addsyscustomkey(key);
   return await do(db =>
   {
    string json = convertjson(t);
    return db.hashsetasync(key, datakey, json);
   });
  }
 
  /// <summary>
  /// 移除hash中的某值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public async task<bool> hashdeleteasync(string key, string datakey)
  {
   key = addsyscustomkey(key);
   return await do(db => db.hashdeleteasync(key, datakey));
  }
 
  /// <summary>
  /// 移除hash中的多个值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakeys"></param>
  /// <returns></returns>
  public async task<long> hashdeleteasync(string key, list<redisvalue> datakeys)
  {
   key = addsyscustomkey(key);
   //list<redisvalue> datakeys1 = new list<redisvalue>() {"1","2"};
   return await do(db => db.hashdeleteasync(key, datakeys.toarray()));
  }
 
  /// <summary>
  /// 从hash表获取数据
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <returns></returns>
  public async task<t> hashgeasync<t>(string key, string datakey)
  {
   key = addsyscustomkey(key);
   string value = await do(db => db.hashgetasync(key, datakey));
   return convertobj<t>(value);
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public async task<double> hashincrementasync(string key, string datakey, double val = 1)
  {
   key = addsyscustomkey(key);
   return await do(db => db.hashincrementasync(key, datakey, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="datakey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public async task<double> hashdecrementasync(string key, string datakey, double val = 1)
  {
   key = addsyscustomkey(key);
   return await do(db => db.hashdecrementasync(key, datakey, val));
  }
 
  /// <summary>
  /// 获取hashkey所有redis key
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<list<t>> hashkeysasync<t>(string key)
  {
   key = addsyscustomkey(key);
   redisvalue[] values = await do(db => db.hashkeysasync(key));
   return convetlist<t>(values);
  }
 
  #endregion 异步方法
 
  #endregion hash

sortedset 类型的封装

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#region sortedset 有序集合
 
  #region 同步方法
 
  /// <summary>
  /// 添加
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  /// <param name="score"></param>
  public bool sortedsetadd<t>(string key, t value, double score)
  {
   key = addsyscustomkey(key);
   return do(redis => redis.sortedsetadd(key, convertjson<t>(value), score));
  }
 
  /// <summary>
  /// 删除
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public bool sortedsetremove<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   return do(redis => redis.sortedsetremove(key, convertjson(value)));
  }
 
  /// <summary>
  /// 获取全部
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public list<t> sortedsetrangebyrank<t>(string key)
  {
   key = addsyscustomkey(key);
   return do(redis =>
   {
    var values = redis.sortedsetrangebyrank(key);
    return convetlist<t>(values);
   });
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public long sortedsetlength(string key)
  {
   key = addsyscustomkey(key);
   return do(redis => redis.sortedsetlength(key));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 添加
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  /// <param name="score"></param>
  public async task<bool> sortedsetaddasync<t>(string key, t value, double score)
  {
   key = addsyscustomkey(key);
   return await do(redis => redis.sortedsetaddasync(key, convertjson<t>(value), score));
  }
 
  /// <summary>
  /// 删除
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async task<bool> sortedsetremoveasync<t>(string key, t value)
  {
   key = addsyscustomkey(key);
   return await do(redis => redis.sortedsetremoveasync(key, convertjson(value)));
  }
 
  /// <summary>
  /// 获取全部
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<list<t>> sortedsetrangebyrankasync<t>(string key)
  {
   key = addsyscustomkey(key);
   var values = await do(redis => redis.sortedsetrangebyrankasync(key));
   return convetlist<t>(values);
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async task<long> sortedsetlengthasync(string key)
  {
   key = addsyscustomkey(key);
   return await do(redis => redis.sortedsetlengthasync(key));
  }
 
  #endregion 异步方法
 
  #endregion sortedset 有序集合

key的管理

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#region key
 
  /// <summary>
  /// 删除单个key
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns>是否删除成功</returns>
  public bool keydelete(string key)
  {
   key = addsyscustomkey(key);
   return do(db => db.keydelete(key));
  }
 
  /// <summary>
  /// 删除多个key
  /// </summary>
  /// <param name="keys">rediskey</param>
  /// <returns>成功删除的个数</returns>
  public long keydelete(list<string> keys)
  {
   list<string> newkeys = keys.select(addsyscustomkey).tolist();
   return do(db => db.keydelete(convertrediskeys(newkeys)));
  }
 
  /// <summary>
  /// 判断key是否存储
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns></returns>
  public bool keyexists(string key)
  {
   key = addsyscustomkey(key);
   return do(db => db.keyexists(key));
  }
 
  /// <summary>
  /// 重新命名key
  /// </summary>
  /// <param name="key">就的redis key</param>
  /// <param name="newkey">新的redis key</param>
  /// <returns></returns>
  public bool keyrename(string key, string newkey)
  {
   key = addsyscustomkey(key);
   return do(db => db.keyrename(key, newkey));
  }
 
  /// <summary>
  /// 设置key的时间
  /// </summary>
  /// <param name="key">redis key</param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public bool keyexpire(string key, timespan? expiry = default(timespan?))
  {
   key = addsyscustomkey(key);
   return do(db => db.keyexpire(key, expiry));
  }
 
  #endregion key

发布和订阅

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#region 发布订阅
 
  /// <summary>
  /// redis发布订阅 订阅
  /// </summary>
  /// <param name="subchannel"></param>
  /// <param name="handler"></param>
  public void subscribe(string subchannel, action<redischannel, redisvalue> handler = null)
  {
   isubscriber sub = _conn.getsubscriber();
   sub.subscribe(subchannel, (channel, message) =>
   {
    if (handler == null)
    {
     console.writeline(subchannel + " 订阅收到消息：" + message);
    }
    else
    {
     handler(channel, message);
    }
   });
  }
 
  /// <summary>
  /// redis发布订阅 发布
  /// </summary>
  /// <typeparam name="t"></typeparam>
  /// <param name="channel"></param>
  /// <param name="msg"></param>
  /// <returns></returns>
  public long publish<t>(string channel, t msg)
  {
   isubscriber sub = _conn.getsubscriber();
   return sub.publish(channel, convertjson(msg));
  }
 
  /// <summary>
  /// redis发布订阅 取消订阅
  /// </summary>
  /// <param name="channel"></param>
  public void unsubscribe(string channel)
  {
   isubscriber sub = _conn.getsubscriber();
   sub.unsubscribe(channel);
  }
 
  /// <summary>
  /// redis发布订阅 取消全部订阅
  /// </summary>
  public void unsubscribeall()
  {
   isubscriber sub = _conn.getsubscriber();
   sub.unsubscribeall();
  }
 
  #endregion 发布订阅

其他

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#region 其他
 
  public itransaction createtransaction()
  {
   return getdatabase().createtransaction();
  }
 
  public idatabase getdatabase()
  {
   return _conn.getdatabase(dbnum);
  }
 
  public iserver getserver(string hostandport)
  {
   return _conn.getserver(hostandport);
  }
 
  /// <summary>
  /// 设置前缀
  /// </summary>
  /// <param name="customkey"></param>
  public void setsyscustomkey(string customkey)
  {
   customkey = customkey;
  }
 
  #endregion 其他

以上就是对stackexchange.redis基本操作的通用封装，提供给大家学习参考，如果有哪里写错的，也希望能一起交流。

问题：

stackexchange.redis没有提供redis分布式锁的操作么？servicestack.redis 提供了acquirelock 的方法来操作，stackexchange.redis 源码中只找到了locktake的方法，并没有找到其他的方法了，如果有人使用过，还希望能提供下。

最后，附上源码地址：demo

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持米米素材网。

原文链接：http://www.cnblogs.com/qtqq/p/5951201.html