WebApi和WebSocket的调用说明

WebApi和WebSocket的调用说明

WebApi的理解

https://baijiahao.baidu.com/s?id=1726234839855027656&wfr=spider&for=pc

出现的问题：

WebApi通信问题出现Https后面的S（加S需要安全验收有证书繁琐，加入了SSL/TLS协议，SSL/TLS依靠证书来验证服务器的身份，到CA申请证书，一般免费证书较少，因而需要一定费用）
解决：
1.在创建项目的时候选择取消
2.在launchSettings配置里面更改HttpS，Program配置里面删除//app.UseHttpsRedirection();

WebApi的使用

需要安装的Nuget包有：

1.Furion 版本为3.2.2

2.Microsoft.AspNetCore.Mvc.NewtonsoftJson版本为6.0.5

3.Swashbuckle.AspNetCore版本为6.3.1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OQw161ra-1664270387761)(C:\Users\23239\AppData\Roaming\Typora\typora-user-images\image-20220927162249719.png)]

Web页面显示

在Controllers里面添加控制器（T）后缀为Controller格式 编写方法就可以显示

NingJinQiangController类的编写

using Furion.DynamicApiController;
using Microsoft.AspNetCore.Mvc;

namespace MoNiWeb.Controllers
{
    public class NingJinQiangController : IDynamicApiController
    {
        //数据判断类
        TaskService taskService = new TaskService();

        private readonly ILogger<WeatherForecastController> _logger;

        public NingJinQiangController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        [HttpPost]
        //解析JSON     WebApi显示的方法
        public (bool state, string mes) InstructionsTaskExec(TightenTheGunClass dto)
        {
            //判断数据发送是否正确 拿到返回值进行返回
            var res = taskService.InstructionsTaskExec(dto);
            return res;
        }

    }
}

launchSettings.json类的编写

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:9068",
      "sslPort": 0
    }
  },
  "profiles": {
    "MoNiWeb": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "launchUrl": "APIWeb",//更改IP链接的名字
      "applicationUrl": "http://localhost:7037", //本地IP地址
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "launchUrl": "swagger",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Program.cs的编写

using MoNiWeb;
//using Furion.UnifyResult;


var builder = WebApplication.CreateBuilder(args).Inject();

// Add services to the container.
builder.Services.AddControllersWithViews().AddNewtonsoftJson();

builder.Services.AddControllers()
        .AddInjectWithUnifyResult<RESTfulResultProvider>();


builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();



var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

//app.UseHttpsRedirection();

app.UseAuthorization();
app.UseInject("APIWeb"); 
app.MapControllers();

app.Run();

RESTfulResultProvider.cs的编写（RESTful 风格返回值解析JSON返回结果）

using Furion;
using Furion.DataValidation;
using Furion.DependencyInjection;
using Furion.UnifyResult;
using Furion.UnifyResult.Internal;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

namespace MoNiWeb
{
    /// <summary>
    /// RESTful 风格返回值
    /// </summary>
    [SuppressSniffer, UnifyModel(typeof(RESTfulResult<>))]
    public class RESTfulResultProvider : IUnifyResultProvider
    {
        /// <summary>
        /// 异常返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public IActionResult OnException(ExceptionContext context, ExceptionMetadata metadata)
        {
            return new JsonResult(RESTfulResult(metadata.StatusCode, errors: metadata.Errors));
        }
        /// <summary>
        /// 成功返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public IActionResult OnSucceeded(ActionExecutedContext context, object data)
        {
            var aa= new JsonResult(RESTfulResult(StatusCodes.Status200OK, true, data));
            return aa;
        }
        /// <summary>
        /// 验证失败返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public IActionResult OnValidateFailed(ActionExecutingContext context, ValidationMetadata metadata)
        {
            return new JsonResult(RESTfulResult(StatusCodes.Status400BadRequest, errors: metadata.ValidationResult));
        }
        /// <summary>
        /// 特定状态码返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="statusCode"></param>
        /// <param name="unifyResultSettings"></param>
        /// <returns></returns>
        public async Task OnResponseStatusCodes(HttpContext context, int statusCode, UnifyResultSettingsOptions unifyResultSettings)
        {
            // 设置响应状态码
            UnifyContext.SetResponseStatusCodes(context, statusCode, unifyResultSettings);
            switch (statusCode)
            {
                // 处理 401 状态码
                case StatusCodes.Status401Unauthorized:
                    await context.Response.WriteAsJsonAsync(RESTfulResult(statusCode, errors: "401 Unauthorized")
                        , App.GetOptions<JsonOptions>()?.JsonSerializerOptions);
                    break;
                // 处理 403 状态码
                case StatusCodes.Status403Forbidden:
                    await context.Response.WriteAsJsonAsync(RESTfulResult(statusCode, errors: "403 Forbidden")
                        , App.GetOptions<JsonOptions>()?.JsonSerializerOptions);
                    break;
                default: break;
            }
        }
        /// <summary>
        /// 返回 RESTful 风格结果集
        /// </summary>
        /// <param name="statusCode"></param>
        /// <param name="succeeded"></param>
        /// <param name="data"></param>
        /// <param name="errors"></param>
        /// <returns></returns>
        private static RESTfulResult<object> RESTfulResult(int statusCode, bool succeeded = default, object data = default, object errors = default)
        {
            return new RESTfulResult<object>
            {
                StatusCode = statusCode,
                Succeeded = succeeded,
                Data = data,
                Errors = errors,
                Extras = UnifyContext.Take(),
                Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
            };
        }

    }
}

TaskService.cs编写 判断数据发送是否正确 返回值200正确

namespace MoNiWeb
{
    public class TaskService
    {
        /// <summary>
        /// 数据判断发送的是否正确
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public (bool state, string mes) InstructionsTaskExec(TightenTheGunClass dto)
        {
            if (dto == null)
            {
                return (false, "未传入有效数据。");
            }
            if (dto.Code==200)
            {
               return (true,"这是一条测试数据");
           }

            return (true, $"结果正确");
        }
    }
}

TightenTheGunClass编写实体类

namespace MoNiWeb
{
    /// <summary>
    /// 实体类
    /// </summary>
    public class TightenTheGunClass
    {
        /// <summary>
        /// 任务VINID号
        /// </summary>
        public string VINID { get; set; }
        /// <summary>
        /// 任务Job号
        /// </summary>
        public string JobID { get; set; }
        /// <summary>
        /// 时间戳VJ
        /// </summary> 
        public long timestampVJ { get; set; }

        //*************************************//
        //*************************************//
        //*************************************//
        /// <summary>
        /// 返回状态
        /// </summary>
        public int Code { get; set; }
        /// <summary>
        /// 任务状态码
        /// </summary>
        public string state { get; set; }
        /// <summary>
        /// 扭矩
        /// </summary>
        public int Torque { get; set; }
        /// <summary>
        /// 角度
        /// </summary>
        public int Angle { get; set; }
        /// <summary>
        /// 条码
        /// </summary>
        public string BarCode { get; set; }

        /// <summary>
        /// 内容备注
        /// </summary>
        public string msg { get; set; }
        /// <summary>
        /// 时间戳
        /// </summary> 
        public long timestamp { get; set; }
    }
}

Windowsform调用WebApi接口

需要安装的Nuget包有：

Microsoft.AspNet.WebApi.Client版本为5.2.9

Newtonsoft.Json版本为：9.0.1

WebApiClient.JIT版本为:1.1.4

需要编写的类为：

1.ClassApi配置IP地址类 （发送值和返回数据值）

2.JXDataClass数据解析调用里面的TaskStartQ的方法

3.TaskApiService发送数据类接收返回值

1.ClassApi配置IP地址类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebApiClient;
using WebApiClient.Attributes;

namespace WebAPiCeshi
{
    [HttpHost("http://localhost:7037/")]  //IP地址
    public interface ClassApi: IHttpApi
    {
        [HttpPost("api/ningJinQiang/instructionsTaskExec")]  //请求格式
        ITask<AgvResultData> TaskStartAsync([JsonContent] TaskStartApiDto dto);
    }
}

//**********************************//
/// <summary>
/// 数据返回的值
/// </summary>
public class AgvResultData
    {
        public string msg { get; set; }
        public int code { get; set; }
            /// <summary>
            ///  执行成功
            /// </summary> 
       public bool succeeded { get; set; }
        /// <summary>
        /// 错误信息
        /// </summary> 
        public object errors { get; set; }
        /// <summary>
        /// 附加数据
        /// </summary>
        public object extras { get; set; }
        /// <summary>
        /// 时间戳
        /// </summary>
        public long timestamp { get; set; }
        /// <summary>
        /// Job码
        /// </summary>
        public string textJob { get; set; }
        /// <summary>
        /// VIN码
        /// </summary>
        public string textVIN { get; set; }

}
    /// <summary>
    /// 发送的值
    /// </summary>
    public class TaskStartApiDto
    {
        /// <summary>
        /// 任务号uid
        /// </summary>
        public string taskID { get; set; }
        /// <summary>
        /// 当前状态
        /// </summary>
        public string state { get; set; }
        /// <summary>
        /// 返回信息
        /// </summary>
        public string msg { get; set; }
        /// <summary>
        /// Job码
        /// </summary>
        public string textJob { get; set; }
        /// <summary>
        /// VIN码
        /// </summary>
        public string textVIN { get; set; }

}

2.JXDataClass

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebApiClient;
using WebApiClient.Attributes;
namespace WebAPiCeshi
{
    [HttpHost("http://localhost:7037/")] //IP
    //返回的接口
    public interface JXDataClass : IHttpApi
    {
        [HttpPost("api/ningJinQiang/instructionsTaskExec")]//后缀
        ITask<ResultData<ValueTuple<bool, string>>> InTaskFinishedApiAsync([JsonContent] InTaskFinishedApiDto dto);


        [HttpPost("api/ningJinQiang/instructionsTaskExec")]
        ITask<Datas<ValueTuple<bool, string>>> TaskStartQ([JsonContent] TaskStartApiDto dto);
    }

    public class Datas<T>
     {

        /// <summary>
        /// Job码
        /// </summary>
        public string textJob { get; set; }
        /// <summary>
        /// VIN码
        /// </summary>
        public string textVIN { get; set; }
        /// <summary>
        /// 状态码
        /// </summary> 
        public int statusCode { get; set; }
        /// <summary>
        /// 成功状态
        /// </summary> 
        public string succeeded { get; set; }
        /// <summary>
        /// 错误信息
        /// </summary> 
        public string errors { get; set; }
        /// <summary>
        /// 附加信息
        /// </summary> 
        public string extras { get; set; }
        /// <summary>
        /// 时间戳
        /// </summary> 
        public long timestamp { get; set; }
        /// <summary>
        /// 数据实体
        /// </summary> 
        public T data { get; set; }



    }
    /// <summary>
    /// 数据库API结果
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ResultData<T>
    {
        /// <summary>
        /// 状态码
        /// </summary> 
        public string statusCode { get; set; }
        /// <summary>
        /// 成功状态
        /// </summary> 
        public bool succeeded { get; set; }
        /// <summary>
        /// 错误信息
        /// </summary> 
        public string errors { get; set; }
        /// <summary>
        /// 附加信息
        /// </summary> 
        public string extras { get; set; }
        /// <summary>
        /// 时间戳
        /// </summary> 
        public long timestamp { get; set; }
        /// <summary>
        /// 数据实体
        /// </summary> 
        public T data { get; set; }
    }

    public class InTaskFinishedApiDto
    {
        public string taskID { get; set; }
    }
}

3.TaskApiService发送数据类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebApiClient;

namespace WebAPiCeshi
{
    /// <summary>
    /// 发送数据类
    /// </summary>
    public class TaskApiService
    {
        ClassApi api = HttpApi.Create<ClassApi>();
        JXDataClass jXDataClassApi  = HttpApi.Create<JXDataClass>();

        /// <summary>
        /// 下发调度任务给agv
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public (bool state, string mes) TaskStart(TaskStartApiDto dto)
        {
            try
            {
                AgvResultData res = new AgvResultData();
                Task.Run(async () => {
                    var resApi = await api.TaskStartAsync(dto);
                    res.code = resApi.code;
                    res.msg = resApi.msg;
                    
                }).GetAwaiter().GetResult();
                return (res.code == 0 ? true : false, res.msg);
            }
            catch (HttpStatusFailureException ex)
            {
                var error = ex.Message;
                return (false, error);
            }
            catch (HttpApiException ex)
            {
                var err = ex.InnerException?.Message + ex.Message;
                return (false, err);
            }
        }

       
        /// <summary>
        /// 下发调度任务给agv1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public (bool state, string mes,string Dada,long timestamp) TaskStart1(TaskStartApiDto dto)
        {
            try
            {
                Datas<string> res = new Datas<string>();
               
                Task.Run(async () => {
                    var resApi = await jXDataClassApi.TaskStartQ(dto);
                    res.textJob = resApi.textJob;
                    res.textVIN = resApi.textVIN;

                    res.statusCode = resApi.statusCode;
                    res.succeeded = resApi.succeeded;
                    res.data = resApi.data.ToString();
                    res.timestamp = resApi.timestamp;
                }).GetAwaiter().GetResult();
                return (res.statusCode == 200 ? true : false, res.succeeded, res.data, res.timestamp);
            }
            catch (HttpStatusFailureException ex)
            {
                var error = ex.Message;
                return (false, error,"测试1",1313);
            }
            catch (HttpApiException ex)
            {
                var err = ex.InnerException?.Message + ex.Message;
                return (false, err,"测试2",1314);
            }
        }
    }
}

using DevExpress.Utils.Drawing.Helpers;
using DevExpress.XtraEditors;
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;
using WebApiClient;

namespace WebAPiCeshi
{
    public partial class Form1 : XtraForm
    {
        TaskApiService api = new TaskApiService();

        // 这里的URL配置成你websocket服务端的地址就好了
       // private static string url = "ws://127.0.0.1:7181/";
        private static string url = "ws://127.0.0.1:1883/";
        WSocketClient client = new WSocketClient(url);
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
            t_IP.Text = url;
        }
      
        /// <summary>
        /// 调用
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void simpleButton2_Click(object sender, EventArgs e)
        {
            TaskStartApiDto dto = new TaskStartApiDto()  
            {
                taskID = textEditID.Text.Trim(),
                state = textZT.Text.Trim(),
                msg = textEditXY.Text.Trim(),
                textJob = textJob.Text.Trim(),
                textVIN = textVIN.Text.Trim(),
            };
            var resAgvApi = api.TaskStart1(dto);  //解析data
            MessageBox.Show($"返回的结果{resAgvApi}");
        }


        //*****************************************
        //*****************************************
        //*****************************************

         这里的URL配置成你websocket服务端的地址就好了
        //private static string url = "";
        //WSocketClient client = new WSocketClient(url);
        private void btn_发布端连接_Click(object sender, EventArgs e)
        {
            //var IP = t_IP.Text.Trim();
            //MessageBox.Show(IP);

            //新建客户端类 
            //服务端IP地址 ws://192.168.1.13 如果服务端开启了ssl或者tsl 这里前缀应该改成 wss:/
            //服务端监听端口 1234
            //自定义的地址参数 可以根据地址参数来区分客户端 /lcj控制台
            //开始链接
            try
            {
                client.Start();
                txtLog.Text = "链接成功";
                MessageReceived();
            }
            catch (Exception ex)
            {
                txtLog.Text = $"发生异常链接失败{ex.ToString()}";
                throw;
            }
        }

  
        private void btn_发布端断开_Click(object sender, EventArgs e)
        {
            // 记得释放资源否则会造成堆栈
            client.Dispose();
            txtLog.Text = $"已成功释放资源。";
            MessageReceived();
        }

        private void btn_发布_Click(object sender, EventArgs e)
        {
            string inputMsg = t_发布内容.Text.ToString();
            if (string.IsNullOrEmpty(inputMsg))
                MessageBox.Show("小调皮,空值不让传！");
            client.SendMessage(inputMsg);
            MessageReceived();
        }

        /// <summary>
        /// 服务端返回的消息
        /// </summary>
        private void MessageReceived()
        {
            //注册消息接收事件，接收服务端发送的数据
            client.MessageReceived += (data) => {
                txtLog.Text += data;
            };
        }
    }
}

Winform客户端 调用WebSocket

需要安装的Nuget包有：

1.Fleck版本为1.2.0

2.Microsoft.AspNet.WebApi.Client版本为：5.2.9

3.NLog版本为:5.0.4

4.WebSocket4Net版本为：0.15.2

需要编写的类为：

1.WSocketClient数据发送连接

WSocketClient

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using WebSocket4Net;
using System.Configuration;
using System.Net.WebSockets;


namespace WebAPiCeshi
{
    public class WSocketClient : IDisposable
    {


        public static NLog.Logger _Logger = NLog.LogManager.GetCurrentClassLogger();

        #region 向外传递数据事件
        public event Action<string> MessageReceived;
        #endregion

        WebSocket4Net.WebSocket _webSocket;
        /// <summary>
        /// 检查重连线程
        /// </summary>
        Thread _thread;
        bool _isRunning = true;
        /// <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;
        }

        #region "web socket "
        /// <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)
            {
                _Logger.Error(ex.ToString());
                result = false;
            }
            return result;
        }
        /// <summary>
        /// 消息收到事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
        {
            _Logger.Info(" Received:" + e.Message);
            MessageReceived?.Invoke(e.Message);
        }
        /// <summary>
        /// Socket关闭事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void WebSocket_Closed(object sender, EventArgs e)
        {
            _Logger.Info("websocket_Closed");
        }

        /// <summary>
        /// Socket打开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void WebSocket_Opened(object sender, EventArgs e)
        {
            _Logger.Info(" websocket_Opened");
        }
        /// <summary>
        /// 检查重连线程
        /// </summary>
        private void CheckConnection()
        {
            do
            {
                try
                {
                    if (this._webSocket.State != WebSocket4Net.WebSocketState.Open && this._webSocket.State != WebSocket4Net.WebSocketState.Connecting)
                    {
                        _Logger.Info(" Reconnect websocket WebSocketState:" + this._webSocket.State);
                        this._webSocket.Close();
                        this._webSocket.Open();
                        Console.WriteLine("正在重连");
                    }
                }
                catch (Exception ex)
                {
                    _Logger.Error(ex.ToString());
                }
                System.Threading.Thread.Sleep(5000);
            } while (this._isRunning);
        }
        #endregion

        /// <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()
        {
            this._isRunning = false;
            try
            {
                _thread.Abort();
            }
            catch
            {

            }
            this._webSocket.Close();
            this._webSocket.Dispose();
            this._webSocket = null;
        }

    }
}

Form的方法

using DevExpress.Utils.Drawing.Helpers;
using DevExpress.XtraEditors;
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;
using WebApiClient;

namespace WebAPiCeshi
{
    public partial class Form1 : XtraForm
    {
        TaskApiService api = new TaskApiService();

        // 这里的URL配置成你websocket服务端的地址就好了
       // private static string url = "ws://127.0.0.1:7181/";
        private static string url = "ws://127.0.0.1:1883/";
        WSocketClient client = new WSocketClient(url);
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
            t_IP.Text = url;
        }
      
        /// <summary>
        /// 调用
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void simpleButton2_Click(object sender, EventArgs e)
        {
            TaskStartApiDto dto = new TaskStartApiDto()  
            {
                taskID = textEditID.Text.Trim(),
                state = textZT.Text.Trim(),
                msg = textEditXY.Text.Trim(),
                textJob = textJob.Text.Trim(),
                textVIN = textVIN.Text.Trim(),
            };
            var resAgvApi = api.TaskStart1(dto);  //解析data
            MessageBox.Show($"返回的结果{resAgvApi}");
        }


        //*****************************************
        //*****************************************
        //*****************************************

         这里的URL配置成你websocket服务端的地址就好了
        //private static string url = "";
        //WSocketClient client = new WSocketClient(url);
        private void btn_发布端连接_Click(object sender, EventArgs e)
        {
            //var IP = t_IP.Text.Trim();
            //MessageBox.Show(IP);

            //新建客户端类 
            //服务端IP地址 ws://192.168.1.13 如果服务端开启了ssl或者tsl 这里前缀应该改成 wss:/
            //服务端监听端口 1234
            //自定义的地址参数 可以根据地址参数来区分客户端 /lcj控制台
            //开始链接
            try
            {
                client.Start();
                txtLog.Text = "链接成功";
                MessageReceived();
            }
            catch (Exception ex)
            {
                txtLog.Text = $"发生异常链接失败{ex.ToString()}";
                throw;
            }
        }

  
        private void btn_发布端断开_Click(object sender, EventArgs e)
        {
            // 记得释放资源否则会造成堆栈
            client.Dispose();
            txtLog.Text = $"已成功释放资源。";
            MessageReceived();
        }

        private void btn_发布_Click(object sender, EventArgs e)
        {
            string inputMsg = t_发布内容.Text.ToString();
            if (string.IsNullOrEmpty(inputMsg))
                MessageBox.Show("小调皮,空值不让传！");
            client.SendMessage(inputMsg);
            MessageReceived();
        }

        /// <summary>
        /// 服务端返回的消息
        /// </summary>
        private void MessageReceived()
        {
            //注册消息接收事件，接收服务端发送的数据
            client.MessageReceived += (data) => {
                txtLog.Text += data;
            };
        }
    }
}

百度网盘地址：

链接：https://pan.baidu.com/s/1EkejkJy2nhLT22qgdRtFQw
catch (Exception ex)
{
txtLog.Text = $“发生异常链接失败{ex.ToString()}”;
throw;
}
}

    private void btn_发布端断开_Click(object sender, EventArgs e)
    {
        // 记得释放资源否则会造成堆栈
        client.Dispose();
        txtLog.Text = $"已成功释放资源。";
        MessageReceived();
    }

    private void btn_发布_Click(object sender, EventArgs e)
    {
        string inputMsg = t_发布内容.Text.ToString();
        if (string.IsNullOrEmpty(inputMsg))
            MessageBox.Show("小调皮,空值不让传！");
        client.SendMessage(inputMsg);
        MessageReceived();
    }

    /// <summary>
    /// 服务端返回的消息
    /// </summary>
    private void MessageReceived()
    {
        //注册消息接收事件，接收服务端发送的数据
        client.MessageReceived += (data) => {
            txtLog.Text += data;
        };
    }
}

}

#### 百度网盘地址：

链接：https://pan.baidu.com/s/1EkejkJy2nhLT22qgdRtFQw 
提取码：c9tg