2. 程式人生 > >在.Net下使用redis基於StackExchange.Redis

在.Net下使用redis基於StackExchange.Redis

阿新 • • 發佈：2017-06-02
sof sel setting null pep inf syn url 討論

研究了下redis在.net下的使用，因為以前在java上用redis用的是jedis操作，在.net不是很熟悉，在網站上也看了一部分的.net下redis的使用，大部分都是ServiceStack.Redis聽說ServiceStack.Redis4.0版本都是收費的，這個我不是很清楚，但是我確實有項目再用ServiceStack.Redis。

技術分享

這裏就不討論ServiceStack.Redis的使用今天帶來的是StackExchange.Redis的封裝版。

代碼參考

DDD領域驅動之幹貨（三）完結篇！

下面是幹貨

技術分享技術分享

RedisCaching裏面放著的是Redis的基本5個方法分別如下圖所示：

技術分享

RedisCommon裏面放著的是redis的幫助類和初始化類如下圖所示：

技術分享

現在舉了例子就以DoRedisStringCache為例：

技術分享

實現了接口IRedisCaching，當然這裏這個接口是標識接口意思就是用來約束的。

StackExchange.Redis是初始化是單列模式，內部有一套自己的方法，這裏我就放一下代碼

技術分享

這裏面還有6個事件如下圖：

技術分享

代碼貼出來：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

 
using StackExchange.Redis;
using KuRuMi.Mio.DoMain.Infrastructure.Logger;

namespace KuRuMi.Mio.DoMain.RedisCache.RedisCommon
{
    public class RedisManager
    {
        private static string Constring = RedisConfig.Config();
        private static readonly object locker = new object();
        private
 
 static ConnectionMultiplexer instance;
        private static readonly Dictionary<string, ConnectionMultiplexer> Concache = new Dictionary<string, ConnectionMultiplexer>();

        /// <summary>
        /// 單例模式獲取redis連接實例
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (locker)
                    {
                        if (instance == null)
                            instance = GetManager();
                    }
                }
                return instance;
            }
        }

        /// <summary>
        /// 從緩存中獲取
        /// </summary>
        /// <param name="constr"></param>
        /// <returns></returns>
        public static ConnectionMultiplexer GetConForMap(string constr) {
            if (!Concache.ContainsKey(constr))
                Concache[constr] = GetManager(constr);
            return Concache[constr];
        }

        private static ConnectionMultiplexer GetManager(string constr = null)
        {
            constr = constr ?? Constring;
            var connect = ConnectionMultiplexer.Connect(constr);

            #region 註冊事件
            connect.ConnectionFailed += MuxerConnectionFailed;
            connect.ConnectionRestored += MuxerConnectionRestored;
            connect.ErrorMessage += MuxerErrorMessage;
            connect.ConfigurationChanged += MuxerConfigurationChanged;
            connect.HashSlotMoved += MuxerHashSlotMoved;
            connect.InternalError += MuxerInternalError;
            #endregion

            return connect;
        }
        #region Redis事件
        /// <summary>
        /// 內部異常
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            Units.Log("內部異常：" + e.Exception.Message);
        }

        /// <summary>
        /// 集群更改
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            Units.Log("新集群：" + e.NewEndPoint + "舊集群：" + e.OldEndPoint);
        }

        /// <summary>
        /// 配置更改事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            Units.Log("配置更改：" + e.EndPoint);
        }

        /// <summary>
        /// 錯誤事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            Units.Log("異常信息：" + e.Message);
        }

        /// <summary>
        /// 重連錯誤事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            Units.Log("重連錯誤" + e.EndPoint);
        }

        /// <summary>
        /// 連接失敗事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            Units.Log("連接異常" + e.EndPoint + "，類型為" + e.FailureType + (e.Exception == null ? "" : ("，異常信息是" + e.Exception.Message)));
        }
        #endregion
    }
}

下面是redis的config：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KuRuMi.Mio.DoMain.RedisCache.RedisCommon
{
    public sealed class RedisConfig
    {
        public static readonly string config = ConfigurationManager.AppSettings["RedisConfig"];
        public static readonly string redisKey = ConfigurationManager.AppSettings["RedisKey"] ?? "";
        public static string Config() {
            return config;
        }
        public static string Key() {
            return redisKey;
        }
    }
}

下面是redis的helper：

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KuRuMi.Mio.DoMain.RedisCache.RedisCommon
{
    public class RedisBase
    {
        private static ConnectionMultiplexer db = null;
        private static string key = string.Empty;

        private int DbNumber { get; }
        public RedisBase(int dbnum = 0) : this(dbnum, null)
        {

        }

        public RedisBase(int dbnum, string connectionString)
        {
            DbNumber = dbnum;
            db = string.IsNullOrWhiteSpace(connectionString) ? RedisManager.Instance : RedisManager.GetConForMap(connectionString);
        }

        #region 輔助方法
        /// <summary>
        /// 添加名稱
        /// </summary>
        /// <param name="old"></param>
        /// <returns></returns>
        public string AddKey(string old)
        {
            var fixkey = key ?? RedisConfig.Key();
            return fixkey + old;
        }

        /// <summary>
        /// 執行保存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public T DoSave<T>(Func<IDatabase, T> func)
        {
            return func(db.GetDatabase(DbNumber));
        }
        public string ConvertJson<T>(T val)
        {
            return val is string ? val.ToString() : JsonConvert.SerializeObject(val);
        }

        public T ConvertObj<T>(RedisValue val)
        {
            return JsonConvert.DeserializeObject<T>(val);
        }

        public List<T> ConvertList<T>(RedisValue[] val)
        {
            List<T> result = new List<T>();
            foreach (var item in val)
            {
                var model = ConvertObj<T>(item);
                result.Add(model);
            }
            return result;
        }

        public RedisKey[] ConvertRedisKeys(List<string> val)
        {
            return val.Select(k => (RedisKey)k).ToArray();
        }
        #endregion
    }
}

下面是我的string封裝方法：

using KuRuMi.Mio.DoMain.RedisCache.RedisCommon;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KuRuMi.Mio.DoMain.RedisCache.RedisCaching
{
    /// <summary>
    /// 表示string的操作
    /// </summary>
    public class DoRedisStringCache : IRedisCaching
    {
        private RedisBase redis = null;
        public DoRedisStringCache()
        {
            redis = new RedisBase();
        }

        #region 同步執行
        /// <summary>
        /// 單個保存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val">值</param>
        /// <param name="exp">過期時間</param>
        /// <returns></returns>
        public bool StringSet(string key, string val, TimeSpan? exp = default(TimeSpan?))
        {
            key = redis.AddKey(key);
            return redis.DoSave(db => db.StringSet(key, val, exp));
        }

        /// <summary>
        /// 保存多個key value
        /// </summary>
        /// <param name="keyValues">鍵值對</param>
        /// <returns></returns>
        public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> KeyVal)
        {
            List<KeyValuePair<RedisKey, RedisValue>> newkey = KeyVal.Select(k => new KeyValuePair<RedisKey, RedisValue>(redis.AddKey(k.Key), k.Value)).ToList();
            return redis.DoSave(db => db.StringSet(newkey.ToArray()));
        }

        /// <summary>
        /// 保存一個對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public bool StringSet<T>(string key, T obj, TimeSpan? exp = default(TimeSpan?))
        {
            key = redis.AddKey(key);
            string json = redis.ConvertJson(obj);
            return redis.DoSave(db => db.StringSet(key, json, exp));
        }

        /// <summary>
        /// 獲取單個
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string StringGet(string key)
        {
           key = redis.AddKey(key);
            return redis.DoSave(db => db.StringGet(key));
        }
        /// <summary>
        /// 獲取單個對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T StringGet<T>(string key) {
            key = redis.AddKey(key);
            var val = redis.DoSave(db => db.StringGet(key));
            return redis.ConvertObj<T>(val);
        }

        /// <summary>
        /// 為數字增長val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val">可以為負數</param>
        /// <returns>增長後的值</returns>
        public double StringIncrement(string key, double val = 1)
        {
           key = redis.AddKey(key);
            return redis.DoSave(db => db.StringIncrement(key, val));
        }
        /// <summary>
        /// 為數字減少val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val">可以為負數</param>
        /// <returns>增長後的值</returns>
        public double StringDecrement(string key, double val = 1)
        {
           key = redis.AddKey(key);
            return redis.DoSave(db => db.StringDecrement(key, val));
        }
        #endregion

        #region 異步執行
        /// <summary>
        /// 異步保存單個
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(string key, string val, TimeSpan? exp = default(TimeSpan?))
        {
            key = redis.AddKey(key);
            return await redis.DoSave(db => db.StringSetAsync(key, val, exp));
        }
        /// <summary>
        /// 異步保存多個key value
        /// </summary>
        /// <param name="keyValues">鍵值對</param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> KeyVal)
        {
            List<KeyValuePair<RedisKey, RedisValue>> newkey = KeyVal.Select(k => new KeyValuePair<RedisKey, RedisValue>(redis.AddKey(k.Key), k.Value)).ToList();
            return await redis.DoSave(db => db.StringSetAsync(newkey.ToArray()));
        }

        /// <summary>
        /// 異步保存一個對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync<T>(string key, T obj, TimeSpan? exp = default(TimeSpan?))
        {
            key = redis.AddKey(key);
            string json = redis.ConvertJson(obj);
            return await redis.DoSave(db => db.StringSetAsync(key, json, exp));
        }

        /// <summary>
        /// 異步獲取單個
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<string> StringGetAsync(string key)
        {
           key = redis.AddKey(key);
            return await redis.DoSave(db => db.StringGetAsync(key));
        }

        /// <summary>
        /// 異步獲取單個
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> StringGetAsync<T>(string key)
        {
            key = redis.AddKey(key);
            var val = await redis.DoSave(db => db.StringGetAsync(key));
            return redis.ConvertObj<T>(val);
        }

        /// <summary>
        /// 異步為數字增長val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val">可以為負數</param>
        /// <returns>增長後的值</returns>
        public async Task<double> StringIncrementAsync(string key, double val = 1)
        {
           key = redis.AddKey(key);
            return await redis.DoSave(db => db.StringIncrementAsync(key, val));
        }
        /// <summary>
        /// 為數字減少val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val">可以為負數</param>
        /// <returns>增長後的值</returns>
        public async Task<double> StringDecrementAsync(string key, double val = 1)
        {
           key = redis.AddKey(key);
            return await redis.DoSave(db => db.StringDecrementAsync(key, val));
        }
        #endregion
    }
}

StackExchange.Redis本身提供了一套異步的方法這個我比較喜歡。至於其他的和string的同理，我這裏就不放出封裝方法，需要的留言。

最後是測試：

技術分享

這是我的redis然後是我的數據庫

技術分享

這裏是我登錄的測試代碼：

技術分享

在.Net下使用redis基於StackExchange.Redis

相關推薦

在.Net下使用redis基於StackExchange.Redis

sof sel setting null pep inf syn url 討論 研究了下redis在.net下的使用，因為以前在java上用redis用的是jedis操作，在.net不是很熟悉，在網站上也看了一部分的.net下redis的使用，大部分都是ServiceSta

C# 基於StackExchange.Redis.dll利用Redis實現分散式Session

最近在研發一款O2O產品，考慮到分散式架構的需要，以前那一套.NET的Session管理方式已經不合用了。遂研究了一下Redis，發現基於這種Key-Value的記憶體資料庫很適合來做分散式Session。本示例將基於StackExchange.Redis.dll進行實現，

Redis叢集~StackExchange.redis連線Sentinel伺服器並訂閱相關事件

對於redis-sentinel我在之前的文章中Redis叢集~StackExchange.redis連線Twemproxy代理伺服器 已經說過，它是一個仲裁者，當主master掛了後，它將在所有slave伺服器中進行選舉，選舉的原則當然可以看它的官方文章，這與我們使用者沒有什麼關係，而對於se

Redis叢集~StackExchange.Redis(10月6號版1.1.608.0)連線Twemproxy支援Auth指令了

回到目錄 對於StackExchange.Redis這個驅動來說，之前的版本在使用Proxy為Twemproxy代理時，它是不支援Password屬性的，即不支援原始的Auth指令，而我也修改過原始碼，為CommandMap添加了Auth但最後測試的結果還是失敗了，就在１０月１過完後的第一天，我升級了Sta

Redis叢集~StackExchange.redis連線Twemproxy代理伺服器

回到目錄 本文是Redis集群系列的一篇文章，主要介紹使用StackExchange.Redis進行Twemproxy（文中簡稱TW）代理服務的連線過程，事務上，對於ＴＷ來說，我們需要理解一下它的物理架構，它類似於Nugix，主要實現的是請求轉發，但它還有一個重要的功能，那就是自動分片，這對於大資料是很必要

Redis叢集~StackExchange.redis連線Sentinel伺服器並訂閱相關事件（原創）

回到目錄 對於redis-sentinel我在之前的文章中已經說過，它是一個仲裁者，當主master掛了後，它將在所有slave伺服器中進行選舉，選舉的原則當然可以看它的官方文章，這與我們使用者沒有什麼關係，而對於sentinel來說，它在進行主從切換時，會觸發相關事件，這是和我們開發人員有關係的，如當+s

.NetCore使用Redis，StackExchange.Redis佇列，釋出與訂閱，分散式鎖的簡單使用

環境：之前一直是使用serverStack.Redis的客服端，今天來使用一下StackExchange.Redis(個人感覺更加的人性化一些，也是免費的，效能也不會差太多)，版本為StackExchange.Redis V2.1.58 ,Core3.1 簡單的說明(專業的術語參考資料網路和官網)：官網地址：

功能比較全的StackExchange.Redis封裝幫助類(.Net/C#)

fault wke setting ret stack gin lex sortedset each Redis官網https://redis.io/ 以下內容未全部驗證，如有問題請指出 //static NewtonsoftSerializer serializer

StackExchange.Redis下清空DB

class com nbsp 出現 tac edi body 技術 change 由於項目需求，需要每天定時將數據庫中某張表的數據全量寫入Redis，每次寫入之前需要清空一下DB，清空代碼如下： 註意事項：如果出現如下圖所示錯誤 解決方案：在redis連接字符串中增加a

Redis 高負載下的中斷優化(基於京東redis叢集高負載下丟包案例分析)

Redis 高負載下的中斷優化 陳炳宇 背景 2015年年初以來，隨著Redis產品的使用者量越來越大，接入服務越來越多，再加上京東商城Memcache和Redis兩套快取融合，Redis服務端的

.net core redis 驅動推薦，為什麼不使用 StackExchange.Redis

前言本人從事 .netcore 轉型已兩年有餘，對 .net core 頗有好感，這一切得益於優

《.NET 5.0 背鍋案》第7集-大結局：捉拿真凶 StackExchange.Redis.Extensions 歸案

* [第1集：驗證 .NET 5.0 正式版 docker 映象問題](https://www.cnblogs.com/cmt/p/13971299.html) * [第2集：碼中的小窟窿，背後的大坑，發現重要嫌犯 EnyimMemcachedCore](https://www.cnblogs.com/cmt

如何在SecureCRT中給linux上傳和下載文件 安裝redis

per med jpg 對話 分享 解壓 -i jin ccf 首先建立文件 /download sz和rz命令無法用。則用以下1.和2.3步驟 需要上傳或者下載，需要使用rz和sz命令。如果linux上沒有這兩個命令工具，則需要

在.net下打造mongoDb基於官方驅動最新版本

readonly alt 新版 read != a + b 了解 服務 common 還是一如既往先把結構圖放出來，上上個版本添加了redis的緩存，但是不滿足我的需求，因為公司有項目要求是分布式所以呢，這裏我就增加了mongoDb進行緩存分布式，好了先看結構圖。 總的來

基於express+redis高速實現實時在線用戶數統計

posit itl git term agent bus class net img 作者：zhanhailiang 日期：2014-11-09 本文將介紹怎樣基於express+redis高速實現實時在線用戶數統計。 1. 在github.com上創建項目u

StackExchange.Redis 官方文檔(一) Basics

pass abc ocs 維護 cpp ber mas msd nds 基本使用方法： StackExchange.Redis的核心是 StackExchange.Redis 命名空間的 ConnectionMultiplexer 類;它隱藏了多服務器的實現細節.Conne

Ubuntu16.04下nginx+mysql+php+redis

images fastcgi light -c 連接 dev 是否 memcache word 一、redis簡介 Redis是一個key-value存儲系統。和Memcached類似，為了保證效率，數據都是緩存在內存中。區別的是redis會周期性的把更新的數據寫入磁盤或者

Jexus~mono中使用StackExchange.redis的問題

nbsp linux環境 hang 感謝 下載 sta dll ref bsp 在windows平臺的vs裏，添加包包時，可以選擇StackExchange.redis，而如果你的應該程序需要部署到linux的mono環境上，使用這個StackExchange.redis是

.NET中使用Redis之ServiceStack.Redis學習（一）安裝與簡單的運行

arraylist write client cli ring blog 控制臺 創建 spa 1.下載ServiceStack.Redis PM> Install-Package ServiceStack.Redis 2.vs中創建一個控制臺程序 class Pro

stackExchange.redis的使用

shell bsp disabled dbr for 方式 shel point org 在StackExchange.Redis中最重要的對象是ConnectionMultiplexer類， 它存在於StackExchange.Redis命名空間中。 這個類隱藏了Redi