Redis .Net客户端源码

1、简单介绍

当前NoSql使用已经极为普遍，无论是Java生态圈，还是.net生态圈。大大小小的Web站点在追求高性能高可靠性方面，不由自主都选择了NoSQL技术作为优先考虑的方面。主流的技术有：HBase、MongoDB、Redis等等。我为什么要选择Redis呢？一是因为，我跟风学来的。。。二是，套用某位大神的话，Redis是Nosql数据库中使用较为广泛的非关系型内存数据库，redis内部是一个key-value存储系统。它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型，类似于Java中的map）。Redis基于内存运行并支持持久化的NoSQL数据库，是当前最热门的NoSql数据库之一，也被人们称为数据结构服务器。总之，我就是用了，而且取得了不错的性能提升，减轻了数据库服务器的压力。

我这里的项目，采用二进制压缩存储，当然你也可以选择json方式，与Redis服务器即时连接即时释放，支持高并发读写，以List、HashSet类型存储为主要结构，读写分离，可以灵活配置。

2、Redis客户端部分源码

 public class RedisClient
     {
         public string ChannelName = string.Empty;

         public bool IsPattern = false;

         public Action<Exception> OnError;

         public Action<object, object> OnMessage;

         public Action<object[]> OnSuccess;

         public Action<object> OnUnSubscribe;

         #region 常用方法

         private void SelectDB(TcpClient client)
         {
             try
             {
                 if (client.DB != DB)
                 {
                     client.DB = DB;
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_SELECT);
                         cmd.Add(DB.ToString());
                         using (var result = TcpClient.Send(cmd, client))
                         {
                         }
                     }
                 }
             }
             catch (Exception ex)
             {

                 Log.Instance.Error("堆栈内存分配不足：{0}",ex.Message);
             }

         }

         #endregion

         /// <summary>
         ///     返回哈希表key中域的数量
         /// </summary>
         /// <param name="key"></param>
         /// <returns>哈希表中域的数量 当key不存在时，返回0</returns>
         public int HLen(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HLEN);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     为给定key设置生存时间
         ///     当key过期时，它会被自动删除。
         ///     在Redis中，带有生存时间的key被称作“易失的”(volatile)。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="time"></param>
         /// <returns>
         ///     设置成功返回1。
         ///     当key不存在或者不能为key设置生存时间时(比如在低于2.1.3中你尝试更新key的生存时间)，返回0。
         /// </returns>
         public int Expire(string key, long time)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_EXPIRE);
                     cmd.Add(key);
                     cmd.Add(time.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     返回给定key的剩余生存时间(time to live)(以秒为单位)。
         /// </summary>
         /// <param name="key"></param>
         /// <returns>key的剩余生存时间(以秒为单位)。当key不存在或没有设置生存时间时，返回-1 。</returns>
         public int TTL(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_TTL);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     返回当前服器时间
         /// </summary>
         /// <returns></returns>
         public List<string> Time()
         {
             List<string> r;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_TIME);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         r = new List<string>(result.ResultDataBlock.Count);
                         foreach (var i in result.ResultDataBlock)
                         {
                             r.Add(i.GetString());
                         }
                     }
                 }
             }
             return r;
         }

         /// <summary>
         ///     从当前数据库中随机返回(不删除)一个key。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns>当数据库不为空时，返回一个key。当数据库为空时，返回nil。</returns>
         public T RandomKey<T>()
         {
             T t;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_RANDOMKEY);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         t = (T)FromRedis(result.ResultDataBlock[], DataType.String, typeof(T));
                     }
                 }
             }
             return t;
         }

         public void Delete(IList<string> keys)
         {
             Delete(keys.ToArray());
         }

         /// <summary>
         ///     查找符合给定模式的key。
         /// </summary>
         /// <param name="match"></param>
         /// <returns>符合给定模式的key列表。</returns>
         [Obsolete("KEYS的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合(Set)。")]
         public List<string> Keys(string match)
         {
             List<string> r;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_KEYS);
                     cmd.Add(match);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         r = new List<string>(result.ResultDataBlock.Count);
                         foreach (var i in result.ResultDataBlock)
                         {
                             r.Add(i.GetString());
                         }
                     }
                 }
             }
             return r;
         }

         /// <summary>
         ///     返回列表key的长度。
         /// </summary>
         /// <param name="key"></param>
         /// <returns>列表key的长度。</returns>
         public int ListLength(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LLEN);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     移除并返回列表key的头元素
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dtype"></param>
         /// <returns>列表的头元素</returns>
         public T LPop<T>(string key, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LPOP);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return (T)FromRedis(result.ResultDataBlock[], dtype, typeof(T));
                     }
                 }
             }
         }

         /// <summary>
         ///     移除并返回列表key的尾元素
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dtype"></param>
         /// <returns>列表的尾元素。</returns>
         public T RPOP<T>(string key, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_RPOP);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return (T)FromRedis(result.ResultDataBlock[], dtype, typeof(T));
                     }
                 }
             }
         }

         /// <summary>
         ///     将一个或多个值value插入到列表key的表头
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="dtype"></param>
         /// <returns>执行LPUSH命令后，列表的长度</returns>
         public int LPUSH(string key, object value, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LPUSH);
                     cmd.Add(key);
                     ToRedis(value, dtype, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     将列表key下标为index的元素的值设置为value。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="index"></param>
         /// <param name="value"></param>
         /// <param name="dtype"></param>
         /// <returns>操作成功返回ok，否则返回错误信息。</returns>
         public string SetListItem(string key, int index, object value, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LSET);
                     cmd.Add(key);
                     cmd.Add(index.ToString());
                     ToRedis(value, dtype, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return result.ResultData.ToString();
                     }
                 }
             }
         }

         /// <summary>
         ///     将一个或多个值value插入到列表key的表尾。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public int RPush(string key, object value, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_RPUSH);
                     cmd.Add(key);
                     ToRedis(value, dtype, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     返回列表key中指定区间内的元素，区间以偏移量start和stop指定。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="start"></param>
         /// <param name="end"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public IList<T> ListRange<T>(string key, int start, int end, DataType dtype)
         {
             //string cachekey = $"{key}_list_{start}_{end}";
             using (var c = GetReader())
             {
                 IList<T> lst = new List<T>();
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LRANGE);
                     cmd.Add(key);
                     cmd.Add(start.ToString());
                     cmd.Add(end.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         foreach (var item in result.ResultDataBlock)
                         {
                             lst.Add((T)FromRedis(item, dtype, typeof(T)));
                         }
                     }
                 }
                 return lst;
             }
         }

         /// <summary>
         ///     返回列表key中指定区间内的元素，区间以偏移量start和stop指定。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public IList<T> ListRange<T>(string key, DataType dtype)
         {
             return ListRange<T>(key, , -, dtype);
         }

         /// <summary>
         ///     返回列表key中，下标为index的元素。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="index"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public T GetListItem<T>(string key, int index, DataType dtype)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_LINDEX);
                     cmd.Add(key);
                     cmd.Add(index.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return (T)FromRedis(result.ResultDataBlock[], dtype, typeof(T));
                     }
                 }
             }
         }

         /// <summary>
         ///     返回哈希表key中，一个或多个给定域的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="fields"></param>
         /// <param name="type"></param>
         /// <returns>一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。</returns>
         public IList<T> HashGetFields<T>(string key, NameType[] fields, DataType type)
         {
             var result = GetResultSpace<T>(fields.Length);
             NameType item;
             using (var c = GetReader())
             {
                 var inputs = new List<NameType>();
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HMGET);
                     cmd.Add(key);
                     for (var i = ; i < fields.Length; i++)
                     {
                         item = fields[i];
                         inputs.Add(item);
                         item.Index = i;
                         cmd.Add(item.Name);
                     }
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         for (var i = ; i < inputs.Count; i++)
                         {
                             item = inputs[i];
                             result[item.Index] = (T)FromRedis(r.ResultDataBlock[i], type, typeof(T));
                         }
                     }
                 }
             }
             return result;
         }

         /// <summary>
         ///     返回哈希表key中给定域field的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="name"></param>
         /// <param name="type"></param>
         /// <returns>给定域的值。</returns>
         public T HashGet<T>(string key, string name, DataType type)
         {
             T t;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HGET);
                     cmd.Add(key);
                     cmd.Add(name);
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         if (r.ResultDataBlock != null && r.ResultDataBlock.Any())
                         {
                            t = (T)FromRedis(r.ResultDataBlock[], type, typeof(T));
                         }
                         else
                         {
                             t = default(T);
                         }
                     }
                 }
             }
             return t;
         }

         /// <summary>
         ///     返回哈希表key中，所有的域和值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns>以列表形式返回哈希表的域和域的值。 若key不存在，返回空列表。</returns>
         public List<Field> HashGetAll<T>(string key, DataType type)
         {
             var result = new List<Field>();
             var k = "";
             using (var c = GetReader())
             {
                 //var inputs = new List<NameType>();
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HGETALL);
                     cmd.Add(key);
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         if (r.ResultDataBlock.Count > )
                             for (var i = ; i < r.ResultDataBlock.Count; i++)
                             {
                                 if (i %  == )
                                     k = (string)FromRedis(r.ResultDataBlock[i], DataType.String, Type.GetType(k));
                                 else
                                 {
                                     var value = FromRedis(r.ResultDataBlock[i], type, typeof(T));
                                     var item = new Field { Name = k, Value = value };
                                     result.Add(item);
                                 }
                             }
                     }
                 }
             }
             return result;
         }

         /// <summary>
         ///     检查给定key是否存在。
         /// </summary>
         /// <param name="key"></param>
         /// <returns>若key存在，返回1，否则返回0。</returns>
         public int Exists(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_EXISTS);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     查看哈希表key中，给定域field是否存在。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="field"></param>
         /// <param name="type"></param>
         /// <returns>
         ///     如果哈希表含有给定域，返回1。
         ///     如果哈希表不含有给定域，或key不存在，返回0。
         /// </returns>
         public int HashFieldExists(string key, string field, DataType type)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HEXISTS);
                     cmd.Add(key);
                     cmd.Add(field);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回哈希表key中的所有域。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public List<string> HashGetAllFields(string key, DataType type)
         {
             var result = new List<string>();
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HKEYS);
                     cmd.Add(key);
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         if (r.ResultDataBlock.Count > )
                         {
                             result.AddRange(r.ResultDataBlock.Select(t => (string)FromRedis(t, type, typeof(string))));
                         }
                     }
                 }
             }
             return result;
         }
         /// <summary>
         ///     返回哈希表key中的所有值(key-T)
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public List<T> HashGetAllValues<T>(string key, DataType type)
         {
             var result = new List<T>();
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HVALS);
                     cmd.Add(key);
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         if (r.ResultDataBlock?.Count > )
                         {
                             result.AddRange(r.ResultDataBlock.Select(t => (T)FromRedis(t, type, typeof(T))));
                         }
                     }
                 }
             }
             return result;
         }
         /// <summary>
         ///     返回哈希表key中的所有值（key-List<T>）
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public List<T> HashGetAllValuesT<T>(string key, DataType type)
         {
             var result = new List<T>();
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HVALS);
                     cmd.Add(key);
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         if (r.ResultDataBlock.Count > )
                         {
                             foreach (var x in r.ResultDataBlock)
                             {
                               var re= (List<T>) FromRedis(x, type, typeof (List<T>));
                               if(re!=null)result.AddRange(re);
                             }
                            // result.AddRange(r.ResultDataBlock.Select(t => (List<T>)FromRedis(t, type, typeof(List<T>))));
                         }
                     }
                 }
             }
             return result;
         }

         /// <summary>
         ///     返回所有(一个或多个)给定key的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <param name="key"></param>
         /// <param name="key1"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public IList<object> Get<T, T1>(string key, string key1, DataType type)
         {
             return Get(new[] { typeof(T), typeof(T1) }, new[] { key, key1 }, type);
         }

         /// <summary>
         ///     返回所有(一个或多个)给定key的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <param name="key"></param>
         /// <param name="key1"></param>
         /// <param name="key2"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public IList<object> Get<T, T1, T2>(string key, string key1, string key2, DataType type)
         {
             return Get(new[] { typeof(T), typeof(T1), typeof(T2) }, new[] { key, key1, key2 }, type);
         }

         /// <summary>
         ///     返回所有(一个或多个)给定key的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <typeparam name="T3"></typeparam>
         /// <param name="key"></param>
         /// <param name="key1"></param>
         /// <param name="key2"></param>
         /// <param name="key3"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public IList<object> Get<T, T1, T2, T3>(string key, string key1, string key2, string key3, DataType type)
         {
             return Get(new[] { typeof(T), typeof(T1), typeof(T2), typeof(T3) },
                 new[] { key, key1, key2, key3 }, type);
         }

         /// <summary>
         ///     返回所有(一个或多个)给定key的值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <typeparam name="T3"></typeparam>
         /// <typeparam name="T4"></typeparam>
         /// <param name="key"></param>
         /// <param name="key1"></param>
         /// <param name="key2"></param>
         /// <param name="key3"></param>
         /// <param name="key4"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public IList<object> Get<T, T1, T2, T3, T4>(string key, string key1, string key2, string key3, string key4,
             DataType type)
         {
             return Get(new[] { typeof(T), typeof(T1), typeof(T2), typeof(T3), typeof(T4) },
                 new[] { key, key1, key2, key3, key4 }, type);
         }

         /// <summary>
         ///     返回所有(一个或多个)给定key的值。
         /// </summary>
         /// <param name="types"></param>
         /// <param name="keys"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public IList<object> Get(Type[] types, string[] keys, DataType dtype)
         {
             using (var c = GetReader())
             {
                 var result = GetResultSpace<object>(keys.Length);
                 var _types = new List<NameType>();
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_MGET);
                     for (var i = ; i < keys.Length; i++)
                     {
                         var key = keys[i];
                         cmd.Add(key);
                         _types.Add(new NameType(keys[i], i));
                     }
                     using (var r = TcpClient.Send(cmd, c.Client))
                     {
                         for (var i = ; i < _types.Count; i++)
                         {
                             var item = FromRedis(r.ResultDataBlock[i], dtype, null);
                             result[_types[i].Index] = item;
                         }
                     }
                 }
                 return result;
             }
         }

         private List<T> GetResultSpace<T>(int count)
         {
             var result = new List<T>(count);
             for (var i = ; i < count; i++)
             {
                 result.Add(default(T));
             }
             return result;
         }

         /// <summary>
         ///     返回key所关联的字符串值
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public string Get(string key)
         {
             return Get<string>(key, DataType.String);
         }

         /// <summary>
         ///     返回key所关联的字符串值
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public T Get<T>(string key, DataType type)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_GET);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             var value = (T)FromRedis(result.ResultDataBlock[], type, typeof(T));
                             return value;
                         }
                     }
                 }
                 return default(T);
             }
         }

         /// <summary>
         ///     将给定key的值设为value，并返回key的旧值。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <returns></returns>
         public string GetSet(string key, object value)
         {
             return GetSet<string>(key, value, DataType.String);
         }

         /// <summary>
         ///     将给定key的值设为value，并返回key的旧值。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public T GetSet<T>(string key, object value, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_GETSET);
                     cmd.Add(key);

                     ToRedis(value, type, cmd);

                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             var oldvalue = (T)FromRedis(result.ResultDataBlock[], type, typeof(T));
                             return oldvalue;
                         }
                     }
                 }
                 return default(T);
             }
         }

         /// <summary>
         ///     同时将多个field - value(域-值)对设置到哈希表key中。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="name"></param>
         /// <param name="value"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public string SetFields(string key, string name, object value, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HMSET);
                     cmd.Add(key);
                     cmd.Add(name);
                     ToRedis(value, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return result.ResultData.ToString();
                     }
                 }
             }
         }

         /// <summary>
         ///     将哈希表key中的域field的值设为value。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="field"></param>
         /// <param name="value"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public int HashSetFieldValue(string key, string field, object value, DataType type)
         {
             try
             {
                 using (var c = GetWriter())
                 {
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_HSET);
                         cmd.Add(key);
                         cmd.Add(field);
                         ToRedis(value, type, cmd);
                         using (var result = TcpClient.Send(cmd, c.Client))
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             catch (Exception ex)
             {

                 throw;
             }

         }

         /// <summary>
         ///     将哈希表key中的域field的值设置为value，当且仅当域field不存在。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="item"></param>
         /// <param name="type"></param>
         /// <returns>设置成功，返回1。如果给定域已经存在且没有操作被执行，返回0。</returns>
         public int HashSetFieldValueNx(string key, Field item, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HSETNX);
                     cmd.Add(key);
                     cmd.Add(item.Name);
                     ToRedis(item.Value, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     同时设置一个或多个key-value对。
         /// </summary>
         /// <param name="kValues"></param>
         /// <param name="dtype"></param>
         public void MSet(Field[] kValues, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_MSET);
                     foreach (var item in kValues)
                     {
                         cmd.Add(item.Name);
                         ToRedis(item.Value, dtype, cmd);
                     }
                     using (TcpClient.Send(cmd, c.Client))
                     {
                     }
                 }
             }
         }

         /// <summary>
         ///     将key中储存的数字值增一。
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Incr(string key)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_INCR);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将key所储存的值加上增量increment。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="increment"></param>
         /// <returns></returns>
         public long Incrby(string key, long increment)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_INCRBY);
                     cmd.Add(key);
                     cmd.Add(increment.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return long.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将key中储存的数字值减一。
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Decr(string key)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_DECR);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将key所储存的值减去减量decrement。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="decrement"></param>
         /// <returns></returns>
         public long DecrBy(string key, long decrement)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_DECRBY);
                     cmd.Add(key);
                     cmd.Add(decrement.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return long.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将字符串值value关联到key。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="type"></param>
         public void Set(string key, object value, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SET);
                     cmd.Add(key);

                     ToRedis(value, type, cmd);
                     using (TcpClient.Send(cmd, c.Client))
                     {
                     }
                 }
             }
         }

         /// <summary>
         ///     将字符串值value关联到key。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="seconds"></param>
         /// <param name="milliseconds"></param>
         /// <param name="existSet"></param>
         /// <param name="type"></param>
         public void Set(string key, object value, long? seconds, long? milliseconds, bool? existSet, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SET);
                     cmd.Add(key);
                     ToRedis(value, type, cmd);
                     if (seconds != null && seconds > )
                     {
                         cmd.Add("EX");
                         cmd.Add(seconds.ToString());
                     }
                     if (milliseconds != null && milliseconds > )
                     {
                         cmd.Add("PX");
                         cmd.Add(milliseconds.ToString());
                     }
                     if (existSet != null)
                         cmd.Add(Convert.ToBoolean(existSet) ? "XX" : "NX");
                     using (TcpClient.Send(cmd, c.Client))
                     {
                     }
                 }
             }
         }

         /// <summary>
         ///     将key改名为newkey。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public bool Rename(string key, object value, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_RENAME);
                     cmd.Add(key);

                     ToRedis(value, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return result.ResultData.ToString().Contains("OK");
                         }
                     }
                 }
             }
             return false;
         }

         /// <summary>
         ///     将一个或多个member元素及其score值加入到有序集key当中。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="sorts"></param>
         /// <param name="dtype"></param>
         /// <returns>被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。</returns>
         public int Zadd(string key, IEnumerable<SortField> sorts, DataType dtype)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZADD);
                     cmd.Add(key);
                     foreach (var item in sorts)
                     {
                         cmd.Add(item.Name.ToString());
                         ToRedis(item.Value, dtype, cmd);
                     }
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回有序集key的基数。
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Zcard(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZCARD);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="min"></param>
         /// <param name="max"></param>
         /// <returns></returns>
         public int Zcount(string key, int min, int max)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZCOUNT);
                     cmd.Add(key);
                     cmd.Add(min.ToString());
                     cmd.Add(max.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回有序集key中，指定区间内的成员。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="start"></param>
         /// <param name="stop"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public HashSet<string> Zrange(string key, int start, int stop, DataType type)
         {
             HashSet<string> sets = null;
             var value = "";
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZRANGE);
                     cmd.Add(key);
                     cmd.Add(start.ToString());
                     cmd.Add(stop.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             sets = new HashSet<string>();
                             foreach (var currentdata in result.ResultDataBlock)
                             {
                                 value = (string)FromRedis(currentdata, type, Type.GetType(value));
                                 sets.Add(value);
                             }
                         }
                     }
                 }
             }
             return sets;
         }

         /// <summary>
         ///     返回有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。有序集成员按score值递增(从小到大)次序排列。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="min"></param>
         /// <param name="isIncludemin"></param>
         /// <param name="max"></param>
         /// <param name="isIncludemax"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public HashSet<T> ZrangeByScore<T>(string key, long min, bool isIncludemin, int max, bool isIncludemax,
             DataType type)
         {
             var hashSet = new HashSet<T>();
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZRANGEBYSCORE);
                     cmd.Add(key);
                     cmd.Add(isIncludemin ? "" : "(" + min);
                     cmd.Add(isIncludemax ? "" : "(" + max);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             foreach (var currentdata in result.ResultDataBlock)
                             {
                                 var value = (T)FromRedis(currentdata, type, typeof(T));
                                 hashSet.Add(value);
                             }
                         }
                     }
                 }
             }
             return hashSet;
         }

         /// <summary>
         ///     返回有序集key中，指定区间内的成员。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="start"></param>
         /// <param name="stop"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public HashSet<string> Zrevrange(string key, int start, int stop, DataType type)
         {
             HashSet<string> sets = null;
             var value = "";
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZREVRANGE);
                     cmd.Add(key);
                     cmd.Add(start.ToString());
                     cmd.Add(stop.ToString());
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             sets = new HashSet<string>();
                             foreach (var currentdata in result.ResultDataBlock)
                             {
                                 value = (string)FromRedis(currentdata, type, Type.GetType(value));
                                 sets.Add(value);
                             }
                         }
                     }
                 }
             }
             return sets;
         }

         /// <summary>
         ///     返回有序集key中成员member的排名。其中有序集成员按score值递增(从小到大)顺序排列。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <returns></returns>
         public int Zrank(string key, string member)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZRANK);
                     cmd.Add(key);
                     cmd.Add(member);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回有序集key中成员member的排名。其中有序集成员按score值递减(从大到小)排序。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <returns></returns>
         public int Zrevrank(string key, string member)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZREVRANK);
                     cmd.Add(key);
                     cmd.Add(member);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     移除有序集key中的一个或多个成员，不存在的成员将被忽略。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="member"></param>
         public void Zrem(string key, int member)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZREM);
                     cmd.Add(key);
                     cmd.Add(member.ToString());
                     using (TcpClient.Send(cmd, c.Client))
                     {
                     }
                 }
             }
         }

         /// <summary>
         ///     返回有序集key中，成员member的score值。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <returns></returns>
         public int Zscore(string key, string member)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_ZSCORE);
                     cmd.Add(key);
                     cmd.Add(member);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             var value = "";
                             value = (string)FromRedis(result.ResultDataBlock[], DataType.String, Type.GetType(value));
                             return int.Parse(value);
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将一个或多个member元素加入到集合key当中，已经存在于集合的member元素将被忽略。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="members"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public int Sadd<T>(string key, List<T> members, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SADD);
                     cmd.Add(key);
                     foreach (var member in members)
                         ToRedis(member, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     将member元素加入到集合key当中，已经存在于集合的member元素将被忽略。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public int Sadd<T>(string key, T member, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SADD);
                     cmd.Add(key);
                     ToRedis(member, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回集合key的基数(集合中元素的数量)。
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Scard(string key)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SCARD);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     判断member元素是否是集合key的成员。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public bool Sismember<T>(string key, T member, DataType type)
         {
             var r = ;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SISMEMBER);
                     cmd.Add(key);
                     ToRedis(member, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             r = int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return r > ;
         }

         /// <summary>
         ///     返回集合key中的所有成员。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public List<T> Smember<T>(string key, DataType type)
         {
             List<T> sets = null;
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SMEMBERS);
                     cmd.Add(key);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             sets = new List<T>();
                             foreach (var currentdata in result.ResultDataBlock)
                             {
                                 sets.Add((T)FromRedis(currentdata, type, typeof(T)));
                             }
                         }
                     }
                 }
             }
             return sets;
         }

         /// <summary>
         ///     移除集合key中的一个或多个member元素，不存在的member元素会被忽略。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="member"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public int Srem<T>(string key, T member, DataType type)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SREM);
                     cmd.Add(key);
                     ToRedis(member, type, cmd);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultData != null)
                         {
                             return int.Parse(result.ResultData.ToString());
                         }
                     }
                 }
             }
             return ;
         }

         /// <summary>
         ///     返回或保存给定列表、集合、有序集合key中经过排序的元素。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="offset"></param>
         /// <param name="count"></param>
         /// <param name="bYpattern"></param>
         /// <param name="geTpattern"></param>
         /// <param name="alpha"></param>
         /// <param name="storeDestination"></param>
         /// <param name="orderby"></param>
         /// <param name="type"></param>
         /// <param name="dtype"></param>
         /// <returns></returns>
         public IList<object> Sort(string key, int? offset, int? count, string bYpattern, string geTpattern, bool alpha,
             string storeDestination,
             SortOrderType orderby, Type type, DataType dtype)
         {
             var result = new List<object>();
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_SORT);
                     cmd.Add(key);
                     if (!string.IsNullOrEmpty(bYpattern))
                     {
                         cmd.Add("BY");
                         cmd.Add(bYpattern);
                     }
                     if (!string.IsNullOrEmpty(geTpattern))
                     {
                         cmd.Add("GET");
                         cmd.Add(geTpattern);
                     }
                     if (offset != null)
                     {
                         cmd.Add("LIMIT");
                         cmd.Add(offset.Value.ToString());
                         cmd.Add(count == null ? "" : count.Value.ToString());
                     }
                     if (alpha)
                     {
                         cmd.Add("alpha");
                     }
                     cmd.Add(Enum.GetName(typeof(SortOrderType), orderby));
                     if (!string.IsNullOrEmpty(storeDestination))
                     {
                         cmd.Add("STORE");
                         cmd.Add(storeDestination);
                     }
                     using (var rd = TcpClient.Send(cmd, c.Client))
                     {
                         foreach (var item in rd.ResultDataBlock)
                         {
                             result.Add(FromRedis(item, dtype, type));
                         }
                     }
                 }
             }
             return result;
         }

         private void ToRedis(object value, DataType type, Command cmd)
         {
             if (type == DataType.String)
             {
                 cmd.Add((string)value);
             }
             else
             {
                 cmd.AddProtobuf(value);
             }
         }

         private object FromRedis(ArraySegment<byte> data, DataType type, Type otype)
         {
             if (type == DataType.String)
             {
                 return data.GetString();
             }
             else
             {
                 try
                 {
                     return data.GetProtobuf(otype);
                 }
                 catch (Exception exception)
                 {
                     Log.Instance.Error($"{otype} type get error!", exception);
                     return null;
                 }
             }
         }

         #region 订阅与发布

         /// <summary>
         /// 发布消息到指定频道
         /// </summary>
         /// <param name="channel">频道</param>
         /// <param name="message">消息</param>
         /// <returns></returns>
         public object Publish(string channel, string message)
         {
             try
             {
                 using (var c = GetWriter())
                 {
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_PUBLISH);
                         cmd.Add(channel);
                         cmd.Add(message);
                         using (var result = TcpClient.Send(cmd, c.Client))
                         {
                             if (result.ResultData != null)
                             {
                                 return result.ResultData.ToString();
                             }
                         }
                     }
                 }
                 return null;
             }
             catch (Exception ex)
             {
                 throw new Exception("Publish:{0}", ex);
             }
         }

         public void Subscribe(string channelName)
         {
             try
             {
                 using (var c = GetWriter())
                 {
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_SUBSCRIBE);
                         cmd.Add(channelName);
                         using (TcpClient.Send(cmd, c.Client))
                         {
                         }
                     }
                 }
             }
             catch (Exception ex)
             {
                 throw new Exception("Subscribe:{0}", ex);
             }
         }

         public void PSubscribe(string channelName)
         {
             Init(channelName);
             IsPattern = true;
             var thread = new Thread(() => CheckSubscribe(IsPattern));
             thread.Start();
         }

         public void UnSubscribe(string channelName)
         {
             UnSubscribe();
         }

         public void UnPSubscribe(string channelName)
         {
             UnSubscribe();
         }

         private void Init(string channelName)
         {
             ChannelName = channelName;
         }

         private void Run(bool isPattern = false)
         {
             Result repy;
             if (isPattern)
             {
                 using (var c = GetWriter())
                 {
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_PSUBSCRIBE);
                         cmd.Add(ChannelName);
                         repy = TcpClient.Send(cmd, c.Client);
                         while (true)
                         {
                             if (repy.ResultData is object[])
                             {
                                 var val = repy.ResultData as object[];
                                 if (val[].ToString().ToLower().Contains("unsubscribe"))
                                 {
                                     if (OnUnSubscribe != null)
                                         OnUnSubscribe(val);
                                     break;
                                 }
                             }
                             if (OnMessage != null)
                                 OnMessage(this, repy);
                         }
                     }
                 }
             }
             else
             {
                 using (var c = GetWriter())
                 {
                     using (var cmd = new Command())
                     {
                         cmd.Add(ConstValues.REDIS_COMMAND_SUBSCRIBE);
                         cmd.Add(ChannelName);
                         repy = TcpClient.Send(cmd, c.Client);
                         while (true)
                         {
                             if (repy.ResultData is object[])
                             {
                                 var val = repy.ResultData as object[];
                                 if (val[].ToString().ToLower().Contains("unsubscribe"))
                                 {
                                     OnUnSubscribe?.Invoke(val);
                                     break;
                                 }
                             }
                             OnMessage?.Invoke(this, repy);
                         }
                     }
                 }
             }

             OnSuccess?.Invoke((object[])repy.ResultData);
         }

         private void CheckSubscribe(bool isPattern = false)
         {
             try
             {
                 Run(isPattern);
             }
             catch (ThreadAbortException)
             {
             }
             catch (Exception exception)
             {
                 if (OnError != null)
                     OnError(exception);
             }
         }

         private void UnSubscribe()
         {
             try
             {
                 if (IsPattern)
                 {
                     using (var c = GetWriter())
                     {
                         using (var cmd = new Command())
                         {
                             cmd.Add(ConstValues.REDIS_COMMAND_PUNSUBSCRIBE);
                             cmd.Add(ChannelName);
                             TcpClient.Send(cmd, c.Client);
                         }
                     }
                 }
                 else
                 {
                     using (var c = GetWriter())
                     {
                         using (var cmd = new Command())
                         {
                             cmd.Add(ConstValues.REDIS_COMMAND_UNSUBSCRIBE);
                             cmd.Add(ChannelName);
                             TcpClient.Send(cmd, c.Client);
                         }
                     }
                 }
             }
             catch (Exception exception)
             {
                 Debug.Print("Hredis UnSubscribe:" + exception.Message);
             }
         }

         #endregion

         #region 属性

         private int _readHostIndex;

         private int _writeHostIndex;

         /// <summary>
         ///     Redis 读取服务器组
         /// </summary>
         public IList<RedisHost> ReadHosts { get; } = new List<RedisHost>();

         /// <summary>
         ///     Redis 写入服务器组
         /// </summary>
         public IList<RedisHost> WriteHosts { get; } = new List<RedisHost>();

         /// <summary>
         ///     默认客户端
         /// </summary>
         public static RedisClient DefaultDB { get; }

         public int DB { get; set; }

         #endregion

         #region 取得服务器

         /// <summary>
         ///     取得写入服务器
         /// </summary>
         /// <returns></returns>
         public RedisHost.ClientItem GetWriter()
         {
             RedisHost host;
             RedisHost.ClientItem client;
             for (var i = ; i < WriteHosts.Count; i++)
             {
                 host = WriteHosts[_writeHostIndex % WriteHosts.Count];
                 if (host.Available)
                 {
                     client = host.Pop();
                     SelectDB(client.Client);
                     return client;
                 }
                 else
                 {
                     host.Detect();
                 }
                 _writeHostIndex++;
             }

             throw new Exception("write host not Available!");
         }

         /// <summary>
         ///     取得读取服务器
         /// </summary>
         /// <returns></returns>
         public RedisHost.ClientItem GetReader()
         {
             for (var i = ; i < ReadHosts.Count; i++)
             {
                 var host = ReadHosts[_readHostIndex % ReadHosts.Count];
                 if (host.Available)
                 {
                     var client = host.Pop();
                     SelectDB(client.Client);
                     return client;
                 }
                 else
                 {
                     host.Detect();
                 }
                 _readHostIndex++;
             }
             throw new Exception("read host not Available!");
         }

         #endregion

         #region 默认构造

         /// <summary>
         ///     默认构造
         /// </summary>
         public RedisClient()
         {
             Init();
         }

         /// <summary>
         ///     初始化
         /// </summary>
         private void Init()
         {
             if (RedisClientSeting.Current.SingleMode)
             {
                 foreach (var hostStrings in RedisClientSeting.Current.RedisServer)
                 {
                     WriteHosts.Add(new RedisHost(hostStrings.Host, hostStrings.Connections));
                     ReadHosts.Add(new RedisHost(hostStrings.Host, hostStrings.Connections));
                 }
             }
             else
             {
                 foreach (var hostStrings in RedisClientSeting.Current.Writes)
                 {
                     WriteHosts.Add(new RedisHost(hostStrings.Host, hostStrings.Connections));
                 }
                 foreach (var hostStrings in RedisClientSeting.Current.Reads)
                 {
                     ReadHosts.Add(new RedisHost(hostStrings.Host, hostStrings.Connections));
                 }
             }

             DB = RedisClientSeting.Current.DbIndex;
         }

         /// <summary>
         ///     静态构造
         /// </summary>
         static RedisClient()
         {
             DefaultDB = new RedisClient();
         }

         /// <summary>
         ///     静态构造
         /// </summary>
         /// <param name="db">客户端</param>
         /// <returns></returns>
         public static RedisClient GetClient(RedisClient db)
         {
             return db ?? DefaultDB;
         }

         #endregion

         #region Delete

         /// <summary>
         /// </summary>
         /// <param name="keys"></param>
         /// <returns></returns>
         public int Delete(params string[] keys)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_DEL);
                     foreach (var key in keys)
                     {
                         cmd.Add(key);
                     }
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         /// <summary>
         ///     删除哈希表key中的一个或多个指定域，不存在的域将被忽略。
         /// </summary>
         /// <param name="key"></param>
         /// <param name="field"></param>
         /// <returns>被成功移除的域的数量，不包括被忽略的域。</returns>
         public int HDelete(string key, string field)
         {
             using (var c = GetWriter())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_HDEL);
                     cmd.Add(key);
                     cmd.Add(field);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         return int.Parse(result.ResultData.ToString());
                     }
                 }
             }
         }

         #endregion

         public string Info(string para, DataType dtype)
         {
             using (var c = GetReader())
             {
                 using (var cmd = new Command())
                 {
                     cmd.Add(ConstValues.REDIS_COMMAND_INFO);
                     cmd.Add(para);
                     using (var result = TcpClient.Send(cmd, c.Client))
                     {
                         if (result.ResultDataBlock.Count > )
                         {
                             return FromRedis(result.ResultDataBlock[], dtype, null).ToString();
                         }
                     }
                 }
             }
             return string.Empty;
         }
     }

里面涉及到复杂对象的ProtoBuff序列化和内存溢出处理等细节不便多说，需要交流讨论的可以联系我。