1. Download the client https://github.com/MSOpenTech/redis/releases. Install the client https://www.runoob.com/redis/redis-install.html
2. Reference https://www.cnblogs.com/LiChen19951127/p/10478153.html
3. own run
①Nuget installation StackExchange.Redis
②redishelper
the System the using;
the using the System.Collections.Generic;
the using Microsoft.Extensions.Logging;
using StackExchange.Redis;
using Newtonsoft.Json;
WebApplication1 namespace
{
public class RedisHelperNetCore
{
// singleton
public static GET RedisCommon the Default {{return new new RedisCommon ();}}
public static GET RedisCommon One {{return new new RedisCommon (. 1, "127.0.0.1:6379");} }
public static GET RedisCommon Two {{return new new RedisCommon (2, "127.0.0.1:6379");}}
}
///
/// the Redis class of operation
/// with the old version is ServiceStack.Redis.
/// Net Core StackExchange.Redis use of packet nuget
///
public class RedisCommon
{
// public static ILogger the Log = UtilLogger.Log; logging //
// redis database connection string
String _conn = AppConfigurtaionServices.Configuration Private [ "RedisConfig: ReadWriteHosts"] ?? "127.0.0.1:6379";
Private _db int = 0;
// static variables to ensure that each module uses the same links to different instances of
private static ConnectionMultiplexer connection;
RedisCommon public () {}
///
/// constructor
///
///
///
public RedisCommon (int DB, String connectStr)
{
_conn = connectStr;
_db = DB;
}
///
/// cache database The database connection
///
public ConnectionMultiplexer CacheConnection
{
GET
{
the try
{
IF (connection == null ||! connection.IsConnected)
{
. Lazy new new Connection = (() => ConnectionMultiplexer.Connect (_conn)) the Value;
}
}
the catch (Exception EX)
{
//Log.LogError("RedisHelper->CacheConnection error \ r \ n "+ ex.ToString ( ) );
return null;
}
return Connection;
}
}
///
/// cache database
///
public CacheRedis the IDatabase => 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
}
}
③ encapsulation class reads the configuration file
the using Microsoft.Extensions.Configuration;
the using Microsoft.Extensions.Configuration.Json;
public class AppConfigurtaionServices
{
public static IConfiguration the Configuration {GET; SET;}
static AppConfigurtaionServices ()
{
// ReloadOnChange to true when = appsettings.json is modified reload
the Configuration new new ConfigurationBuilder = ()
.Add (new new JsonConfigurationSource the Path = { "appsettings.json", to true ReloadOnChange =})
.build ();
}}
④appsetting.json configuration
// redis Distributed Cache
"RedisConfig": {
// whether to open a cache 1 0 No
"IsOpenCache": "0",
"ReadWriteHosts": "127.0.0.1:6379,password=123456",
"ReadOnlyHosts ":" 127.0.0.1:6379,password=123456 "
}
⑤ test call
public IActionResult Index ()
{
#region - test redis-
var A = RedisHelperNetCore.Default.StringSet (" Redis "," Redis "+ the DateTime.Now , TimeSpan.FromSeconds (1000000));
var B = RedisHelperNetCore.Default.StringGet ( "Redis");
// var C = RedisHelper.Default.KeyDelete ( "Redis");
#endregion
return View ();
}
