.NET中Redis安装部署及使用方法简介

　一Redis服务端以服务方式运行

  1. 修改端口压缩文件中配置的是6488
  2. 修改密码
  3. 修改库的数量
  4.  工具配置安装后如下图
 

　　

　　Redis是一个用的比较广泛的Key/Value的内存数据库，新浪微博、Github、StackOverflow 等大型应用中都用其作为缓存，Redis的官网为http://redis.io/。

　　Redis 是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。 　　Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。 　　Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

　　在这篇文章中我们将记录一下Redis的安装，以及如何在.NET中使用Redis。

　　工具下载位置：http://pan.baidu.com/s/1jILIzLs，包括服务端配置以及查看缓存的工具。

　一、Redis服务端以服务方式运行

　　服务端是以服务的形式运行，将Redis服务端解压到某个目录，然后以管理员方式运行cmd执行命令进行安装：

redis-server.exe --service-install redis.windows.conf --loglevel verbose

　　注意卸载服务的命令为：

redis-server.exe --service-uninstall redis.windows.conf --loglevel verbose

　　注意事项，修改Redis端口及密码的配置在文件redis.windows-service.conf中：（使用redis284.rar中解压文件）

修改端口，压缩文件中配置的是6488：

修改密码

修改库的数量

配置完成后，执行

redis-server.exe --service-install redis.windows.conf --loglevel verbose

到控制面板查看服务已经安装成功了，注意首次安装时默认没有启动，单击启动即可。

 工具配置，安装后如下图

连接成功后，就可以查看缓存中的数据了

　二、Redis服务端以控制台方式运行

　　解压下载的redis64-2.6.12.1.rar文件，如下图：

 　第一步（配置本地服务）

　　点击run这个DOS执行命令
　　因为是自己的电脑测试的，所以这个Redis默认的端口我们就不用修改了，如果到了正式的服务器，一定要修改端口号，防止黑客攻击，获取到你的数据，毕竟信息安全很重要，可以通过它的配置文件来修改。
 
看下用NotePad++打开配置文件，修改过后的效果图，这里我修改成了6380这个端口
这个就是更改过后的效果图了，只要改了端口，再启动run就可以发现端口号确实已经变了，第一步也已经完成了。

第二部（安装和配置客户端）

文件中的“redis-desktop-manager-0.8.2.3849.exe“是2015-11-23 从Redis的官网下载的客户端安装包，如果有更新可以去官网下载最新的Redis，这是链接：http://redis.io/

1.点击客户端安装程序，下一步....，完成打开客户端界面就可以了，省略安装截图。

　　2.打开界面，客户端默认读取到6379的端口，会创建一个6379的Redis服务器

　　由于我更改了6379的端口号，导致Redis客户端默认创建的localhost服务器启动不成功，这里只需要右击修改一下端口号就可以了。

三、C#访问Redis

下载ServiceStack.Redis

和MongoDB一样，在.NET中使用Redis其实也是使用第三方驱动，官网推荐的是使用ServiceStack.Redis 下载后解压得到如下dll

.NET项目中使用Redis

ServerStack中有很多方法可以在.NET中调用，其类结构图如下：

 

Redis公共类库参考

[csharp] view plain copy
 
print?在CODE上查看代码片派生到我的代码片
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4.    
  5. namespace RDIFramework.Utilities  
  6. {  
  7.     using ServiceStack.Redis;  
  8.     using ServiceStack.Redis.Generic;  
  9.    
  10.     /// <summary>  
  11.     /// Redis公共辅助类库  
  12.     /// </summary>  
  13.     public class RedisHelper : IDisposable  
  14.     {  
  15.         public RedisClient Redis = new RedisClient("127.0.0.1", 6379);  
  16.         //缓存池  
  17.         PooledRedisClientManager prcm = new PooledRedisClientManager();  
  18.    
  19.         //默认缓存过期时间单位秒  
  20.         public int secondsTimeOut = 30 * 60;  
  21.    
  22.         /// <summary>  
  23.         /// 缓冲池  
  24.         /// </summary>  
  25.         /// <param name="readWriteHosts"></param>  
  26.         /// <param name="readOnlyHosts"></param>  
  27.         /// <returns></returns>  
  28.         public static PooledRedisClientManager CreateManager(  
  29.          string[] readWriteHosts, string[] readOnlyHosts)  
  30.         {  
  31.             return new PooledRedisClientManager(readWriteHosts, readOnlyHosts,  
  32.                 new RedisClientManagerConfig  
  33.                 {  
  34.                     MaxWritePoolSize = readWriteHosts.Length * 5,  
  35.                     MaxReadPoolSize = readOnlyHosts.Length * 5,  
  36.                     AutoStart = true,  
  37.                 });// { RedisClientFactory = (IRedisClientFactory)RedisCacheClientFactory.Instance.CreateRedisClient("127.0.0.1", 6379) };            
  38.         }  
  39.         /// <summary>  
  40.         /// 构造函数  
  41.         /// </summary>  
  42.         /// <param name="openPooledRedis">是否开启缓冲池</param>  
  43.         public RedisHelper(bool openPooledRedis = false)  
  44.         {  
  45.             if (openPooledRedis)  
  46.             {  
  47.                 prcm = CreateManager(new string[] { "127.0.0.1:6379" }, new string[] { "127.0.0.1:6379" });  
  48.                 Redis = prcm.GetClient() as RedisClient;  
  49.             }  
  50.         }  
  51.    
  52.         #region Key/Value存储  
  53.         /// <summary>  
  54.         /// 设置缓存  
  55.         /// </summary>  
  56.         /// <typeparam name="T"></typeparam>  
  57.         /// <param name="key">缓存建</param>  
  58.         /// <param name="t">缓存值</param>  
  59.         /// <param name="timeout">过期时间，单位秒,-1：不过期，0：默认过期时间</param>  
  60.         /// <returns></returns>  
  61.         public bool Set<T>(string key, T t, int timeout = 0)  
  62.         {  
  63.             if (timeout >= 0)  
  64.             {  
  65.                 if (timeout > 0)  
  66.                 {  
  67.                     secondsTimeOut = timeout;  
  68.                 }  
  69.                 Redis.Expire(key, secondsTimeOut);  
  70.             }  
  71.    
  72.             return Redis.Add<T>(key, t);  
  73.         }  
  74.         /// <summary>  
  75.         /// 获取  
  76.         /// </summary>  
  77.         /// <typeparam name="T"></typeparam>  
  78.         /// <param name="key"></param>  
  79.         /// <returns></returns>  
  80.         public T Get<T>(string key)  
  81.         {  
  82.             return Redis.Get<T>(key);  
  83.         }  
  84.         /// <summary>  
  85.         /// 删除  
  86.         /// </summary>  
  87.         /// <param name="key"></param>  
  88.         /// <returns></returns>  
  89.         public bool Remove(string key)  
  90.         {  
  91.             return Redis.Remove(key);  
  92.         }  
  93.    
  94.         public bool Add<T>(string key, T t, int timeout)  
  95.         {  
  96.             if (timeout >= 0)  
  97.             {  
  98.                 if (timeout > 0)  
  99.                 {  
  100.                     secondsTimeOut = timeout;  
  101.                 }  
  102.                 Redis.Expire(key, secondsTimeOut);  
  103.             }  
  104.             return Redis.Add<T>(key, t);  
  105.         }  
  106.         #endregion  
  107.    
  108.         #region 链表操作  
  109.         /// <summary>  
  110.         /// 根据IEnumerable数据添加链表  
  111.         /// </summary>  
  112.         /// <typeparam name="T"></typeparam>  
  113.         /// <param name="listId"></param>  
  114.         /// <param name="values"></param>  
  115.         /// <param name="timeout"></param>  
  116.         public void AddList<T>(string listId, IEnumerable<T> values, int timeout = 0)  
  117.         {  
  118.             Redis.Expire(listId, 60);  
  119.             IRedisTypedClient<T> iredisClient = Redis.As<T>();  
  120.             if (timeout >= 0)  
  121.             {  
  122.                 if (timeout > 0)  
  123.                 {  
  124.                     secondsTimeOut = timeout;  
  125.                 }  
  126.                 Redis.Expire(listId, secondsTimeOut);  
  127.             }  
  128.             var redisList = iredisClient.Lists[listId];  
  129.             redisList.AddRange(values);  
  130.             iredisClient.Save();  
  131.         }  
  132.         /// <summary>  
  133.         /// 添加单个实体到链表中  
  134.         /// </summary>  
  135.         /// <typeparam name="T"></typeparam>  
  136.         /// <param name="listId"></param>  
  137.         /// <param name="Item"></param>  
  138.         /// <param name="timeout"></param>  
  139.         public void AddEntityToList<T>(string listId, T Item, int timeout = 0)  
  140.         {  
  141.             IRedisTypedClient<T> iredisClient = Redis.As<T>();  
  142.             if (timeout >= 0)  
  143.             {  
  144.                 if (timeout > 0)  
  145.                 {  
  146.                     secondsTimeOut = timeout;  
  147.                 }  
  148.                 Redis.Expire(listId, secondsTimeOut);  
  149.             }  
  150.             var redisList = iredisClient.Lists[listId];  
  151.             redisList.Add(Item);  
  152.             iredisClient.Save();  
  153.         }  
  154.         /// <summary>  
  155.         /// 获取链表  
  156.         /// </summary>  
  157.         /// <typeparam name="T"></typeparam>  
  158.         /// <param name="listId"></param>  
  159.         /// <returns></returns>  
  160.         public IEnumerable<T> GetList<T>(string listId)  
  161.         {  
  162.             IRedisTypedClient<T> iredisClient = Redis.As<T>();  
  163.             return iredisClient.Lists[listId];  
  164.         }  
  165.         /// <summary>  
  166.         /// 在链表中删除单个实体  
  167.         /// </summary>  
  168.         /// <typeparam name="T"></typeparam>  
  169.         /// <param name="listId"></param>  
  170.         /// <param name="t"></param>  
  171.         public void RemoveEntityFromList<T>(string listId, T t)  
  172.         {  
  173.             IRedisTypedClient<T> iredisClient = Redis.As<T>();  
  174.             var redisList = iredisClient.Lists[listId];  
  175.             redisList.RemoveValue(t);  
  176.             iredisClient.Save();  
  177.         }  
  178.         /// <summary>  
  179.         /// 根据lambada表达式删除符合条件的实体  
  180.         /// </summary>  
  181.         /// <typeparam name="T"></typeparam>  
  182.         /// <param name="listId"></param>  
  183.         /// <param name="func"></param>  
  184.         public void RemoveEntityFromList<T>(string listId, Func<T, bool> func)  
  185.         {  
  186.             using (IRedisTypedClient<T> iredisClient = Redis.As<T>())  
  187.             {  
  188.                 var redisList = iredisClient.Lists[listId];  
  189.                 T value = redisList.Where(func).FirstOrDefault();  
  190.                 redisList.RemoveValue(value);  
  191.                 iredisClient.Save();  
  192.             }  
  193.         }  
  194.         #endregion  
  195.         //释放资源  
  196.         public void Dispose()  
  197.         {  
  198.             if (Redis != null)  
  199.             {  
  200.                 Redis.Dispose();  
  201.                 Redis = null;  
  202.             }  
  203.             GC.Collect();  
  204.         }  
  205.     }  
  206. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/itjeff/p/6168827.html