C#实用技能篇

Redis配置文件详解

 

若是不指定配置文件，redis也能够启动，此时，redis使用默认的内置配置。不过在正式环境，经常经过配置文件【一般叫redis.conf】来配置redis。

redis.conf配置格式以下：

 

keyword argument1 argument2 ... argumentN

redis.conf配置参数：

 

1）daemonize on|yes

redis默认不是以守护进程的方式运行，能够经过该配置项修改，使用yes时，启用守护进程

2）pidfile /var/run/redis_6379.pid

redis以守护进程方式运行时，系统默认会把pid写入/var/run/redis.pid，能够经过pidfile指定pid文件

3）port 6379

redis默认监听6379端口，能够经过port指定redis要监听的端口

4）bind 127.0.0.1

绑定主机地址

5）unixsocket /tmp/redis.sock

指定redis监听的unix socket 路径

6）timeout 300

当客户端闲置多长时间，关闭链接，单位秒

7）loglevel verbose|debug|notice|warning

指定日志记录级别，默认是verbose

8）logfile /var/log/redis_6379.log

日志记录文件，默认是标准输出stdout，若是redis以守护进程方式运行，logfile 配置为stdout时，logs将要输出到/dev/null

9)syslog-enabled no|yes

当配置为yes时，日志输出到系统日志，默认是no

10）syslog-ident redis

指定syslog的标示符

11）syslog-facility local0

指定syslog设备(facility)，必须是user或则local0到local7

12）databases 16

设置redis中数据库的个数，默认数据库是DB 0，能够经过select <dbid>，选择使用的数据库。dbis大于等于0，小于等于databases -1 【这里是16-1】

13）save <seconds> <changes>

指定多长时间内，有多少次更新操做时，将数据同步到数据库文件，能够多个条件配合，系统默认配置以下：

 

save 900 1 #900秒 1个修改
save 300 10 #300秒 10个更新
save 60 10000<span style="white-space:pre"> </span>#60秒 10000个更新

注意，若是不持久化【不把数据写入磁盘】，注释掉save便可。 

14）rdbcompression yes|no

 

数据dump到数据文件时，系统是否压缩string对象数据，系统默认是yes。若是为了节省cpu，能够设置为no，此时数据文件比用LZF压缩时要大
15）dbfilename dump.rdb

指定数据库文件名，默认是dump.rdb

16）dir /var/lib/redis/6379

指定本地数据库存放目录

17）slaveof <masterip> <masterport>

当本机是slave服务时，设置master服务的ip和端口

18）masterauth <master-password>

当master服务设置了密码时，slave服务链接master的密码。若是配置不对，slave服务请求将被拒绝

19）slave-serve-stale-data yes|no

当slave和master之间的链接断开或slave正在于master同步时，若是有slave请求，当slave-serve-stale-data配置为yes时，slave能够相应客户端请求；当为no时，slave将要响应错误，默认是yes

20）requirepass foobared

设置redis链接密码

21）maxclients 128

设置同一时间客户端最大链接数，默认是无限制。若是设置maxclients 0 时，表示不限制

22）maxmemory <bytes>

指定redis最大内存限制，redis在启动时，会把数据加载到内存中，达到最大内存后，redis会先清除已到期或将过时的key，仍然到达最大内存设置，将没法再进行写入操做，但仍然能够进行读操做

23）maxmemory-policy volatile-lru|allkeys-lru|volatile-random|allkeys->random|volatile-ttl|noeviction

当redis使用内存达到最大时，使用哪一种策略移除内存中数据

24）appendonly no|yes

指定是否在每次更新操做后进行日志记录，默认配置是no，即在采用异步方式把数据写入到磁盘，若是不开启，可能会在断电时致使部分数据丢失

25）appendfilename appendonly.aof

指定更新日志文件名【aof日志】，默认为appendonly.aof

26）appendfsync everysec|no|aways

指定更新日志条件，no表示等操做系统进行数据缓存同步到磁盘的aof文件（快）always表示每次更新操做后手动调用fsync将数据写到磁盘的aof文件（慢，安全）

everysec，表示每秒同步一次（拆中，默认值）

27）slowlog-log-slower-than 10000

配置记录慢日志的条件，单位是微妙，当是负值时，关闭慢日志记录，当是0时，记录全部操做

28）slowlog-max-len 1024

配置记录慢查询的最大条数

29）hash-max-zipmap-entries 512

配置最大元素数，当超过该配置数据时，redis采用特殊hash算法

30）hash-max-zipmap-value 64

配置最大元素值，当草果配置值时，采用特殊hash算法

31）activerehashing yes

指定是否激活充值hash，默认开启

能够经过下面命令使用配置文件redis.conf启动redis服务

 

Redis安装管理

C#客户端Redis服务器的分布式缓存

在这篇文章中，我想介绍我知道的一种最紧凑的安装和配置Redis服务器的方式。另外，我想简短地概述一下在.NET / C#客户端下Redis hash（哈希类型）和list（链表）的使用。

做者：小峰来源：码农网|2015-08-17 09:48

 收藏

  分享

 

介绍

在这篇文章中，我想介绍我知道的一种最紧凑的安装和配置Redis服务器的方式。另外，我想简短地概述一下在.NET / C#客户端下Redis hash（哈希类型）和list（链表）的使用。

在这篇文章主要讲到：

• 安装Redis服务器（附完整的应用程序文件设置）

• Redis服务器保护（配置身份验证）

• 配置服务器复制

• 从C#应用程序访问缓存

• 使用Redis ASP.NET会话状态

• Redis 集合（Set）、列表（List）和事务处理用法示例

• 说明附加的源（Redis Funq LoC MVC项目：举例）

• 缓存的优化思路

背景

Redis是最快也是功能最丰富的内存Key-Value数据存储系统之一。

缺点

• 没有本地数据缓存（如在Azure缓存同步本地数据缓存）

• 没有彻底集群化的支持（不过，可能今年年末会实现）

优势

• 易于配置

• 使用简单

• 高性能

• 支持不一样的数据类型（如hash（哈希类型）、list（链表）、set（集合）、sorted set（有序集））

• ASP.NET会话集成

• Web UI用于浏览缓存内容

下面我将简单说明如何在服务器上安装和配置Redis，并用C#使用它。

Redis的安装

从https://github.com/dmajkic/redis/downloads（win32 win64直接连接）下载二进制文件，解包档案到应用程序目录（如C：\Program Files\Redis）

下载从https://github.com/kcherenkov/redis-windows-service/downloads编译的Redis服务，而后复制到程序文件夹（如C：\Program Files\Redis）。若是配置文件丢失，也能够下载复制到应用程序目录。有效的Redis配置文件的范例在https://raw.github.com/antirez/redis/2.6/redis.conf。

Redis应用程序的完整文件也能够从压缩文件（x64）获得。

当你拥有了全套的应用程序文件（以下图所示），

导航到应用程序目录，而后运行如下命令：

sc create %name% binpath= "\"%binpath%\" %configpath%" start= "auto" DisplayName= "Redis"

其中：

• %name%——服务实例的名称，例如：redis-instance；

• %binpath%——到项目exe文件的路径，例如：C：\Program Files\Redis\RedisService_1.1.exe；

• %configpath%——到Redis配置文件的路径，例如：C：\Program Files\Redis\redis.conf；

举例：

sc create Redis start= auto DisplayName= Redis binpath= "\"C:\Program Files\Redis\RedisService_1.1.exe\
" \"C:\Program Files\Redis\redis.conf\""

即应该是这样的：

请确保有足够的权限启动该服务。安装完毕后，请检查该服务是否建立成功，当前是否正在运行：

或者，你可使用安装程序（我没试过）：https://github.com/rgl/redis/downloads。

Redis服务器保护：密码，IP过滤

保护Redis服务器的主要方式是使用Windows防火墙或活跃的网络链接属性设置IP过滤。此外，还可使用Redis密码设置额外保护。这须要用下面的方式更新Redis配置文件（redis.conf）：

首先，找到这行：

# requirepass foobared

删除开头的#符号，用新密码替换foobared：

requirepass foobared

而后，从新启动Redis Windows服务！

当具体使用客户端的时候，使用带密码的构造函数：

RedisClient client = new RedisClient(serverHost, port, redisPassword);

Redis服务器复制（主—从配置）

Redis支持主从同步，即，每次主服务器修改，从服务器获得通知，并自动同步。大多复制用于读取（但不能写）扩展和数据冗余和服务器故障转移。设 置两个Redis实例（在相同或不一样服务器上的两个服务），而后配置其中之一做为从站。为了让Redis服务器实例是另外一台服务器的从属，能够这样更改配 置文件：

找到如下代码：

# slaveof <masterip> <masterport>

替换为：

slaveof 192.168.1.1 6379

（能够自定义指定主服务器的真实IP和端口）。若是主服务器配置为须要密码（验证），能够以下所示改变redis.conf，找到这一行代码：

# masterauth <master-password>

删除开头的#符号，用主服务器的密码替换<master-password>，即：

masterauth mastpassword

如今这个Redis实例能够被用来做为主服务器的只读同步副本。

用C#代码使用Redis缓存

用C#代码使用Redis运行Manage NuGet包插件，找到ServiceStack.Redis包，并进行安装。

直接从实例化客户端使用Set/Get方法示例：

string host = "localhost";
string elementKey = "testKeyRedis";

using (RedisClient redisClient = new RedisClient(host))
{
      if (redisClient.Get<string>(elementKey) == null)
      {
           // adding delay to see the difference
           Thread.Sleep(5000);
           // save value in cache
           redisClient.Set(elementKey, "some cached value");
      }
      // get value from the cache by key
      message = "Item value is: " + redisClient.Get<string>("some cached value");
}

类型化实体集更有意思和更实用，这是由于它们操做的是确切类型的对象。在下面的代码示例中，有两个类分别定义为Phone和Person——phone的主人。每一个phone实例引用它的主人。下面的代码演示咱们如何经过标准添加、删除和发现缓存项：

public class Phone
{
   public int Id { get; set; }
   public string Model { get; set; }
   public string Manufacturer { get; set; }
   public Person Owner { get; set; }
}

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Surname { get; set; }
    public int Age { get; set; }
    public string Profession { get; set; }
}

using (RedisClient redisClient = new RedisClient(host))
{
     IRedisTypedClient<phone> phones = redisClient.As<phone>();
     Phone phoneFive = phones.GetValue("5");
     if (phoneFive == null)
     {
          // make a small delay
          Thread.Sleep(5000);
          // creating a new Phone entry
          phoneFive = new Phone
          {
               Id = 5,
               Manufacturer = "Motorolla",
               Model = "xxxxx",
               Owner = new Person
               {
                    Id = 1,
                    Age = 90,
                    Name = "OldOne",
                    Profession = "sportsmen",
                    Surname = "OldManSurname"
               }
          };
          // adding Entry to the typed entity set
          phones.SetEntry(phoneFive.Id.ToString(), phoneFive);
     }
     message = "Phone model is " + phoneFive.Manufacturer;
     message += "Phone Owner Name is: " + phoneFive.Owner.Name;
}

在上面的例子中，咱们实例化了输入端IRedisTypedClient，它与缓存对象的特定类型——Phone类型一块儿工做。

Redis ASP.NET会话状态

要用Redis提供商配置ASP.NET会话状态，添加新文件到你的Web项目，命名为RedisSessionStateProvider.cs，能够从https://github.com/chadman/redis-service-provider/raw/master/RedisProvider/SessionProvider/RedisSessionProvider.cs复制代码，而后添加或更改配置文件中的如下部分（sessionState标签已经内置于system.web标签），或者你也能够下载附加来源和复制代码。

<sessionstate timeout="1" mode="Custom"
customprovider="RedisSessionStateProvider" cookieless="false">
      <providers>
        <add name="RedisSessionStateProvider" writeexceptionstoeventlog="false"
        type="RedisProvider.SessionProvider.CustomServiceProvider"
        server="localhost" port="6379" password="pasword">
      </add> </providers>
</sessionstate>

注意，此密码是能够选择的，看服务器是否须要认证。它必须被真实的值替换或删除，若是Redis服务器不须要身份验证，那么服务器属性和端口得由具体的数值代替（默认端口为6379）。而后在项目中，你才可使用会话状态：

// in the Global.asax
public class MvcApplication1 : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        //....
    }

    protected void Session_Start()
    {
        Session["testRedisSession"] = "Message from the redis ression";
    }
}

在Home controller（主控制器）：

public class HomeController : Controller
{
    public ActionResult Index()
    {
       //...
       ViewBag.Message = Session["testRedisSession"];
       return View();
    }
//...
}

结果：

ASP.NET输出缓存提供者，而且Redis能够用相似的方式进行配置。

Redis Set（集合）和List（列表）

主要要注意的是，Redis列表实现IList<T>，而Redis集合实现ICollection<T>。下面来讲说如何使用它们。

当须要区分相同类型的不一样分类对象时，使用列表。例如，咱们有“mostSelling（热销手机）”和“oldCollection（回收手机）”两个列表：

string host = "localhost";
using (var redisClient = new RedisClient(host))
{
    //Create a 'strongly-typed' API that makes all Redis Value operations to apply against Phones
    IRedisTypedClient<phone> redis = redisClient.As<phone>();

    IRedisList<phone> mostSelling = redis.Lists["urn:phones:mostselling"];
    IRedisList<phone> oldCollection = redis.Lists["urn:phones:oldcollection"];

    Person phonesOwner = new Person
        {
            Id = 7,
            Age = 90,
            Name = "OldOne",
            Profession = "sportsmen",
            Surname = "OldManSurname"
        };

    // adding new items to the list
    mostSelling.Add(new Phone
            {
                Id = 5,
                Manufacturer = "Sony",
                Model = "768564564566",
                Owner = phonesOwner
            });

    oldCollection.Add(new Phone
            {
                Id = 8,
                Manufacturer = "Motorolla",
                Model = "324557546754",
                Owner = phonesOwner
            });

    var upgradedPhone  = new Phone
    {
        Id = 3,
        Manufacturer = "LG",
        Model = "634563456",
        Owner = phonesOwner
    };

    mostSelling.Add(upgradedPhone);

    // remove item from the list
    oldCollection.Remove(upgradedPhone);

    // find objects in the cache
    IEnumerable<phone> LGPhones = mostSelling.Where(ph => ph.Manufacturer == "LG");

    // find specific
    Phone singleElement = mostSelling.FirstOrDefault(ph => ph.Id == 8);

    //reset sequence and delete all lists
    redis.SetSequence(0);
    redisClient.Remove("urn:phones:mostselling");
    redisClient.Remove("urn:phones:oldcollection");
}

当须要存储相关的数据集和收集统计信息，例如answer -> queustion给答案或问题投票时，Redis集合就很是好使。假设咱们有不少的问题（queustion）和答案（answer ），须要将它们存储在缓存中。使用Redis，咱们能够这么作：

/// <summary>
/// Gets or sets the Redis Manager. The built-in IoC used with ServiceStack autowires this property.
/// </summary>
IRedisClientsManager RedisManager { get; set; }
/// <summary>
/// Delete question by performing compensating actions to
/// StoreQuestion() to keep the datastore in a consistent state
/// </summary>
/// <param name="questionId">
public void DeleteQuestion(long questionId)
{
    using (var redis = RedisManager.GetClient())
    {
        var redisQuestions = redis.As<question>();

        var question = redisQuestions.GetById(questionId);
        if (question == null) return;

        //decrement score in tags list
        question.Tags.ForEach(tag => redis.IncrementItemInSortedSet("urn:tags", tag, -1));

        //remove all related answers
        redisQuestions.DeleteRelatedEntities<answer>(questionId);

        //remove this question from user index
        redis.RemoveItemFromSet("urn:user>q:" + question.UserId, questionId.ToString());

        //remove tag => questions index for each tag
        question.Tags.ForEach("urn:tags>q:" + tag.ToLower(), questionId.ToString()));

        redisQuestions.DeleteById(questionId);
    }
}

public void StoreQuestion(Question question)
{
    using (var redis = RedisManager.GetClient())
    {
        var redisQuestions = redis.As<question>();

        if (question.Tags == null) question.Tags = new List<string>();
        if (question.Id == default(long))
        {
            question.Id = redisQuestions.GetNextSequence();
            question.CreatedDate = DateTime.UtcNow;

            //Increment the popularity for each new question tag
            question.Tags.ForEach(tag => redis.IncrementItemInSortedSet("urn:tags", tag, 1));
        }

        redisQuestions.Store(question);
        redisQuestions.AddToRecentsList(question);
        redis.AddItemToSet("urn:user>q:" + question.UserId, question.Id.ToString());

        //Usage of tags - Populate tag => questions index for each tag
        question.Tags.ForEach(tag => redis.AddItemToSet
        ("urn:tags>q:" + tag.ToLower(), question.Id.ToString()));
    }
}

/// <summary>
/// Delete Answer by performing compensating actions to
/// StoreAnswer() to keep the datastore in a consistent state
/// </summary>
/// <param name="questionId">
/// <param name="answerId">
public void DeleteAnswer(long questionId, long answerId)
{
    using (var redis = RedisManager.GetClient())
    {
        var answer = redis.As<question>().GetRelatedEntities<answer>
        (questionId).FirstOrDefault(x => x.Id == answerId);
        if (answer == null) return;

        redis.As<question>().DeleteRelatedEntity<answer>(questionId, answerId);

        //remove user => answer index
        redis.RemoveItemFromSet("urn:user>a:" + answer.UserId, answerId.ToString());
    }
}

public void StoreAnswer(Answer answer)
{
    using (var redis = RedisManager.GetClient())
    {
        if (answer.Id == default(long))
        {
            answer.Id = redis.As<answer>().GetNextSequence();
            answer.CreatedDate = DateTime.UtcNow;
        }

        //Store as a 'Related Answer' to the parent Question
        redis.As<question>().StoreRelatedEntities(answer.QuestionId, answer);
        //Populate user => answer index
        redis.AddItemToSet("urn:user>a:" + answer.UserId, answer.Id.ToString());
    }
}

public List<answer> GetAnswersForQuestion(long questionId)
{
    using (var redis = RedisManager.GetClient())
    {
        return redis.As<question>().GetRelatedEntities<answer>(questionId);
    }
}

public void VoteQuestionUp(long userId, long questionId)
{
    //Populate Question => User and User => Question set indexes in a single transaction
    RedisManager.ExecTrans(trans =>
    {
        //Register upvote against question and remove any downvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:q>user+:" + questionId, userId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:q>user-:" + questionId, userId.ToString()));

        //Register upvote against user and remove any downvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:user>q+:" + userId, questionId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:user>q-:" + userId, questionId.ToString()));
    });
}

public void VoteQuestionDown(long userId, long questionId)
{
    //Populate Question => User and User => Question set indexes in a single transaction
    RedisManager.ExecTrans(trans =>
    {
        //Register downvote against question and remove any upvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:q>user-:" + questionId, userId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:q>user+:" + questionId, userId.ToString()));

        //Register downvote against user and remove any upvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet"urn:user>q-:" + userId, questionId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:user>q+:" + userId, questionId.ToString()));
    });
}

public void VoteAnswerUp(long userId, long answerId)
{
    //Populate Question => User and User => Question set indexes in a single transaction
    RedisManager.ExecTrans(trans =>
    {
        //Register upvote against answer and remove any downvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:a>user+:" + answerId, userId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:a>user-:" + answerId, userId.ToString()));

        //Register upvote against user and remove any downvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:user>a+:" + userId, answerId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:user>a-:" + userId, answerId.ToString()));
    });
}

public void VoteAnswerDown(long userId, long answerId)
{
    //Populate Question => User and User => Question set indexes in a single transaction
    RedisManager.ExecTrans(trans =>
    {
        //Register downvote against answer and remove any upvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:a>user-:" + answerId, userId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:a>user+:" + answerId, userId.ToString()));

        //Register downvote against user and remove any upvotes if any
        trans.QueueCommand(redis =>
        redis.AddItemToSet("urn:user>a-:" + userId, answerId.ToString()));
        trans.QueueCommand(redis =>
        redis.RemoveItemFromSet("urn:user>a+:" + userId, answerId.ToString()));
    });
}

public QuestionResult GetQuestion(long questionId)
{
    var question = RedisManager.ExecAs<question>
    (redisQuestions => redisQuestions.GetById(questionId));
    if (question == null) return null;

    var result = ToQuestionResults(new[] { question })[0];
    var answers = GetAnswersForQuestion(questionId);
    var uniqueUserIds = answers.ConvertAll(x => x.UserId).ToHashSet();
    var usersMap = GetUsersByIds(uniqueUserIds).ToDictionary(x => x.Id);

    result.Answers = answers.ConvertAll(answer =>
        new AnswerResult { Answer = answer, User = usersMap[answer.UserId] });

    return result;
}

public List<user> GetUsersByIds(IEnumerable<long> userIds)
{
    return RedisManager.ExecAs<user>(redisUsers => redisUsers.GetByIds(userIds)).ToList();
}

public QuestionStat GetQuestionStats(long questionId)
{
    using (var redis = RedisManager.GetReadOnlyClient())
    {
        var result = new QuestionStat
        {
            VotesUpCount = redis.GetSetCount("urn:q>user+:" +questionId),
            VotesDownCount = redis.GetSetCount("urn:q>user-:" + questionId)
        };
        result.VotesTotal = result.VotesUpCount - result.VotesDownCount;
        return result;
    }
}

public List<tag> GetTagsByPopularity(int skip, int take)
{
    using (var redis = RedisManager.GetReadOnlyClient())
    {
        var tagEntries = redis.GetRangeWithScoresFromSortedSetDesc("urn:tags", skip, take);
        var tags = tagEntries.ConvertAll(kvp => new Tag { Name = kvp.Key, Score = (int)kvp.Value });
        return tags;
    }
}

public SiteStats GetSiteStats()
{
    using (var redis = RedisManager.GetClient())
    {
        return new SiteStats
        {
            QuestionsCount = redis.As<question>().TypeIdsSet.Count,
            AnswersCount = redis.As<answer>().TypeIdsSet.Count,
            TopTags = GetTagsByPopularity(0, 10)
        };
    }
}

附加资源说明

项目中引用的一些包在packages.config文件中配置。

Funq IoC的相关配置，以及注册类型和当前控制器目录，在Global.asax文件中配置。

基于IoC的缓存使用以及Global.asax能够打开如下URL：http://localhost:37447/Question/GetQuestions?tag=test 查看。

你能够将tag字段设置成test3，test1，test2等。

Redis缓存配置——在web config文件（<system.web><sessionState>节点）以及RedisSessionStateProvider.cs文件中。

在MVC项目中有不少待办事项，所以，若是你想改进/继续，请更新，并上传。

若是有人能提供使用Redis（以及Funq IOC）缓存的MVC应用程序示例，本人将不胜感激。Funq IOC已经配置，使用示例已经在Question controller中。

注：部分取样于“ServiceStack.Examples-master”解决方案。

结论。优化应用程序缓存以及快速本地缓存

因为Redis并不在本地存储（也不在本地复制）数据，那么经过在本地缓存区存储一些轻量级或用户依赖的对象（跳过序列化字符串和客户端—服务端数据转换）来优化性能是有意义的。例如，在Web应用中，对于轻量级的对象使用’System.Runtime.Caching.ObjectCache‘ 会更好——用户依赖，而且应用程序时常要用。不然，当常常性地须要使用该对象时，就必须在分布式Redis缓存中存储大量容积的内容。用户依赖的对象举例——我的资料信息，个性化信息 。经常使用对象——本地化数据，不一样用户之间的共享信息，等等。

下载源代码（Redis Funq LoC MVC 4版本）

连接

如何运行Redis服务：

https://github.com/kcherenkov/redis-windows-service

文档：

http://redis.io/documentation

.NET / C#示例：

https://github.com/ServiceStack/ServiceStack.Examples

关于如何用C＃在Windows上使用Redis的好建议：

http://maxivak.com/getting-started-with-redis-and-asp-net-mvc-under-windows/：

http://www.piotrwalat.net/using-redis-with-asp-net-web-api/

关于Redis：

https://github.com/ServiceStack/ServiceStack.Redis

Azure缓存

http://kotugoroshko.blogspot.ae/2013/07/windows-azure-caching-integration.html

许可证

这篇文章，以及任何相关的源代码和文件，依据The Code Project Open License (CPOL)。

译文连接：http://www.codeceo.com/article/distributed-caching-redis-server.html
英文原文：Distributed Caching using Redis Server with .NET/C# Client

 

园内博客简单安装Redis方法

windows下安装redis

一、redis简介
redis是一个key-value存储系统。和Memcached相似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hashs（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操做，并且这些操做都是原子性的。在此基础上，redis支持各类不一样方式的排序。与memcached同样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操做写入追加的记录文件，而且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合能够对关系数据库起到很好的补充做用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

二、windows下安装redis
下载地址https://github.com/dmajkic/redis/downloads。下载到的Redis支持32bit和64bit。根据本身实际状况选择，我选择32bit。把32bit文件内容拷贝到须要安装的目录下,好比：D:\dev\redis-2.4.5。

打开一个cmd窗口，使用cd命令切换到指定目录（D:\dev\redis-2.4.5）运行 redis-server.exe redis.conf 。运行之后出现以下界面。

这就说明Redis服务端已经安装成功。

从新打开一个cmd窗口，使用cd命令切换到指定目录（D:\dev\redis-2.4.5）运行 redis-cli.exe -h 127.0.0.1 -p 6379 -a 123456，其中 127.0.0.1是本地ip，6379是redis服务端的默认端口,123456是redis密码。运行成功以下图所示。
这样，Redis windows环境下搭建已经完成，是否是很简单。

这样，Redis windows环境下搭建已经完成，是否是很简单。

环境已经搭建好，总得测试下吧。好比：存储一个key为test，value为hello word的字符串，而后获取key值。
正确输出 hell word，测试成功！