Redis在.net 环境下的使用

redis概念

        redis是一个开源的使用ansi c语言编写、支持网络、可基于内存亦可持久化的日志型、key-value数据库，和memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

        redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。

redis 与 memcached 区别

• memcached是多线程，而redis使用单线程。(个人认为memcached在读写处理速度上由于redis)
• memcached使用预分配的内存池的方式，redis使用现场申请内存的方式来存储数据，并且可以配置虚拟内存。
• redis可以实现持久化(也就是说redis需要经常将内存中的数据同步到硬盘中来保证持久化)，主从复制，实现故障恢复。
• memcached只是简单的key与value,但是redis支持数据类型比较多。包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。

redis支持两种持久化方式：

   (1):snapshotting(快照)也是默认方式.(把数据做一个备份，将数据存储到文件)

   (2)append-only file(缩写aof)的方式 

   快照是默认的持久化方式，这种方式是将内存中数据以快照的方式写到二进制文件中，默认的文件名称为dump.rdb.可以通过配置设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key键修改就自动做快照.

   aof方式:由于快照方式是在一定间隔时间做一次的，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。aof比快照方式有更好的持久化性，是由于在使用aof时，redis会将每一个收到的写命令都通过write函数追加到文件中，当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。 

windows环境下redis的安装

windows版本redis下载地址：

redis服务端安装  

点击安装文件安装以后，打开本地服务管理器，并启动redis相关服务

 

 

打开redis的安装目录文件

用vs打开 redis.windows-service.conf 可以看到相关配置，如redis服务的端口信息

 

 

 

 

在.net开发环境（客户端）中使用 redis

 我们创建一个项目，控制台程序或者web程序都可以。然后通过vs的nuget程序包管理工具安装  stackexchange.redis 包

 

安装以后创建一个 redishelper.cs 帮助类，帮助类代码如下：

    /// <summary>
    /// redis读写帮助类
    /// </summary>
    public class redishelper
    {
        private string redisconnectionstr = configurationmanager.appsettings["redisconnectionstr"];
        private connectionmultiplexer redis { get; set; }
        private idatabase db { get; set; }
        public redishelper()
        {
            redis = connectionmultiplexer.connect(redisconnectionstr);
            db = redis.getdatabase();
        }
        #region string类型操作
        /// <summary>
        /// set or update the value for string key 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool setstringvalue(string key, string value)
        {
            return db.stringset(key, value);
        }
        /// <summary>
        /// 保存单个key value
        /// </summary>
        /// <param name="key">redis key</param>
        /// <param name="value">保存的值</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool setstringkey(string key, string value, timespan? expiry = default(timespan?))
        {
            return db.stringset(key, value, expiry);
        }
        /// <summary>
        /// 保存一个对象
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool setstringkey<t>(string key, t obj, timespan? expiry = default(timespan?))
        {
            string json = jsonhelper.serializeobject(obj);
            return db.stringset(key, json, expiry);
        }
        /// <summary>
        /// 获取一个key的对象
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public t getstringkey<t>(string key) where t : class
        {
           var result= db.stringget(key);
            if (string.isnullorempty(result))
            {
                return null;
            }
            try
            {
                return jsonhelper.deserializeobject<t>(result);
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// get the value for string key 
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string getstringvalue(string key)
        {
            return db.stringget(key);
        }

        /// <summary>
        /// delete the value for string key 
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool deletestringkey(string key)
        {
            return db.keydelete(key);
        }
        #endregion

        #region 哈希类型操作
        /// <summary>
        /// set or update the hashvalue for string key 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashkey"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool sethashvalue(string key, string hashkey, string value)
        {
            return db.hashset(key, hashkey, value);
        }
        /// <summary>
        /// set or update the hashvalue for string key 
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashkey"></param>
        /// <param name="t">defined class</param>
        /// <returns></returns>
        public bool sethashvalue<t>(string key, string hashkey, t t) where t : class
        {
            var json = jsonhelper.serializeobject(t);
            return db.hashset(key, hashkey, json);
        }
        /// <summary>
        /// 保存一个集合
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="key">redis key</param>
        /// <param name="list">数据集合</param>
        /// <param name="getmodelid"></param>
        public void hashset<t>(string key, list<t> list, func<t, string> getmodelid)
        {
            list<hashentry> listhashentry = new list<hashentry>();
            foreach (var item in list)
            {
                string json = jsonhelper.serializeobject(item);
                listhashentry.add(new hashentry(getmodelid(item), json));
            }
            db.hashset(key, listhashentry.toarray());
        }
        /// <summary>
        /// 获取hashkey所有的值
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public list<t> hashgetall<t>(string key) where t : class
        {
            list<t> result = new list<t>();
            hashentry[] arr = db.hashgetall(key);
            foreach (var item in arr)
            {
                if (!item.value.isnullorempty)
                {
                    t t;
                    if (jsonhelper.deserializejsontoobject<t>(item.value,out t))
                    {
                        result.add(t);
                    }
                   
                }
            }
            return result;
            //result =jsonhelper.deserializejsontolist<t>(arr.tostring());                        
            //return result;
        }
        /// <summary>
        /// get the hashvalue for string key  and hashkey
        /// </summary>
        /// <param name="key">represents a key that can be stored in redis</param>
        /// <param name="hashkey"></param>
        /// <returns></returns>
        public redisvalue gethashvalue(string key, string hashkey)
        {
            redisvalue result = db.hashget(key, hashkey);
            return result;
        }
        /// <summary>
        /// get the hashvalue for string key  and hashkey
        /// </summary>
        /// <param name="key">represents a key that can be stored in redis</param>
        /// <param name="hashkey"></param>
        /// <returns></returns>
        public t gethashvalue<t>(string key, string hashkey) where t : class
        {
            redisvalue result = db.hashget(key, hashkey);
            if (string.isnullorempty(result))
            {
                return null;
            }
            t t;
            if (jsonhelper.deserializejsontoobject<t>(result,out t))
            {
                return t;
            }
            return null;         
        }
        /// <summary>
        /// delete the hashvalue for string key  and hashkey
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashkey"></param>
        /// <returns></returns>
        public bool deletehashvalue(string key, string hashkey)
        {
            return db.hashdelete(key, hashkey);
        }
        #endregion
    }

写一个方法来测试使用redis

namespace redisdemo.controllers
{
    public class homecontroller : controller
    {
        public actionresult index()
        {

            redishelper redis = new redishelper();
            redis.setstringkey("name", "ccc");
            string name= redis.getstringvalue("name");
            redis.setstringkey<list<string>>("list", new list<string> { "dada", "daccz", "ccc" });
            return view();
        }
    }
}

 

 我们分别插入了一个string类型和list类型的数据

然后通过redis的客户端工具来看看是否能获取到刚才插入的数据