ServiceStack.Redis

Redis 官网  
Redis Commands(命令)  
Redis 命令中心（Redis commands） -- Redis中国用户组（CRUG）  
Redis 中文网  
腾讯云 云数据库 Redis
Redis 命令参考（红色）
Redis 命令参考（蓝色）
Redis 数据库学习教程
Redis 菜鸟教程 

StackExchange.Redis 
redis默认16个数据库，如何选择将数据写入哪个数据库呢？
var db = conn.GetDatabase(); //在Redis中获得与数据库的交互式连接
该语句连接数据库，括号为空默认写入db0
var db = conn.GetDatabase(6)；即可将数据写入db6数据库

CSRedis 
var redisClient = new CSRedis.CSRedisClient("localhost:6379,password=1q2w3E*,defaultDatabase=1,ssl=false,writeBuffer=10240");

ServiceStack.Redis.PooledRedisClientManager：连接池管理类
ServiceStack.Redis.RedisClientManagerConfig：
ServiceStack.Redis.IRedisClientsManager
ServiceStack.Redis.IRedisTransaction：事务
ServiceStack.Redis.Pipeline.IRedisPipeline：管道
ServiceStack.Redis.RedisPubSubServer：发布
ServiceStack.Redis.IRedisSubscription：订阅
ServiceStack.Redis.RedisConfig：
ServiceStack.Redis.IRedisClient：
ServiceStack.Redis.IRedisClient.AcquireLock：锁
ServiceStack.Redis.RedisEndpoint：
*
1、管理 NuGet 添加引用
     ServiceStack.Redis

2、RedisHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ServiceStack.Redis;

namespace Test.CoreLibrary
{
    public class RedisHelper
    {
        public List<string> HostPort { get; set; }

        private string[] SplitString(string strSource, string split)
        {
            return strSource.Split(split.ToArray());
        }

        /// <summary>
        /// 自增的开始数值
        /// </summary>
        public int Begin { get; set; }

        private PooledRedisClientManager redisPoolManager;

        /// <summary>
        /// 客户端缓存操作对象
        /// </summary>
        public IRedisClient RedisClient
        {
            get
            {
                if (redisPoolManager == null)
                {
                    #region 方式1（复杂）
                    //string[] WriteServerConStr = SplitString("", ",");
                    //string[] ReadServerConStr = SplitString("", ",");
                    //redisPoolManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr,
                    //                 new RedisClientManagerConfig
                    //                 {
                    //                     MaxWritePoolSize = 5,
                    //                     MaxReadPoolSize = 5,
                    //                     AutoStart = true,
                    //                 });
                    #endregion

                    #region 方式2（简单）
                    redisPoolManager = new PooledRedisClientManager(HostPort.ToArray());
                    #endregion
                }
                return redisPoolManager.GetClient();
            }
        }

        /// <summary>
        /// 返回一个在指定过期时间内自动累加的唯一序列号
        /// </summary>
        /// <param name="key"></param>
        /// <param name="timeout">过期时间：分钟</param>
        /// <returns></returns>
        public long GetUniqueNumByTimeout(string key, int timeout)
        {
            using (var client = RedisClient)
            {
                var count = client.IncrementValue(key);
                if (count == 1)
                {
                    client.ExpireEntryIn(key, new TimeSpan(0, 0, timeout, 0));
                }

                return count;
            }
        }

        /// <summary>
        /// 设置key的value并设置过期时间
        /// </summary>
        public void Set(string key, string value, DateTime dt)
        {
            using (var client = RedisClient)
            {
                client.Set<string>(key, value, dt);
            }
        }

        /// <summary>
        /// 写入键值缓存，设置key的value并设置过期时间
        /// </summary>
        public void Set<T>(string key, T value, int timeout)
        {
            using (var client = RedisClient)
            {
                if (timeout <= 0)
                {
                    client.Set(key, value);
                }
                else
                {
                    client.Set(key, value, new TimeSpan(0, 0, timeout));
                }
            }
        }

        /// <summary>
        /// 设置多个key/value
        /// </summary>
        public void Set(Dictionary<string, string> dic)
        {
            using (var client = RedisClient)
            {
                client.SetAll(dic);
            }
        }

        public void Set<T>(string key, T value)
        {
            using (var client = RedisClient)
            {
                client.Set(key, value);
            }
        }

        /// <summary>
        /// 获取键值缓存
        /// </summary>
        public T Get<T>(string key)
        {
            using (var client = RedisClient)
            {
                return client.Get<T>(key);
            }
        }

        /// <summary>
        /// 在原有key的value值之后追加value
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Append(string key, string value)
        {
            using (var client = RedisClient)
            {
                client.AppendToValue(key, value);
            }
        }

        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public List<string> Get(List<string> keys)
        {
            using (var client = RedisClient)
            {
                return client.GetValues(keys);
            }
        }

        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys"></param>
        /// <returns></returns>
        public List<T> Get<T>(List<string> keys)
        {
            using (var client = RedisClient)
            {
                return client.GetValues<T>(keys);
            }
        }

        /// <summary>
        /// 获取旧值赋上新值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public string GetAndSetValue(string key, string value)
        {
            using (var client = RedisClient)
            {
                return client.GetAndSetValue(key, value);
            }
        }

        #region 获取自增计数
        /// <summary>
        /// 获取自增计数
        /// </summary>
        /// <param name="key"></param>
        /// <param name="timeout">分钟</param>
        /// <returns></returns>
        public long GetIncr(string key, int timeout)
        {
            using (var client = RedisClient)
            {
                client.ExpireEntryIn(key, new TimeSpan(0, timeout, 0));
                return client.IncrementValue(key);
            }
        }
        #endregion

        #region 移除
        /// <summary>
        /// 移除缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(string key)
        {
            using (var client = RedisClient)
            {
                return client.Remove(key);
            }
        }
        #endregion

        /// <summary>
        /// 事务操作
        /// </summary>
        public void Transaction()
        {
            using(var client = RedisClient)
            {
                using (var tran = client.CreateTransaction())
                {
                    try
                    {
                        tran.QueueCommand(p =>
                        {
                            //操作redis数据命令
                        });
                        //提交事务
                        tran.Commit();
                    }
                    catch
                    {
                        //回滚事务
                        tran.Rollback();
                    }
                }
            }
        }
    }
}

3、Controller（HomeController）

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using IdentityModel;
using log4net;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using Test.CoreLibrary;
using WebApp.Models;

namespace WebApp.Controllers
{
    public class HomeController : Controller
    {
        private IOptions<JwtSettings> _setting;
        private IConfiguration _configuration;
        private readonly RedisHelper _redis;

        public HomeController(IOptions<JwtSettings> setting, IConfiguration configuration, RedisHelper redisHelper)
        {
            _setting = setting;
            _configuration = configuration;
            _redis = redisHelper;
        }

        public IActionResult RedisIndex()
        {
            _redis.Set<string>("UserName", "1qaz2wsx");
            _redis.Set<long>("Age", 100);
            _redis.Set<int>("TransactionLock", 100);
            _redis.Set<bool>("IsAdmin", true);

            _redis.Get<string>("UserName");
            _redis.Get<long>("Age");
            _redis.Get<int>("TransactionLock");
            _redis.Get<bool>("IsAdmin");

            _redis.Remove("UserName");


            #region 事务

            _redis.Transaction();

            using (var client = _redis.RedisClient)
            {
                using (var tran = client.CreateTransaction())
                {
                    try
                    {
                        tran.QueueCommand(p =>
                        {
                            //操作redis数据命令
                        });
                        //提交事务
                        tran.Commit();
                    }
                    catch
                    {
                        //回滚事务
                        tran.Rollback();
                    }
                }
            }
            #endregion

            return View();
        }
    }
}

4、appsettings.json

# Redis配置【RuYiAdmin】
{
  "RedisConfig": {
    //连接串
    "ConnectionString": "localhost:6379,password=1q2w3E*,defaultDatabase=1,ssl=false,writeBuffer=10240",
    //用户模糊搜索格式
    "Pattern": "user_",
    //统一认证模糊搜索格式
    "UnifiedAuthenticationPattern": "UnifiedAuthentication_",
    //同步模糊搜索格式
    "SynchronizationPattern": "Synchronization_",
    //是否支持哨兵
    "SupportRedisSentinel": false,
    //哨兵集群
    "RedisSentinels": "192.168.1.10:26379,192.168.1.11:26379,192.168.1.12:26379"
  }
}

# Redis配置【ABP】
{
  "Redis": {
    "IsEnabled": "true",
    "Configuration": "127.0.0.1"
  }
}

# Redis配置【Magic.NET】
{
  "RedisConnectionString": "127.0.0.1:6379,password=1q2w3E*,defaultDatabase=2"
}

# Redis配置【Meiam.System】
{
  "RedisServer": {
    "Cache": "127.0.0.1:6379,password=HApVpL8XhFFGz3Oy,preheat=5,idleTimeout=600,defaultDatabase=13,prefix=Cache:",
    "Sequence": "127.0.0.1:6379,password=HApVpL8XhFFGz3Oy,preheat=5,idleTimeout=600,defaultDatabase=14,prefix=Sequence:",
    "Session": "127.0.0.1:6379,password=HApVpL8XhFFGz3Oy,preheat=5,idleTimeout=600,defaultDatabase=15,prefix=Session:"
  }
}

# Redis配置【SimpleAdmin】
{
  "RedisSettings": {
    "Address": "127.0.0.1:6379",
    "Password": "1q2w3E*",
    //默认库
    "Db": 9,
    //是否每次启动都清除Redis缓存
    "ClearRedis": true
  }
}

# Redis配置【ViazyNetCore】
{
  "RedisConfig": {
    "ConnectionString": "127.0.0.1:6379,password=1q2w3E*"
  }
}

*
ServerStack.Redis
*

*