Windows安装Redis,C#简易交互

已于 2023-01-12 15:58:46 修改
阅读量261 收藏
点赞数
分类专栏： 经验分享 文章标签： redis
于 2023-01-06 08:45:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36694133/article/details/128573005
版权
文章详细介绍了如何在Windows上下载并安装Redis，创建批处理文件启动服务，以及在VS2019中创建C#窗体应用，使用.NETFramework4.7.2和ServiceStack.Redis库进行Redis的连接、操作和断开。示例代码包括了Redis服务的启停、连接、数据操作等功能。
摘要由CSDN通过智能技术生成

1.在网址【https://github.com/microsoftarchive/redis/releases】进行下载msi文件，下载完毕直接安装即可。

2.安装完毕后，在其安装目录【本人安装在F盘下】添加一个bat文件，内容为

redis-server.exe redis.windows.conf

以便我们双击此批处理命令就能方便启动redis服务端

3.VS2019创建窗体应用程序，框架选用.net framework 4.7.2

4.简单设计一下界面

5.Nuget包安装【ServiceStack.Redis】库 

6.添加一个类文件RedisUtil.cs

using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RedisDemo
{
    public class RedisUtil
    {
        public RedisClient client = null;

        /// <summary>
        /// 开启redis服务
        /// </summary>
        /// <returns></returns>
        public bool Start()
        {
            if (Process.GetProcessesByName("redis-server.exe").Length > 0)
            {
                return false;
            }
            Process process = new Process();
            process.StartInfo.WorkingDirectory = @"F:\Redis";
            process.StartInfo.FileName = @"F:\Redis\startup.bat";
            process.StartInfo.CreateNoWindow = false;
            process.StartInfo.UseShellExecute = false;
            process.Start();
            return true;
        }

        /// <summary>
        /// 关闭redis服务
        /// </summary>
        /// <returns></returns>
        public bool Close()
        {
            bool flag = false;
            foreach (Process process in Process.GetProcesses())
            {
                if (process.ProcessName.Contains("redis-server"))
                {
                    process.Kill();
                    flag = true;
                }
            }
            return flag;
        }

        /// <summary>
        /// 连接redis服务
        /// </summary>
        /// <returns></returns>
        public void Connect()
        {
            if (client == null)
            {
                client = new RedisClient("127.0.0.1", 6379);
            }
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            if (client != null)
            {
                client.Quit();
            }
        }

        /// <summary>
        /// 所有键值对
        /// </summary>
        /// <returns></returns>
        public List<string> AllKeyValue()
        {
            IEnumerable<string> keys = client.ScanAllKeys();
            List<string> result = new List<string>();
            foreach (string key in keys)
            {
                string value = "";
                string type = client.Type(key).ToLower();
                int len;
                byte[][] buffer;
                switch (type)
                {
                    case "string":
                        value = client.GetValue(key);
                        break;
                    case "hash":
                        buffer = client.HGetAll(key);
                        value += "{";
                        for (int i = 0; i < buffer.Length; i += 2)
                        {
                            value += $"{Encoding.UTF8.GetString(buffer[i])}={Encoding.UTF8.GetString(buffer[i + 1])}";
                            if (i + 2 < buffer.Length)
                            {
                                value += ",";
                            }
                        }
                        value += "}";
                        break;
                    case "list":
                        len = (int)client.LLen(key);
                        buffer = client.LRange(key, 0, len);
                        value += "[";
                        for (int i = 0; i < buffer.Length; i++)
                        {
                            value += $"{Encoding.UTF8.GetString(buffer[i])}";
                            if (i + 1 < buffer.Length)
                            {
                                value += ",";
                            }
                        }
                        value += "]";
                        break;
                    case "set":
                        buffer = client.SMembers(key);
                        value += "{";
                        for (int i = 0; i < buffer.Length; i++)
                        {
                            value += $"{Encoding.UTF8.GetString(buffer[i])}";
                            if (i + 1 < buffer.Length)
                            {
                                value += ",";
                            }
                        }
                        value += "}";
                        break;
                    case "zset":
                        len = (int)client.ZCard(key);
                        buffer = client.ZRange(key, 0, len);
                        value += "{";
                        for (int i = 0; i < buffer.Length; i++)
                        {
                            value += $"{Encoding.UTF8.GetString(buffer[i])}";
                            if (i + 1 < buffer.Length)
                            {
                                value += ",";
                            }
                        }
                        value += "}";
                        break;
                    default:
                        break;
                }
                result.Add($"type={type},key={key},value={value}");
            }
            return result;
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        public void Add<T>(T t) where T : IAdd
        {
            t.Add(client);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key"></param>
        public void Delete(string key)
        {
            client.Del(key);
        }

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string Search(string key)
        {
            List<string> result = AllKeyValue();
            string pattern = $"key={key}";
            foreach(string keyvalue in result)
            {
                if (keyvalue.Contains(pattern))
                {
                    return keyvalue;
                }
            }
            return "";
        }
    }

    public interface IAdd
    {
        void Add(RedisClient client);
    }

    public class StringItem : IAdd
    {
        public string key;
        public string value;
        public StringItem(string key, string value)
        {
            this.key = key;
            this.value = value;
        }

        public void Add(RedisClient client)
        {
            client.Set(key, value);
        }
    }

    public class HashItem : IAdd
    {
        public string hashId;
        public Dictionary<string, string> pairs = new Dictionary<string, string>();
        public HashItem(string hashId, Dictionary<string, string> pairs)
        {
            this.hashId = hashId;
            this.pairs = pairs;
        }

        public void Add(RedisClient client)
        {
            byte[][] ks = new byte[pairs.Count][];
            byte[][] vs = new byte[pairs.Count][];
            int i = 0;
            foreach (string key in pairs.Keys)
            {
                ks[i] = Encoding.UTF8.GetBytes(key.ToString());
                vs[i] = Encoding.UTF8.GetBytes(pairs[key].ToString());
            }
            client.HMSet(hashId, ks, vs);
        }
    }

    public class ListItem : IAdd
    {
        public string listId;
        public string value;
        public ListItem(string listId, string value)
        {
            this.listId = listId;
            this.value = value;
        }
        public void Add(RedisClient client)
        {
            client.LPush(listId, Encoding.UTF8.GetBytes(value));
        }
    }

    public class SetItem : IAdd
    {
        public string setId;
        public string value;
        public SetItem(string setId, string value)
        {
            this.setId = setId;
            this.value = value;
        }

        public void Add(RedisClient client)
        {
            client.SAdd(setId, Encoding.UTF8.GetBytes(value));
        }
    }

    public class ZSetItem : IAdd
    {
        public string setId;
        public double score;
        public string value;
        public ZSetItem(string setId, double score, string value)
        {
            this.setId = setId;
            this.score = score;
            this.value = value;
        }
        public void Add(RedisClient client)
        {
            client.ZAdd(setId, score, Encoding.UTF8.GetBytes(value));
        }
    }
}

7.给窗体添加事件绑定

using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace RedisDemo
{
    public partial class MainForm : Form
    {
        readonly RedisUtil util = new RedisUtil();

        public MainForm()
        {
            InitializeComponent();

            try
            {
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message+"\n"+exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            comboBox_Type.SelectedIndex = 0;
        }

        private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            try
            {
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Start_Click(object sender, EventArgs e)
        {
            try
            {
                if (util.Start())
                {
                    toolStripStatusLabel.Text = "redis服务端开启成功";
                }
                else
                {
                    toolStripStatusLabel.Text = "redis服务端开启失败";
                }
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "redis服务端开启失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Close_Click(object sender, EventArgs e)
        {
            try
            {
                if (util.Close())
                {
                    toolStripStatusLabel.Text = "redis服务端关闭成功";
                }
                else
                {
                    toolStripStatusLabel.Text = "redis服务端关闭失败";
                }
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "redis服务端关闭失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Connect_Click(object sender, EventArgs e)
        {
            try
            {
                util.Connect();
                toolStripStatusLabel.Text = "redis服务端连接成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "redis服务端连接失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Disconnect_Click(object sender, EventArgs e)
        {
            try
            {
                util.Disconnect();
                toolStripStatusLabel.Text = "连接断开成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "连接断开失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_AllKeyValue_Click(object sender, EventArgs e)
        {
            try
            {
                List<string> result = util.AllKeyValue();
                richTextBox_AllKeyValue.Clear();
                richTextBox_AllKeyValue.AppendText(string.Join("\r\n", result));
                toolStripStatusLabel.Text = "查询所有键值对成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "查询所有键值对失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Add_Click(object sender, EventArgs e)
        {
            try
            {
                string type = comboBox_Type.Text.Trim();
                string id = textBox_Key.Text.Trim();
                string value = "";
                switch (type)
                {
                    case "string":
                        value = richTextBox_Value.Text.Trim();
                        StringItem stringItem = new StringItem(id, value);
                        util.Add(stringItem);
                        break;
                    case "hash":
                        string[] ps = richTextBox_Value.Text.Trim().Split(' ');
                        Dictionary<string, string> pairs = new Dictionary<string, string>();
                        for (int i = 0; i < ps.Length; i += 2)
                        {
                            pairs.Add(ps[i], ps[i + 1]);
                        }
                        HashItem hashItem = new HashItem(id, pairs);
                        util.Add(hashItem);
                        break;
                    case "list":
                        value = richTextBox_Value.Text.Trim();
                        ListItem listItem = new ListItem(id, value);
                        util.Add(listItem);
                        break;
                    case "set":
                        value = richTextBox_Value.Text.Trim();
                        SetItem setItem = new SetItem(id, value);
                        util.Add(setItem);
                        break;
                    case "zset":
                        value = richTextBox_Value.Text.Trim();
                        ZSetItem zSetItem = new ZSetItem(id, 0, value);
                        util.Add(zSetItem);
                        break;
                }
                toolStripStatusLabel.Text = "添加键值对成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "添加键值对失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Search_Click(object sender, EventArgs e)
        {
            try
            {
                string key = textBox_Key.Text.Trim();
                string value = util.Search(key);
                richTextBox_AllKeyValue.Text = value;
                toolStripStatusLabel.Text = "查询键值对成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "查询键值对失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Button_Delete_Click(object sender, EventArgs e)
        {
            try
            {
                string key = textBox_Key.Text.Trim();
                util.Delete(key);
                toolStripStatusLabel.Text = "删除键值对成功";
            }
            catch (Exception exception)
            {
                toolStripStatusLabel.Text = "删除键值对失败";
                MessageBox.Show(exception.Message + "\n" + exception.StackTrace, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

 8.项目我已经上传到码云中【CSharp与Redis交互: 使用C#与Redis数据库简单交互，熟悉Redis的使用】，有需要的同学可以自行下载，仅供参考

氷凌公子
关注
专栏目录
在C#中使用Redis实现高效消息队列
qq_43535970的博客
09-29 843
本文详细介绍了如何在C#中利用Redis实现一个简单而高效的消息队列。通过使用Redis的列表数据结构，我们构建了RedisQueue类，封装了消息的入队和出队操作。文章涵盖了环境准备、代码实现及使用示例，最后还介绍了如何创建一个消费者类来处理消息。Redis的高性能和灵活性使其成为构建现代消息队列的理想选择，适合各种应用场景。
C# Redis交互
01-20
封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法 封装了List,hash,string,sortset通用查询及同异步插入等方法封装了List,hash,string,sortset通用查询及同异步插入等方法封装了List,hash,string,sortset通用查询及同异步插入等方法封装了List,hash,string,sortset通用查询及同异步插入等方法
C# windows redis-2.4.5-win32-win64.rar和redis服务安装软件
07-25
包含windows c# redis安装文件和 redis服务的安装文件
Redis for Windows(C#缓存)安装和使用
weixin_34405925的博客
04-27 154
前言 前段时间写过两篇简单的有关Memcached缓存的相关文章，当然了只是入门的如何使用而已。最近这两天又发现了Redis这个神奇的东西，之前肯定看到过，由于是小菜，还真心没多多注意它是干什么的，不料最近发现原来它也是缓存神器呀，于是自己就来简单的入门学习。 Asp.Net中使用Couchbase——Memcached缓存入门篇http://www.cnblogs.c...
Redis 详细介绍及安装使用教程（含 C# 示例）
最新发布
Hellc007的博客
08-22 961
Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统。它可以用作数据库、缓存和消息代理。Redis 支持多种数据结构，如字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）及范围查询、bitmaps、hyperloglogs 和 geospatial 索引半径查询。性能高：由于 Redis 是基于内存操作的，读写速度非常快。持久化。
C#版-Redis缓存服务器在Windows下的使用
weixin_30612769的博客
02-07 195
Redis缓存服务器是一款key/value数据库，读110000次/s，写81000次/s，因为是内存操作所以速度飞快，常见用法是存用户token、短信验证码等 官网显示Redis本身并没有Windows版本的，微软官方开发了基于Windows的Redis服务器：MSOpenTech/redis 一、Redis服务端 首先下载Redis服务器，点击前往下载.msi版本，双击安装...
windows下c#操作redis类
01-08
windows下c#操作redis类
Redis入门教程（C#）
weixin_33692284的博客
09-03 404
Redis是什么？ Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。 补充概念： 持久化：是将程序数据在持久状态和瞬时状态间转换的机制。通俗的讲，就是瞬时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库中，能够长久保存） Redis的安装、启动： 下载地址：https...
Redis客户端模型与高级特性实现(C#版)
这个客户端库是为了让C#开发者能够在应用程序中轻松地与Redis数据库进行交互。以下是对标题、描述和标签所蕴含知识点的详细说明： 1. **Redis客户端**: Redis客户端是连接和操作Redis服务器的软件组件。该客户端库...
c#+layui毕设邮箱系统.zip
12-28
C#是Microsoft开发的一种面向对象的、类型安全的编程语言，广泛应用于Windows平台的软件开发，而Layui则是一款轻量级的前端UI框架，以其简洁的代码结构和丰富的组件库，深受开发者喜爱。 一、系统架构设计 1. 前端...
C语言简易游戏Cgame.zip
04-15
C#通常用于开发Windows桌面应用程序、Web应用程序、移动应用程序以及游戏开发等领域。C#是.NET框架的一部分，这意味着它可以与其他.NET语言（如Visual Basic .NET、F#等）以及.NET框架中的各种库和工具进行交互使用...
C# Redis 安装与使用
09-03
C# Redis 安装与使用，有服务器端安装包和客户端查看工具。及net调用例子
C# CsRedis的初探（一）--- Redis的安装
Vaccae的博客
12-10 246
Redis简介Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（ha...
Redis安装及C# 调用。
chihen的专栏
09-30 4898
Redis安装及C# 调用。 一、Redis简介 Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供
C# Redis内存数据库的安装和使用教程
kingshown_WZ的专栏
04-27 3176
引言 Redis是一个实时的数据库技术，主要采用键值操作来存储数据的，但支持许多不同类型的值：字符串，列表，集合，排序集，哈希值。 Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类...
C# Redis学习笔记（一）-Windows安装Redis
weixin_41436204的博客
08-08 47
1、Windows安装Redis：  官网未提供Window版的Redis安装包，安装包下载链接：https://github.com/MicrosoftArchive/redis/releases，  备份下载链接：Redis-Win-x64-3.0.504.zip① 下一步下一步，安装完即可。② 在Redis的安装目...
redis-client(windows)
08-20
redis db windows客户端的查看工具，方便开发者进行数据的查看！！
redis的windows版本安装
空白画布
07-31 1433
第二步：完成环境变量配置之后，无需再从Redis目录下打开 cmd 命令行窗口，直接”Win键+R“输入 cmd 打开命令窗口输入命令即可启动Redis服务。打开 cmd 命令窗口，切换到 Redis 安装目录（因为要指定配置文件），执行以下命令将 Redis 注册为系统服务。为了更方便地使用Redis，可以把Redis的路径加到系统的环境变量里，这样就省得再输路径了。将 Redis 注册为系统服务后，系统可以在启动时自动启动 Redis，无需手动启动。第一步：在系统属性弹框中，找到环境变量，点击打开。
【Redis】Redis安装 配置 C#实例
GreAmbWang的博客
08-24 621
REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。 Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Ha...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值