天天看點
傳回

Asp.Net Core 2.0 項目實戰（6）Redis配置、封裝幫助類RedisHelper及使用執行個體

由于內存存取速度遠高于磁盤讀取的特性，為了程式效率提高性能，通常會把常用的不常變動的資料存儲在系統記憶體中，提升資料讀取的速度,這裡我們介紹Redis分布式緩存，另在C#下常見的記憶體操作有微軟自帶的記憶體處理、分布式緩存Memcached。

Asp.Net Core 2.0 項目實戰（1） NCMVC開源下載下傳了

Asp.Net Core 2.0 項目實戰（2）NCMVC一個基于Net Core2.0搭建的角色權限管理開發架構

Asp.Net Core 2.0 項目實戰（3）NCMVC角色權限管理前端UI預覽及下載下傳

Asp.Net Core 2.0 項目實戰（4）ADO.NET操作資料庫封裝、 EF Core操作及執行個體

Asp.Net Core 2.0 項目實戰（5）Memcached踩坑，基于EnyimMemcachedCore整理MemcachedHelper幫助類。

Asp.Net Core 2.0 項目實戰（6）Redis配置、封裝幫助類RedisHelper及使用執行個體

Asp.Net Core 2.0 項目實戰（7）MD5加密、AES&DES對稱加解密

Asp.Net Core 2.0 項目實戰（8）Core下緩存操作、序列化操作、JSON操作等Helper集合類

Asp.Net Core 2.0 項目實戰（9） 日志記錄，基于Nlog或Microsoft.Extensions.Logging的實作及調用執行個體

Asp.Net Core 2.0 項目實戰（10） 基于cookie登入授權認證并實作前台會員、背景管理者同時登入

Asp.Net Core 2.0 項目實戰（11） 基于OnActionExecuting全局過濾器，頁面操作權限過濾控制到按鈕級

本文目錄

1. 摘要

2. Redis配置

3. RedisHelper

4．使用執行個體

5. 總結

1.  摘要

　　由于內存存取速度遠高于磁盤讀取的特性，為了程式效率提高性能，通常會把常用的不常變動的資料存儲在系統記憶體中，提升資料讀取的速度，在C#下常見的記憶體操作有微軟自帶的記憶體處理、分布式緩存Memcached以及Redis,這裡我們介紹Redis分布式緩存，另外兩種緩存處理參考《Asp.Net Core 2.0 項目實戰（8）Core下緩存操作、序列化操作、JSON操作等Helper集合類》介紹了基于Microsoft.Extensions.Caching.Memory封裝CacheHelper緩存幫助類；《Asp.Net Core 2.0 項目實戰（5）Memcached踩坑，基于EnyimMemcachedCore整理MemcachedHelper幫助類。》Memcached幫助類。

2.  Redis配置

　　在appsettings.json添加相關配置，配置讀寫redis伺服器,多伺服器用逗号隔開。

//redis分布式緩存
  "RedisConfig": {
    //是否打開緩存1是0否
    "IsOpenCache": "0",
    "ReadWriteHosts": "192.168.1.2:6379,192.168.1.3:6379,password=123456",
    "ReadOnlyHosts": "192.168.1.2:6379,password=123456"
  }
Asp.Net Core 2.0 項目實戰（6）Redis配置、封裝幫助類RedisHelper及使用執行個體

3.  RedisHelper

　　添加Nuget包StackExchange.Redis和Newtonsoft.Json；設定Key/Value，删除redis緩存。本幫助類我僅本地兩台電腦測試過，生産環境暫未使用，現僅供參考。

using System;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;

using StackExchange.Redis;
using Newtonsoft.Json;

namespace NC.Common
{
    public class RedisHelper
    {
        //單例模式
        public static RedisCommon Default{get { return new RedisCommon(); } }
        public static RedisCommon One { get { return new RedisCommon(1, "127.0.0.1:6379"); } }
        public static RedisCommon Two { get { return new RedisCommon(2, "127.0.0.1:6379"); } }
    }
    /// <summary>
    /// Redis操作類
    /// 老版用的是ServiceStack.Redis。
    /// Net Core使用StackExchange.Redis的nuget包
    /// </summary>
    public class RedisCommon
    {
        public static ILogger Log = UtilLogger<RedisCommon>.Log;//日志記錄
        //redis資料庫連接配接字元串
        private string _conn = UtilConf.Configuration["RedisConfig:ReadWriteHosts"] ?? "127.0.0.1:6379";
        private int _db = 0;
        //靜态變量 保證各子產品使用的是不同執行個體的相同連結
        private static ConnectionMultiplexer connection;
        public RedisCommon() { }
        /// <summary>
        /// 構造函數
        /// </summary>
        /// <param name="db"></param>
        /// <param name="connectStr"></param>
        public RedisCommon(int db, string connectStr)
        {
            _conn = connectStr;
            _db = db;
        }
        /// <summary>
        /// 緩存資料庫，資料庫連接配接
        /// </summary>
        public ConnectionMultiplexer CacheConnection
        {
            get
            {
                try
                {
                    if (connection == null || !connection.IsConnected)
                    {
                        connection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(_conn)).Value;
                    }
                }
                catch (Exception ex)
                {
                    Log.LogError("RedisHelper->CacheConnection 出錯\r\n" + ex.ToString());
                    return null;
                }
                return connection;
            }
        }
        /// <summary>
        /// 緩存資料庫
        /// </summary>
        public IDatabase CacheRedis => CacheConnection.GetDatabase(_db);

        #region --KEY/VALUE存取--
        /// <summary>
        /// 單條存值
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">The value.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
        public bool StringSet(string key, string value)
        {
            return CacheRedis.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 StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            return CacheRedis.StringSet(key, value, expiry);
        }
        /// <summary>
        /// 儲存多個key value
        /// </summary>
        /// <param name="arr">key</param>
        /// <returns></returns>
        public bool StringSet(KeyValuePair<RedisKey, RedisValue>[] arr)
        {
            return CacheRedis.StringSet(arr);
        }
        /// <summary>
        /// 批量存值
        /// </summary>
        /// <param name="keysStr">key</param>
        /// <param name="valuesStr">The value.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
        public bool StringSetMany(string[] keysStr, string[] valuesStr)
        {
            var count = keysStr.Length;
            var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
            for (int i = 0; i < count; i++)
            {
                keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(keysStr[i], valuesStr[i]);
            }

            return CacheRedis.StringSet(keyValuePair);
        }

        /// <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 = JsonConvert.SerializeObject(obj);
            return CacheRedis.StringSet(key, json, expiry);
        }
        /// <summary>
        /// 追加值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void StringAppend(string key, string value)
        {
            ////追加值，傳回追加後長度
            long appendlong = CacheRedis.StringAppend(key, value);
        }

        /// <summary>
        /// 擷取單個key的值
        /// </summary>
        /// <param name="key">Redis Key</param>
        /// <returns></returns>
        public RedisValue GetStringKey(string key)
        {
            return CacheRedis.StringGet(key);
        }
        /// <summary>
        /// 根據Key擷取值
        /// </summary>
        /// <param name="key">鍵值</param>
        /// <returns>System.String.</returns>
        public string StringGet(string key)
        {
            try
            {
                return CacheRedis.StringGet(key);
            }
            catch (Exception ex)
            {
                Log.LogError("RedisHelper->StringGet 出錯\r\n" + ex.ToString());
                return null;
            }
        }

        /// <summary>
        /// 擷取多個Key
        /// </summary>
        /// <param name="listKey">Redis Key集合</param>
        /// <returns></returns>
        public RedisValue[] GetStringKey(List<RedisKey> listKey)
        {
            return CacheRedis.StringGet(listKey.ToArray());
        }
        /// <summary>
        /// 批量擷取值
        /// </summary>
        public string[] StringGetMany(string[] keyStrs)
        {
            var count = keyStrs.Length;
            var keys = new RedisKey[count];
            var addrs = new string[count];

            for (var i = 0; i < count; i++)
            {
                keys[i] = keyStrs[i];
            }
            try
            {

                var values = CacheRedis.StringGet(keys);
                for (var i = 0; i < values.Length; i++)
                {
                    addrs[i] = values[i];
                }
                return addrs;
            }
            catch (Exception ex)
            {
                Log.LogError("RedisHelper->StringGetMany 出錯\r\n" + ex.ToString());
                return null;
            }
        }
        /// <summary>
        /// 擷取一個key的對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T GetStringKey<T>(string key)
        {
            return JsonConvert.DeserializeObject<T>(CacheRedis.StringGet(key));
        }

        #endregion

        #region --删除設定過期--
        /// <summary>
        /// 删除單個key
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns>是否删除成功</returns>
        public bool KeyDelete(string key)
        {
            return CacheRedis.KeyDelete(key);
        }
        /// <summary>
        /// 删除多個key
        /// </summary>
        /// <param name="keys">rediskey</param>
        /// <returns>成功删除的個數</returns>
        public long KeyDelete(RedisKey[] keys)
        {
            return CacheRedis.KeyDelete(keys);
        }
        /// <summary>
        /// 判斷key是否存儲
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns></returns>
        public bool KeyExists(string key)
        {
            return CacheRedis.KeyExists(key);
        }
        /// <summary>
        /// 重新命名key
        /// </summary>
        /// <param name="key">就的redis key</param>
        /// <param name="newKey">新的redis key</param>
        /// <returns></returns>
        public bool KeyRename(string key, string newKey)
        {
            return CacheRedis.KeyRename(key, newKey);
        }
        /// <summary>
        /// 删除hasekey
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool HaseDelete(RedisKey key, RedisValue hashField)
        {
            return CacheRedis.HashDelete(key, hashField);
        }
        /// <summary>
        /// 移除hash中的某值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool HashRemove(string key, string dataKey)
        {
            return CacheRedis.HashDelete(key, dataKey);
        }
        /// <summary>
        /// 設定緩存過期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="datetime"></param>
        public void SetExpire(string key, DateTime datetime)
        {
            CacheRedis.KeyExpire(key, datetime);
        }
        #endregion

    }
}

4.  使用執行個體

　　在HomeCtroller控制器中添加測試redis方法如下：寫；讀；删除。

public IActionResult Index()
        {
            #region --測試redis--
            RedisHelper.Default.StringSet("redis", "redis" + DateTime.Now, TimeSpan.FromSeconds(1000000));
            ViewData["redis"] = RedisHelper.Default.StringGet("redis");
            //RedisHelper.Default.KeyDelete("redis");
            #endregion
            return View();
        }

5.  總結

　　Redis讀寫速度快性能高，但部署到生産環境中要注意端口、密碼設定，最好是部署在内網環境中，另由于之前都是使用ServiceStack.Redis，由于ServiceStack.Redis v4版本後是收費版的，好像還有每小時6000次通路請求的問題需注意，具體這倆請自行搜尋對比。Redis 有五種常用資料類型，字元串類型（string），散列類型（hash），清單類型（list），集合類型（set），有序集合類型（zset）參考：https://www.cnblogs.com/mingtianct/p/6291593.html；這裡我暫隻處理了string類型，上面我測試的方法有限，其他類型各位可自行補充，網上有很多案例。

作者：鄭州 - 在路上

出處：http://www.cnblogs.com/oorz/

Q群：NET CORE技術交流（444036561）

Asp.Net Core 2.0 項目實戰（6）Redis配置、封裝幫助類RedisHelper及使用執行個體

微信公衆号：“專卓”；因為專業，是以卓越！可掃描左側二維碼關注。

本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接配接，否則保留追究法律責任的權利。

Asp.Net Core 2.0項目實戰 RedisHelper Redis
上一篇: ASP.NET Core 運作原了解剖[1]:Hosting
下一篇: 使用 NLog 給 Asp.Net Core 做請求監控

繼續閱讀