前言
维护公司的一个老项目，有的网页打开初始化的查询需要五六秒甚至更久，用户体验极差，而且并发量变大的时候网站容易崩溃，经过考虑，可以添加Redis缓存来缓存常用数据来减少后台数据库的调用。
Redis是一种流行的开源内存数据存储，常用于缓存，消息队列，实时数据分析等应用场景。在C#开发中，我们可以使用StackExchange.Redis库来连接和操作Redis。
本文将介绍如何在.NET中配置Redis，包括如何安装和初始化Redis，以及如何使用StackExchange.Redis库连接和操作Redis。
安装配置StackExchange.Redis
安装StackExchange.Redis
可以使用Nuget包管理器安装StackExchange.Redis。使用以下命令：
Install-Package StackExchange.Redis也可以在NuGet包管理器手动搜索StackExchange.Redis下载：
编写一个RedisHelper类
RedisHelper类：
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using Newtonsoft.Json;
using StackExchange.Redis; // 需要安装StackExchange.Redis包
namespace Common
{
/// <summary>
/// Redis工具类
/// </summary>
public class RedisHelper
{
#region redis 连接
private static ConnectionMultiplexer _redis;
private static readonly string RedisConnectionString =
ConfigurationManager.ConnectionStrings["RedisConnectionStr"].ConnectionString;
/// <summary>
/// 连接 Redis 数据库
/// </summary>
/// <returns>Redis 数据库连接实例</returns>
public static ConnectionMultiplexer ConnectRedis()
{
if (_redis == null || !_redis.IsConnected)
{
_redis = ConnectionMultiplexer.Connect(RedisConnectionString);
}
return _redis;
}
#endregion
#region redis 通用型数据读写操作
/// <summary>
/// 使用Redis缓存数据
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="key">键</param>
/// <param name="data">数据</param>
/// <param name="expiry">过期时间（可选）</param>
public void SetRedisCache<T>(string key, T data, TimeSpan? expiry = null) {
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("缓存键不能为空！", nameof(key));
}
IDatabase redisDb = ConnectRedis().GetDatabase();
if (expiry.HasValue) {
redisDb.StringSet(key, JsonConvert.SerializeObject(data), expiry);
} else {
redisDb.StringSet(key, JsonConvert.SerializeObject(data));
}
}
/// <summary>
/// 从Redis获取缓存数据
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="key">键</param>
/// <returns>数据</returns>
public T GetRedisCache<T>(string key) {
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("缓存键不能为空！", nameof(key));
}
IDatabase redisDb = ConnectRedis().GetDatabase();
string redisValue = redisDb.StringGet(key);
if (!string.IsNullOrEmpty(redisValue)) {
return JsonConvert.DeserializeObject<T>(redisValue);
}
return default(T);
}
/// <summary>
/// 删除 Redis 缓存中的数据
/// </summary>
/// <param name="key">缓存键</param>
public void DelRedisCache(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("缓存键不能为空！", nameof(key));
}
ConnectRedis().GetDatabase().KeyDelete(key);
}
#endregion
#region redis 字符串（string）操作
/// <summary>
/// 设置指定键的值
/// </summary>
/// <param name="key">要设置值的键</param>
/// <param name="value">要设置的值</param>
/// <returns>如果设置成功则返回 true，否则返回 false</returns>
public bool StringSet(string key, string value)
{
return ConnectRedis().GetDatabase().StringSet(key, value);
}
/// <summary>
/// 获取指定键的值
/// </summary>
/// <param name="key">要获取值的键</param>
/// <returns>键对应的值</returns>
public object StringGet(string key)
{
return ConnectRedis().GetDatabase().StringGet(key);
}
/// <summary>
/// 获取指定键的字符串值的子字符串
/// </summary>
/// <param name="key">要获取值的键</param>
/// <param name="start">子字符串的起始位置（包含）</param>
/// <param name="end">子字符串的结束位置（包含）</param>
/// <returns>键对应的子字符串</returns>
public object StringGet(string key, int start, int end)
{
return ConnectRedis().GetDatabase().StringGetRange(key, start, end);
}
/// <summary>
/// 设置键的字符串值并返回其旧值
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">键的值</param>
/// <returns>返回键的旧值</returns>
public object StringGetAndSet(string key, string value)
{
return ConnectRedis().GetDatabase().StringGetSet(key, value);
}
/// <summary>
/// 返回在键处存储的字符串值中偏移处的位值
/// </summary>
/// <param name="key">键值</param>
/// <param name="offset">偏移量</param>
/// <returns>在键处存储的字符串值中偏移处的位值</returns>
public bool StringGetBit(string key, long offset)
{
return ConnectRedis().GetDatabase().StringGetBit(key, offset);
}
/// <summary>
/// 获取所有给定键的值
/// </summary>
/// <param name="keys">键的集合</param>
/// <returns>由该键集合所对应的值组成的列表</returns>
public List<object> StringMultiGet(string[] keys)
{
List<object> list = new List<object>();
for (int i = 0; i < keys.Length; i++)
{
list.Add(ConnectRedis().GetDatabase().StringGet(keys[i]));
}
return list;
}
/// <summary>
/// 存储在键上的字符串值中设置或清除偏移处的位
/// </summary>
/// <param name="key">键值</param>
/// <param name="offset">偏移量</param>
/// <param name="value">值</param>
/// <returns>如果偏移量原来在位集里返回 true ,如果偏移量超出了字符串的长度返回 false </returns>
public bool StringSetBit(string key, long offset)
{
return ConnectRedis().GetDatabase().StringSetBit(key, offset, true);
}
/// <summary>
/// 使用键和到期时间来设置值
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">键的值</param>
/// <param name="expiry">过期时间</param>
/// <returns>是否设置成功</returns>
public bool StringSet(string key, string value, TimeSpan expiry)
{
return ConnectRedis().GetDatabase().StringSet(key, value, expiry);
}
/// <summary>
/// 设置键的值，仅当键不存在时
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">键的值</param>
/// <returns></returns>
public void StringSetIfAbsent(string key, string value)
{
if (ConnectRedis().GetDatabase().StringGet(key) == RedisValue.Null)
{
ConnectRedis().GetDatabase().StringSet(key, value);
}
}
/// <summary>
/// 在指定偏移处开始的键处覆盖字符串的一部分
/// </summary>
/// <param name="key">键值</param>
/// <param name="offset">偏移量</param>
/// <param name="value">覆盖的字符串</param>
/// <returns>被修改的字符串长度</returns>
public object StringSet(string key, long offset, string value)
{
return ConnectRedis().GetDatabase().StringSetRange(key, offset, value);
}
/// <summary>
/// 获取存储在键中的值的长度
/// </summary>
/// <param name="key">键值</param>
/// <returns>存储在键中的值的长度</returns>
public long StringSize(string key)
{
return ConnectRedis().GetDatabase().StringLength(key);
}
/// <summary>
/// 为多个键分别设置它们的值
/// </summary>
/// <param name="dic">键和对应值组成的字典</param>
/// <returns></returns>
public void StringMultiSet(Dictionary<string, string> dic)
{
foreach (KeyValuePair<string, string> key in dic)
{
ConnectRedis().GetDatabase().StringSet(key.Key, key.Value);
}
}
/// <summary>
/// 为多个键分别设置它们的值，仅当键不存在时
/// </summary>
/// <param name="keys">键值集合</param>
/// <returns></returns>
public void StringMultiSetIfAbsent(Dictionary<string, string> dic)
{
foreach (KeyValuePair<string, string> key in dic)
{
//判断键值是否存在，不存在则设置键值
if (ConnectRedis().GetDatabase().StringGet(key.Key) == RedisValue.Null)
{
ConnectRedis().GetDatabase().StringSet(key.Key, key.Value);
}
}
}
/// <summary>
/// 将键的整数值按给定的数值增加
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">给定的数值</param>
/// <returns>增加后的值</returns>
public double StringIncrement(string key, double value)
{
return ConnectRedis().GetDatabase().StringIncrement(key, value);
}
/// <summary>
/// 在key键对应值的右面追加值value
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">要追加的值</param>
/// <returns>追加后字符串的长度</returns>
public long StringAppend(string key, string value)
{
return ConnectRedis().GetDatabase().StringAppend(key, value);
}
/// <summary>
/// 删除某个键值
/// </summary>
/// <param name="key">键值</param>
/// <returns>如果成功删除则返回true，否则返回false</returns>
public bool StringDelete(string key)
{
return ConnectRedis().GetDatabase().KeyDelete(key);
}
#endregion
#region redis 哈希/散列/字典（Hash）操作
/// <summary>
/// 删除指定的哈希字段
/// </summary>
/// <param name="key">哈希键</param>
/// <param name="field">哈希字段</param>
/// <returns>成功返回true，否则返回false</returns>
public bool HashDelete(string key, string field)
{
return ConnectRedis().GetDatabase().HashDelete(key, field);
}
/// <summary>
/// 判断是否存在散列字段
/// </summary>
/// <param name="key">哈希键</param>
/// <param name="field">哈希字段</param>
/// <returns>存在返回true，否则返回false</returns>
public bool HashHasKey(string key, string field)
{
return ConnectRedis().GetDatabase().HashExists(key, field);
}
/// <summary>
/// 判断是否存在散列字段
/// </summary>
/// <param name="key">哈希键</param>
/// <param name="field">哈希字段</param>
/// <returns>存在返回true，否则返回false</returns>
public object HashGet(string key, string field)
{
return ConnectRedis().GetDatabase().HashGet(key, field);
}
/// <summary>
/// 获取存储在指定键的哈希中的所有字段和值
/// </summary>
/// <param name="key">哈希键</param>
/// <returns>返回包含所有字段和值的字典</returns>
public Dictionary<string, object> HashGetAll(string key)
{
Dictionary<string, object> dic = new Dictionary<string, object>();
var collection = ConnectRedis().GetDatabase().HashGetAll(key);
foreach (var item in collection)
{
dic.Add(item.Name, item.Value);
}
return dic;
}
/// <summary>
/// 将哈希字段的浮点值按给定数值增加
/// </summary>
/// <param name="key">哈希键</param>
/// <param name="field">哈希字段</param>
/// <param name="value">给定的数值</param>
/// <returns>返回增加后的值</returns>
public double HashIncrement(string key, string field, double value)
{
return ConnectRedis().GetDatabase().HashIncrement(key, field, value);
}
/// <summary>
/// 获取哈希中的所有字段
/// </summary>
/// <param name="key">哈希键</param>
/// <returns>返回包含所有字段的字符串数组</returns>
public string[] HashKeys(string key)
{
return ConnectRedis().GetDatabase().HashKeys(key).ToStringArray();
}
/// <summary>
/// 获取哈希中的所有字段
/// </summary>
/// <param name="key">哈希键</param>
/// <returns>返回包含所有字段的字符串数组</returns>
public long HashSize(string key)
{
return ConnectRedis().GetDatabase().HashLength(key);
}
/// <summary>
/// 获取哈希中的所有字段
/// </summary>
/// <param name="key">哈希键</param>
/// <returns>返回包含所有字段的字符串数组</returns>
public List<object> HashMultiGet(string key, List<string> hashKeys)
{
List<object> result = new List<object>();
foreach (string field in hashKeys)
{
result.Add(ConnectRedis().GetDatabase().HashGet(key, field));
}
return result;
}
/// <summary>
/// 为多个哈希字段分别设置它们的值
/// </summary>
/// <param name="key">哈希键</param>
/// <param name="dic">哈希字段和对应值组成的字典</param>
/// <returns></returns>
public void HashPutAll(string key, Dictionary<string, string> dic)
{
List<HashEntry> list = new List<HashEntry>();
for (int i = 0; i < dic.Count; i++)
{
KeyValuePair<string, string> param = dic.ElementAt(i);
list.Add(new HashEntry(param.Key, param.Value));
}
ConnectRedis().GetDatabase().HashSet(key, list.ToArray());
}
/// <summary>
/// 设置散列字段的字符串值
/// </summary>
/// <param name="key">哈希表的键</param>
/// <param name="field">散列字段的键</param>
/// <param name="value">散列字段的值</param>
/// <returns></returns>
public void HashPut(string key, string field, string value)
{
ConnectRedis().GetDatabase().HashSet(key, new HashEntry[] { new HashEntry(field, value) });
}
/// <summary>
/// 仅当字段不存在时，才设置散列字段的值
/// </summary>
/// <param name="key">哈希表的键</param>
/// <param name="field">散列字段的键</param>
/// <param name="value">散列字段的值</param>
/// <returns></returns>
public void HashPutIfAbsent(string key, string field, string value)
{
if (!HashHasKey(key, field))
{
ConnectRedis().GetDatabase().HashSet(key, new HashEntry[] { new HashEntry(field, value) });
}
}
/// <summary>
/// 获取哈希表中的所有值
/// </summary>
/// <param name="key">哈希表的键</param>
/// <returns>该哈希表中的所有值</returns>
public string[] HashValues(string key)
{
return ConnectRedis().GetDatabase().HashValues(key).ToStringArray();
}
/// <summary>
/// 从redis中获取指定键的值并返回对象
/// </summary>
/// <typeparam name="T">要获取的对象类型</typeparam>
/// <param name="key">哈希表的键</param>
/// <returns>指定类型的对象</returns>
public T GetHashValue<T>(string key)
{
HashEntry[] array = ConnectRedis().GetDatabase().HashGetAll(key);
Dictionary<string, object> dic = new Dictionary<string, object>();
for (int i = 0; i < array.Length; i++)
{
dic.Add(array[i].Name, array[i].Value);
}
string strJson = JsonConvert.SerializeObject(dic);
return JsonConvert.DeserializeObject<T>(strJson);
}
/// <summary>
/// 把指定对象存储在键为key的哈希表中
/// </summary>
/// <typeparam name="T">要存储的对象类型</typeparam>
/// <param name="t">要存储的对象实例</param>
/// <param name="key">哈希表的键</param>
public void SetHashValue<T>(T t, string key)
{
string strJson = JsonConvert.SerializeObject(t);
Dictionary<string, string> param = JsonConvert.DeserializeObject<Dictionary<string, string>>(strJson);
HashPutAll(key, param);
}
#endregion
#region redis 列表（List）操作
/// <summary>
/// 从左向右存压栈
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <returns>返回操作后列表的长度</returns>
public long ListLeftPush(string key, string value)
{
return ConnectRedis().GetDatabase().ListLeftPush(key, value);
}
/// <summary>
/// 从左出栈
/// </summary>
/// <param name="key">键</param>
/// <returns>返回出栈的元素值，若列表为空则返回null</returns>
public object ListLeftPop(string key)
{
return ConnectRedis().GetDatabase().ListLeftPop(key);
}
/// <summary>
/// 从右向左存压栈
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <returns>返回操作后列表的长度</returns>
public long ListRightPush(string key, string value)
{
return ConnectRedis().GetDatabase().ListRightPush(key, value);
}
/// <summary>
/// 从右出栈
/// </summary>
/// <param name="key">键</param>
/// <returns>返回出栈的元素值，若列表为空则返回null</returns>
public object ListRightPop(string key)
{
return ConnectRedis().GetDatabase().ListRightPop(key);
}
/// <summary>
/// 队/栈长
/// </summary>
/// <param name="key">键</param>
/// <returns>返回列表的长度</returns>
public long ListSize(string key)
{
return ConnectRedis().GetDatabase().ListLength(key);
}
/// <summary>
/// 范围检索,返回List
/// </summary>
/// <param name="key">键</param>
/// <param name="start">起始索引</param>
/// <param name="end">结束索引</param>
/// <returns>返回指定索引范围内的元素列表</returns>
public string[] ListRange(string key, int start, int end)
{
return ConnectRedis().GetDatabase().ListRange(key, start, end).ToStringArray();
}
/// <summary>
/// 移除key中值为value的i个,返回删除的个数；如果没有这个元素则返回0
/// </summary>
/// <param name="key">键</param>
/// <param name="value">要删除的元素值</param>
/// <returns>返回成功删除的元素个数</returns>
public long ListRemove(string key, string value)
{
return ConnectRedis().GetDatabase().ListRemove(key, value);
}
/// <summary>
/// 检索
/// </summary>
/// <param name="key">键</param>
/// <param name="index">索引</param>
/// <returns>返回指定索引位置的元素值</returns>
public object ListIndex(string key, long index)
{
return ConnectRedis().GetDatabase().ListGetByIndex(key, index);
}
/// <summary>
/// 赋值
/// </summary>
/// <param name="key">键</param>
/// <param name="index">索引</param>
/// <param name="value">要设置的元素值</param>
/// <returns></returns>
public void ListSet(string key, int index, string value)
{
ConnectRedis().GetDatabase().ListSetByIndex(key, index, value);
}
/// <summary>
/// 裁剪,删除除了[start,end]以外的所有元素
/// </summary>
/// <param name="key">键</param>
/// <param name="start">起始索引</param>
/// <param name="end">结束索引</param>
/// <returns></returns>
public void ListTrim(string key, int start, int end)
{
ConnectRedis().GetDatabase().ListTrim(key, start, end);
}
/// <summary>
/// 将源key的队列的右边的一个值删除，然后塞入目标key的队列的左边，返回这个值
/// </summary>
/// <param name="sourceKey">源键</param>
/// <param name="destinationKey">目标键</param>
/// <returns>返回移动的元素值</returns>
public object ListRightPopAndLeftPush(string sourceKey, string destinationKey)
{
return ConnectRedis().GetDatabase().ListRightPopLeftPush(sourceKey, destinationKey);
}
#endregion
#region redis 集合（Set）操作
/// <summary>
/// 集合添加元素
/// 需要注意的是，如果指定的 Redis 集合不存在，则会自动创建。另外，该方法不会返回任何结果，只会将元素添加到 Redis 集合中。如果需要检查元素是否添加成功，可以使用集合中的成员数量进行判断。
/// </summary>
/// <param name="key">集合的键</param>
/// <param name="value">要添加的元素</param>
public void SetAdd(string key, string value)
{
ConnectRedis().GetDatabase().SetAdd(key, value);
}
/// <summary>
/// 根据指定操作，对多个集合执行组合操作并返回结果。
/// </summary>
/// <param name="point">指定组合操作类型。0表示求并集，1表示求交集，2表示求差集。</param>
/// <param name="firstKey">第一个集合的键名。</param>
/// <param name="secondKey">第二个集合的键名。</param>
/// <returns>组合操作的结果数组。</returns>
public string[] SetCombine(int point, string firstKey, string secondKey)
{
RedisValue[] array;
switch (point)
{
case 0:
array = ConnectRedis().GetDatabase().SetCombine(SetOperation.Union, firstKey, secondKey);
break;
case 1:
array = ConnectRedis().GetDatabase().SetCombine(SetOperation.Intersect, firstKey, secondKey);
break;
case 2:
array = ConnectRedis().GetDatabase().SetCombine(SetOperation.Difference, firstKey, secondKey);
break;
default:
array = new RedisValue[0];
break;
}
return array.ToStringArray();
}
/// <summary>
/// 返回对应键值集合的长度
/// </summary>
/// <param name="key">集合的键</param>
/// <returns>集合长度</returns>
public long SetLength(string key)
{
return ConnectRedis().GetDatabase().SetLength(key);
}
/// <summary>
/// 根据键值返回集合中所有的value
/// </summary>
/// <param name="key">集合的键</param>
/// <returns>集合中所有的元素</returns>
public string[] SetMembers(string key)
{
return ConnectRedis().GetDatabase().SetMembers(key).ToStringArray();
}
/// <summary>
/// 将成员从源集移动到目标集
/// </summary>
/// <param name="sourceKey">源集的键</param>
/// <param name="destinationKey">目标集的键</param>
/// <param name="value">要移动的元素</param>
/// <returns>如果元素移动成功，则返回 true；否则返回 false。</returns>
public bool SetMove(string sourceKey, string destinationKey, string value)
{
return ConnectRedis().GetDatabase().SetMove(sourceKey, destinationKey, value);
}
/// <summary>
/// 检查指定的 Set 集合中是否包含指定的值。
/// </summary>
/// <param name="key">Set 集合的键。</param>
/// <param name="value">要检查的值。</param>
/// <returns>如果集合中包含指定的值，则返回 true；否则返回 false。</returns>
public bool SetContains(string key, string value)
{
return ConnectRedis().GetDatabase().SetContains(key, value);
}
/// <summary>
/// 移除集合中指定键值随机元素
/// </summary>
/// <param name="key">集合的键值</param>
/// <returns>返回被移除的元素</returns>
public string SetPop(string key)
{
return ConnectRedis().GetDatabase().SetPop(key);
}
/// <summary>
/// 返回集合中指定键值随机元素
/// </summary>
/// <param name="key">集合的键值</param>
/// <returns>返回指定键值集合的随机元素</returns>
public string SetRandomMember(string key)
{
return ConnectRedis().GetDatabase().SetRandomMember(key);
}
/// <summary>
/// 返回集合中指定键值随机元素
/// </summary>
/// <param name="key">集合的键值</param>
/// <param name="count">要返回的元素数量</param>
/// <returns>返回指定键值集合的随机元素</returns>
public string[] SetRandomMembers(string key, long count)
{
return ConnectRedis().GetDatabase().SetRandomMembers(key, count).ToStringArray();
}
/// <summary>
/// 移除集合中指定key值和value
/// </summary>
/// <param name="key">集合的键值</param>
/// <param name="value">要移除的元素值</param>
public void SetRemove(string key, string value)
{
ConnectRedis().GetDatabase().SetRemove(key, value);
}
/// <summary>
/// 迭代集合中的元素
/// </summary>
/// <param name="key">集合的键值</param>
public void SetScan(string key)
{
ConnectRedis().GetDatabase().SetScan(key);
}
#endregion
#region redis 有序集合（sorted set）操作
/// <summary>
/// 向指定的有序集合中添加一个元素。
/// </summary>
/// <param name="key">有序集合的键。</param>
/// <param name="value">要添加的元素的值。</param>
/// <param name="score">要添加的元素的分值。</param>
public void Method(string key, string value, double score)
{
// 将指定的元素添加到有序集合中，并设置其分值
ConnectRedis().GetDatabase().SortedSetAdd(key, new SortedSetEntry[] { new SortedSetEntry(value, score) });
}
#endregion
}
}编写配置文件：
<configuration>
<connectionStrings>
<add name="RedisConnectionStr" connectionString="localhost:6379,password=123456,defaultDatabase=0,ssl=False,abortConnect=False,connectTimeout=5000,syncTimeout=5000,asyncTimeout=5000" />
</connectionStrings>
</configuration>
调用测试
RedisHelper redisHelper = new RedisHelper();
Console.WriteLine(">>>>>>>>>>>>>>>>字符串>>>>>>>>>>>>>>>>>");
//放一个字符串
redisHelper.StringSet("test", "test", TimeSpan.FromMinutes(10));
//取出字符串
Console.WriteLine("test" + ": " + redisHelper.StringGet("test"));
Console.WriteLine(">>>>>>>>>>>>>>>>集合>>>>>>>>>>>>>>>>>");
//放一个集合
redisHelper.SetAdd("testList", "list");
redisHelper.SetAdd("testList", "list1");
redisHelper.SetAdd("testList", "list2");
var members = redisHelper.SetMembers("testList");
foreach (var item in members)
{
Console.WriteLine("testList" + ": " + item);
}
List<string> list = new List<string>();
list.Add("list");
list.Add("list1");
list.Add("list2");
redisHelper.SetRedisCache("testList1", list, TimeSpan.FromMinutes(10));
var redisCache = redisHelper.GetRedisCache<List<string>>("testList1");
foreach (var item in redisCache)
{
Console.WriteLine("testList1" + ": " + item);
}
//放一个list
redisHelper.ListRightPush("testList2", "test1");
redisHelper.ListRightPush("testList2", "test2");
redisHelper.ListRightPush("testList2", "test3");
//取出list
var list1 = redisHelper.ListRange("testList2", 0, 2);
foreach (var item in list1)
{
Console.WriteLine("testList2" + ": " + item);
}
Console.WriteLine(">>>>>>>>>>>>>>>>哈希>>>>>>>>>>>>>>>>>");
//存一个hash
Dictionary<string, string> hashData = new Dictionary<string, string>()
{
{ "name", "John" },
{ "age", "30" },
{ "gender", "male" }
};
redisHelper.SetRedisCache("testHash", hashData, TimeSpan.FromMinutes(10));
//从Redis中获取哈希表数据
Dictionary<string, string> hashData1 = redisHelper.GetRedisCache<Dictionary<string, string>>("testHash");
foreach (KeyValuePair<string, string> entry in hashData1)
{
Console.WriteLine(entry.Key + ": " + entry.Value);
}结果：
总结
在.NET中使用Redis缓存是一种非常常见的需求。本文介绍了如何在C#中使用Redis，包括连接Redis，设置和获取键值对的最佳实践。希望这些实践对.NET开发者在使用Redis缓存时有所帮助。
扫一扫
660
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
