C# WebSocket(Fleck) 客户端:html Winfrom

已于 2024-08-13 18:27:25 修改
阅读量1w 收藏 66
点赞数 12
分类专栏： C# 文章标签： websocket c#
于 2022-10-08 20:17:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38693757/article/details/127193349
版权

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

有bug，不推荐使用

一、简介

WebSocket 是一种在单个TCP连接上进行全双工通信的协议。WebSocket 通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。

WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

Websocket 用法和 TCP 协议差不多，在这里我用 C# 写服务器端， html 和 winform 作为客户端。

二、服务端

1.新建项目

新建一个控制台项目

在 NuGet 引入  Fleck 插件

2.WebSocketHelper

新建 WebSocketHelper.cs

代码

using Fleck;

namespace WebSocket
{
    internal class WebSocketHelper
    {
        //客户端url以及其对应的Socket对象字典
        IDictionary<string, IWebSocketConnection> dic_Sockets = new Dictionary<string, IWebSocketConnection>();
        //创建一个 websocket ,0.0.0.0 为监听所有的的地址
        WebSocketServer server = new WebSocketServer("ws://0.0.0.0:30000");

        //打开连接委托
        public delegate void _OnOpen(string ip);
        public event _OnOpen OnOpen;
        //关闭连接委托
        public delegate void _OnClose(string ip);
        public event _OnClose OnClose;
        //当收到消息
        public delegate void _OnMessage(string ip, string msg);
        public event _OnMessage OnMessage;

        /// <summary>
        /// 初始化
        /// </summary>
        private void Init()
        {
            //出错后进行重启
            server.RestartAfterListenError = true;

            //开始监听
            server.Start(socket =>
            {
                //连接建立事件
                socket.OnOpen = () =>
                {
                    //获取客户端网页的url
                    string clientUrl = socket.ConnectionInfo.ClientIpAddress + ":" + socket.ConnectionInfo.ClientPort;
                    dic_Sockets.Add(clientUrl, socket);
                    if (OnOpen != null) OnOpen(clientUrl);
                    Console.WriteLine(DateTime.Now.ToString() + " | 服务器:和客户端:" + clientUrl + " 建立WebSock连接！");
                };

                //连接关闭事件
                socket.OnClose = () =>
                {
                    string clientUrl = socket.ConnectionInfo.ClientIpAddress + ":" + socket.ConnectionInfo.ClientPort;
                    //如果存在这个客户端,那么对这个socket进行移除
                    if (dic_Sockets.ContainsKey(clientUrl))
                    {
                        dic_Sockets.Remove(clientUrl);
                        if (OnClose != null) OnClose(clientUrl);
                    }
                    Console.WriteLine(DateTime.Now.ToString() + " | 服务器:和客户端:" + clientUrl + " 断开WebSock连接！");
                };

                //接受客户端网页消息事件
                socket.OnMessage = message =>
                {
                    string clientUrl = socket.ConnectionInfo.ClientIpAddress + ":" + socket.ConnectionInfo.ClientPort;
                    Receive(clientUrl, message);
                    if (OnMessage != null) 
                        OnMessage(clientUrl, message);
                };
            });
        }

        /// <summary>
        /// 向客户端发送消息
        /// </summary>
        /// <param name="webSocketConnection">客户端实例</param>
        /// <param name="message">消息内容</param>
        public void Send(string clientUrl, string message)
        {
            IWebSocketConnection webSocketConnection = GetUserSocketInstance(clientUrl);
            if (webSocketConnection != null)
            {
                if (webSocketConnection.IsAvailable)
                {
                    webSocketConnection.Send(message);
                }
            }
        }

        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="clientUrl"></param>
        /// <param name="message"></param>
        private void Receive(string clientUrl, string message)
        {
            Console.WriteLine(DateTime.Now.ToString() + " | 服务器:【收到】来客户端:" + clientUrl + "的信息：\n" + message);
        }

        /// <summary>
        /// 获取用户实例
        /// </summary>
        /// <param name="clientUrl">用户的地址</param>
        public IWebSocketConnection GetUserSocketInstance(string clientUrl)
        {
            if (dic_Sockets.ContainsKey(clientUrl))
                return dic_Sockets[clientUrl];
            else
                return null;
        }

        /// <summary>
        /// 关闭某一个用户的连接
        /// </summary>
        /// <param name="clientUrl"></param>
        public void CloseUserConnect(string clientUrl)
        {
            IWebSocketConnection webSocketConnection = GetUserSocketInstance(clientUrl);
            if (webSocketConnection != null)
                webSocketConnection.Close();
        }

        /// <summary>
        /// 关闭与客户端的所有的连接
        /// </summary>
        public void CloseAllConnect()
        {
            foreach (var item in dic_Sockets.Values)
            {
                if (item != null)
                {
                    item.Close();
                }
            }
        }

        public WebSocketHelper()
        {
            Init();
        }
    }
}

3.Program

目前并没有写入太多功能，只是加了控制台输入文字，然后转发给所有连接的用户

代码

using WebSocket;

namespace WebSocketNet6
{
    internal class Program
    {
        private static List<string> IPList = new List<string>();
        private static WebSocketHelper WebSocketHelpers = new WebSocketHelper();

        static void Main(string[] args)
        {
            WebSocketHelpers.OnOpen += WebSocketHelper_OnOpen;
            WebSocketHelpers.OnClose += WebSocketHelper_OnClose;
            WebSocketHelpers.OnMessage += WebSocketHelper_OnMessage;

            while (true)
            {
                //监听控制台的输入
                string? contetn = Console.ReadLine();
                if (contetn != null)
                {
                    Relay(contetn);

                    if (contetn.Equals("q"))
                    {
                        WebSocketHelpers.CloseAllConnect();
                        Console.WriteLine("关闭所有客户端的连接");
                        break;
                    }
                }
                Thread.Sleep(10);
            }
        }

        #region WebSocket回调

        //当收到消息
        private static void WebSocketHelper_OnMessage(string ip, string msg)
        {
            for (int i = 0; i < IPList.Count; i++)
            {
                if (IPList[i] != ip)
                {
                    WebSocketHelpers.Send(IPList[i], msg);
                }
            }
        }

        //当客户端断开连接
        private static void WebSocketHelper_OnClose(string ip)
        {
            if (IPList.Contains(ip))
            {
                IPList.Remove(ip);
            }
        }

        //当客户端连接上服务器
        private static void WebSocketHelper_OnOpen(string ip)
        {
            if (!IPList.Contains(ip))
            {
                IPList.Add(ip);
            }
        }

        #endregion

        //转发所有客户端
        private static void Relay(string content)
        {
            if (IPList.Count == 0)  return;

            for (int i = 0; i < IPList.Count; i++)
            {
                WebSocketHelpers.Send(IPList[i], content);
            }
        }
    }
}

三、客户端

1.html


<!DOCTYPE  HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
    <title>websocket client</title>
    <script type="text/javascript">
        var start = function () {
            var inc = document.getElementById('incomming');
            var wsImpl = window.WebSocket || window.MozWebSocket;
            var form = document.getElementById('sendForm');
            var input = document.getElementById('sendText');
 
            inc.innerHTML += "连接服务器..<br/>";
 
            // 创建一个新的websocket并连接
            window.ws = new wsImpl('ws://localhost:30000/');
 
            // 当数据来自服务器时，将调用此方法
            ws.onmessage = function (evt) {
                inc.innerHTML += ("[来自服务器的消息] " + evt.data + '<br/>');
                console.log("[来自服务器的消息] " + evt.data);
            };
 
            // 当建立连接时，将调用此方法
            ws.onopen = function () {
                inc.innerHTML += '已建立连接.. <br/>';
            };
 
            // 当连接关闭时，将调用此方法
            ws.onclose = function () {
                inc.innerHTML += '连接已关闭.. <br/>';
            }
 
            form.addEventListener('submit', function (e) {
                e.preventDefault();
                var val = input.value;
                ws.send(val);
                input.value = "";
            });
        }
        window.onload = start;
    </script>
</head>
<body>
    <form id="sendForm">
        <span>输入内容按回车发送消息</span> <br/>
        <input id="sendText" placeholder="Text to send" />
    </form>
    <pre id="incomming"></pre>
</body>
</html>

在本地新建一个 文本文档，将名字改为 index.html ，然后将上面的代码复制进去。

先打开上面的 Webscoket 服务器，用浏览器打开 index.html，

然后服务器端就会收到对于的消息了

服务器发送 你好

同样的，网页端也收到了来自服务器的消息

那么这样，就完成了网页端的通信了

2.Winform

新建一个 winform 项目

先安装插件 SuperSocket.ClientEngine

再安装插件 WebSocket4Net

新建脚本 WSocketClient.cs

using SuperSocket.ClientEngine;
using System;
using System.Threading;
using System.Threading.Tasks;
using WebSocket4Net;

namespace WebSocketClient
{
    public class WSocketClient : IDisposable
    {
        //收到消息后的回调
        //public event Action<string> MessageReceived;
        public Action<string> MessageReceived;

        private WebSocket4Net.WebSocket _webSocket;

        /// <summary>
        /// 检查重连线程
        /// </summary>
        Thread _thread;
        bool _isRunning = false;

        /// <summary>
        /// 是否在运行中
        /// </summary>
        public bool IsRunning => _isRunning;

        /// <summary>
        /// WebSocket连接地址
        /// </summary>
        public string ServerPath { get; set; }

        public WSocketClient(string url)
        {
            ServerPath = url;
            this._webSocket = new WebSocket4Net.WebSocket(url);
            this._webSocket.Opened += WebSocket_Opened;
            this._webSocket.Error += WebSocket_Error;
            this._webSocket.Closed += WebSocket_Closed;
            this._webSocket.MessageReceived += WebSocket_MessageReceived;
        }

        /// <summary>
        /// 连接方法
        /// <returns></returns>
        public bool Start()
        {
            bool result = true;
            try
            {
                this._webSocket.Open();
                this._isRunning = true;
                this._thread = new Thread(new ThreadStart(CheckConnection));
                this._thread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                result = false;
                this._isRunning = false;
            }
            return result;
        }

        /// <summary>
        /// 消息收到事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
        {
            Console.WriteLine("Received:" + e.Message);

            if (MessageReceived != null)
                MessageReceived(e.Message);
        }

        /// <summary>
        /// Socket关闭事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WebSocket_Closed(object sender, EventArgs e)
        {
            Console.WriteLine("websocket_Closed");
        }

        /// <summary>
        /// Socket报错事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WebSocket_Error(object sender, ErrorEventArgs e)
        {
            Console.WriteLine("websocket_Error:" + e.Exception.ToString());
        }

        /// <summary>
        /// Socket打开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WebSocket_Opened(object sender, EventArgs e)
        {
            Console.WriteLine("websocket_Opened");
        }

        /// <summary>
        /// 检查重连线程
        /// </summary>
        private void CheckConnection()
        {
            do
            {
                try
                {
                    if (this._webSocket.State != WebSocket4Net.WebSocketState.Open && this._webSocket.State != WebSocket4Net.WebSocketState.Connecting)
                    {
                        Console.WriteLine("Reconnect websocket WebSocketState:" + this._webSocket.State);

                        this._webSocket.Close();
                        this._webSocket.Open();

                        Console.WriteLine("正在重连");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
                System.Threading.Thread.Sleep(5000);
            } while (this._isRunning);
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="Message"></param>
        public void SendMessage(string Message)
        {
            Task.Factory.StartNew(() =>
            {
                if (_webSocket != null && _webSocket.State == WebSocket4Net.WebSocketState.Open)
                {
                    this._webSocket.Send(Message);
                }
            });
        }

        public void Dispose()
        {
            try
            {
                _thread?.Abort();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            this._webSocket.Close();
            this._webSocket.Dispose();
            this._webSocket = null;
            this._isRunning = false;
        }
    }
}

winfrom 界面如下

Form1.cs

using System;
using System.Windows.Forms;
using WebSocketClient;

namespace WinFormWebsocket
{
    public partial class Form1 : Form
    {
        private static string url = "ws://127.0.0.1:30000";
        private WSocketClient client = new WSocketClient(url);

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
            txtServerIP.Text = url;
            client.MessageReceived = MessageReceived;
            this.Text = "客户端";
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if(client.IsRunning)
                client.Dispose();
        }

        /// <summary>
        /// 连接服务器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                if(client.IsRunning)
                {
                    AddOrdinaryLog("已经连接服务器，不能重复执行");
                    return;
                }

                bool result = client.Start();
                AddOrdinaryLog("连接是否成功：" + result);
            }
            catch (Exception ex)
            {
                string err = string.Format("连接失败：{0}", ex.Message);
                Console.WriteLine(err);
                throw;
            }
        }

        /// <summary>
        /// 关闭服务器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnClose_Click(object sender, EventArgs e)
        {
            if (!client.IsRunning)
            {
                AddOrdinaryLog("服务器未连接");
                return;
            }

            // 记得释放资源否则会造成堆栈
            client.Dispose();
            AddOrdinaryLog("连接已关闭");
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSendMsg_Click(object sender, EventArgs e)
        {
            string inputMsg = txtInputMsg.Text;
            if (string.IsNullOrEmpty(inputMsg))
            {
                MessageBox.Show("输入框不能为空");
                return;
            }

            client.SendMessage(inputMsg);
            AddOrdinaryLog(inputMsg);
            txtInputMsg.Text = string.Empty;
        }

        /// <summary>
        /// 服务端返回的消息
        /// </summary>
        private void MessageReceived(string msg)
        {
            AddOrdinaryLog(msg);
        }

        /// <summary>
        /// 添加日志
        /// </summary>
        /// <param name="content"></param>
        private void AddOrdinaryLog(string content)
        {
            //读取当前ListBox列表长度
            int len = ListBox_OrdinaryLogList.Items.Count;
            //插入新的一行
            ListBox_OrdinaryLogList.Items.Insert(len, content);
            //列表长度大于30，那么就删除第1行的数据
            if (len > 30)
                ListBox_OrdinaryLogList.Items.RemoveAt(0);
            //插入新的数据后，将滚动条移动到最下面
            int visibleItems = ListBox_OrdinaryLogList.ClientSize.Height / ListBox_OrdinaryLogList.ItemHeight;
            ListBox_OrdinaryLogList.TopIndex = Math.Max(ListBox_OrdinaryLogList.Items.Count - visibleItems + 1, 0);
        }
    }
}

到这里，所有的准备工作都做完了，下面就来测试一下效果吧。

首先，运行 WebSocket 服务器端，再运行客户端，点击连接按钮

服务器端也显示有客户端连接上了。

那么现在用客户端发送消息，输入恭喜发财，然后点击 发送消息 按钮，这时历史消息列表就有对于的记录。

这时，服务器端也同样的收到了来自客户端的消息。

接下来，我们用服务器向客户端发送消息，在控制台输入文字后，按回车，会自动发送

客户端收到了来自服务器的消息

 

 这样，就完成了通讯部分的基本功能了。

 源码：点击下载

结束

如果这个帖子对你有用，欢迎 关注 + 点赞 + 留言，谢谢

end

熊思宇
关注
专栏目录
使用Fleck和WebSocketSharp实现WebStock通信
07-16
使用Fleck和WebSocketSharp实现WebStock通信,仅为客户端与服务端之间的通信,正在升级为客户端与客户端之间的通信,可以关注我的信息.
C# WebSocket Client
08-30
C#编写的基于WebSocket winform客户端Demo源码，实现连接、收到消息、关闭事件。适合初学者参考。需要DotNet4.5框架
C# 中使用 WebSocket 的技术探索
最新发布
dotNET跨平台
07-25 408
WebSocket 是一种网络通信协议，提供了浏览器和服务器之间的全双工通信渠道。与传统的 HTTP 请求相比，WebSocket 允许服务器主动发送信息给客户端，实现真正的实时双向交互。在 C# 中，我们可以使用 .NET Framework 或 .NET Core 来实现 WebSocket 通信。本文将深入探讨在 C# 中如何使用 WebSocket 进行开发。一、WebSocket 基础W...
C# web socket 客户端实现源码
08-09
使用C#编写，web socket客户端连接源码，可用于性能测试。
[C#] WebSocket 客户端+服务端 轻松实现
热门推荐
wabil的专栏
07-05 4万+
转自:http://www.cnblogs.com/zhuweisky/p/3930780.html 　随着HTML5 WebSocket技术的日益成熟与普及，我们可以借助WebSocket来更加方便地打通BS与CS -- 因为B/S中的WebSocket可以直接连接到C/S的服务端，并进行双向通信。如下图所示： 　　 一.对Socket Server的要求
【C#】WebSoket 演示（使用websocket-sharp库）
cxyhjl的博客
05-10 3388
Example 3服务器+ Example1 客户端示例3此源代码片段包含了如何使用WebSocketSharp库来创建一个HTTP服务器，并提供WebSocket服务。 分析整个代码，我们可以归纳出以下关键信息：导入了一系列重要的命名空间，包括系统配置、加密库、文本、WebSocket等。定义了Example3名称空间和包含Main方法的Program类，作为HTTP服务器和WebSocket服...
C# WebSocket
01-24
可以直接跑通！打不开请用visual studio 2017 这句必须有
C#实现WebSocket源码（c#写的服务端html写的客户端）
12-21
C#实现WebSocket源码（c#写的服务端html写的客户端） WebSocket 协议在2008年诞生，2011年成为国际标准。所有浏览器都已经支持了。 它的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于服务器推送技术的一种。 其他特点包括： （1）建立在 TCP 协议之上，服务器端的实现比较容易。 （2）与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。 （3）数据格式比较轻量，性能开销小，通信高效。 （4）可以发送文本，也可以发送二进制数据。 （5）没有同源限制，客户端可以与任意服务器通信。 （6）协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。
【C#】WebSocket
在这里你大概率会有所收获，欢迎指错||纠正||建议||水评+点赞&&评论&&关注&&转发
07-03 1196
在C#中，`WebSocket` 是一种网络通信协议，它允许在单个持久连接上进行全双工通信（即，数据可以在同一时间双向流动）。在.NET中，有几个库和API可以用来实现WebSocket客户端和服务端。
C# websocket
11-07
vs2015 websocket 实现通信。支持广播，私信。windows平台测试通过。
C#WebSocket客户端及服务端Demo源代码
03-13
C#WebSocket客户端及服务端Demo，服务端采用SocketTCP通讯，WebSocket通讯与传统通讯的差异就是多了一些消息解析，详情见服务端源代码！
Fleck:C＃Websocket实现
05-11
斑点 Fleck是C＃中的WebSocket服务器实现。 从项目分支出来的Fleck不需要继承，容器或其他引用。 Fleck不依赖于HttpListener或HTTP.sys ，这意味着它将在Windows 7和Server 2008主机上运行。 例子 以下是将回显到客户端的示例。 var server = new WebSocketServer ( " ws://0.0.0.0:8181 " ); server . Start ( socket => { socket . OnOpen = () => Console . WriteLine ( " Open! " ); socket . OnClose = () => Console . WriteLine ( " Close! " ); socket . OnMessage = message => socket
C# webSocket
01-19
WebSocket协议是基于TCP的一种新的网络协议，WebSocket通信协议于2011年被IETF定为标准RFC 6455，并被RFC7936所补充规范。
C# WebSocket实例
08-15
这个是我压箱底的，哈哈可能分比较高一点， 但是值。 其中包含两个场景的实例，txt文本相关步骤和说明。。。
C# WebSocket(Fleck) 客户端html Winfrom
10-08
本篇文章将详细探讨C#如何利用Fleck库创建WebSocket客户端，并与HTML页面以及Windows Forms应用程序进行交互。 1. **Fleck库介绍** Fleck是一个轻量级的C# WebSocket服务器和客户端库，由Joshua Granick开发。它的...
winform调用websocket_使用C#实现websocket服务端与客户端通信
weixin_32818917的博客
01-13 6337
一、websocket简介websocket是一种在单个TCP连接上进行全双工通信的协议。websocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。二、背景很多网站为了实现推送技术，所用的技术都是轮询。轮询是在特定的时间间隔，由浏览器对客户...
C# WebSocket 服务端接收并返回消息给客户端js
weixin_41561640的博客
05-25 2984
接手一个小项目，要求在页面控制电磁阀的开启关闭。采用WebSocket传递消息，临时做个demo来测试场景。 1、首先写js中的部分代码： //通讯“套接字” var socket; switchLCBFun(); function switchLCBFun() { //var host = "ws://" + $("#HFCtrlIP").val() + ":" + $("#HFCtrlPort").val() + "/"; var host
c# websocket
08-18
C#中可以使用WebSocket来实现与服务器进行全双工通信的功能。WebSocket是HTML5下的一种新协议，它是基于TCP的协议，能够在浏览器和服务器之间实现实时通信，同时能够节省服务器资源和带宽。WebSocket是一个持久化的协议，支持长连接。在C#中，可以使用System.Net.WebSockets命名空间下的类来实现WebSocket的功能。通过创建WebSocket对象，连接到服务器，并发送和接收数据来进行通信。需要注意的是，WebSocket也需要进行握手过程来建立连接，但相对于HTTP协议，WebSocket的网络开销较小，并且能够降低延迟。此外，WebSocket协议有两种形式，即WS和WSS，分别代表明文和密文的WebSocket协议，对应的默认端口分别是80和443。C#中可以根据实际需要选择使用WS或WSS协议来进行通信。总而言之，使用C#的WebSocket可以方便地实现与服务器进行实时双向通信的功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C# Websocket连接(wss)](https://blog.csdn.net/lvxingzhe3/article/details/124904887)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊思宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值