基于SignalR的服务端和客户端通讯处理

SignalR是一个.NET Core/.NET Framework的实时通讯的框架，一样平常应用在ASP.NET上，固然也可以应用在Winform上实现服务端和客户端的消息通讯，本篇随笔重要基于SignalR的构建一个基于Winform的服务端和客户端的通讯处理案例，先容此中的处理过程。

1、SignalR底子知识

SignalR是一个.NET Core/.NET Framework的开源实时框架. SignalR的可利用Web Socket, Server Sent Events 和 Long Polling作为底层传输方式。

SignalR基于这三种技能构建, 抽象于它们之上, 它让你更好的关注业务标题而不是底层传输技能标题。

SignalR将整个信息的交换封装起来，客户端和服务器都是利用JSON来沟通的，在服务端声明的全部Hub信息，都会生成JavaScript输出到客户端，.NET则依赖Proxy来生成署理对象，而Proxy的内部则是将JSON转换成对象。

RPC

RPC (Remote Procedure Call). 它的优点就是可以像调用当地方法一样调用长途服务.

SignalR接纳RPC范式来举行客户端与服务器端之间的通讯.

SignalR利用底层传输来让服务器可以调用客户端的方法, 反之亦然, 这些方法可以带参数, 参数也可以是复杂对象, SignalR负责序列化和反序列化.

Hub

Hub是SignalR的一个组件, 它运行在ASP.NET Core应用里. 以是它是服务器端的一个类.

Hub利用RPC担当从客户端发来的消息, 也能把消息发送给客户端. 以是它就是一个通讯用的Hub.

在ASP.NET Core里, 本身创建的Hub类必要继承于基类Hub。在Hub类内里, 我们就可以调用全部客户端上的方法了. 同样客户端也可以调用Hub类里的方法.

SignalR可以将参数序列化和反序列化. 这些参数被序列化的格式叫做Hub 协议, 以是Hub协议就是一种用来序列化和反序列化的格式.

Hub协议的默认协议是JSON, 还支持别的一个协议是MessagePack。MessagePack是二进制格式的, 它比JSON更紧凑, 而且处理起来更简朴快速, 由于它是二进制的.

别的, SignalR也可以扩展利用别的协议。

2、基于SignalR构建的Winform服务端和客户端案例

服务单界面结果如下所示，重要功能为启动服务、制止服务，广播消息和检察毗连客户端信息。

客户端重要就是实时获取在线用户列表，以及发送、应答消息，消息可以群发，也可以针对特定的客户端举行消息一对一发送。

客户端1：

客户端2：

构建的项目工程，包罗服务端、客户端和两个之间的通讯对象类，如下所示。

服务端引用

客户端引用

服务端启动代码，想要界说一个Startup类，用来承载SignalR的入口处理。

1. [assembly: OwinStartup(typeof(SignalRServer.Startup))]
2. namespace SignalRServer
3. {
4. public class Startup
5. {
6. public void Configuration(IAppBuilder app)
7. {
8. var config = new HubConfiguration();
9. config.EnableDetailedErrors = true;
11. //设置可以跨域访问
12. app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
13. //映射到默认的管理
14. app.MapSignalR(config);
15. }
16. }
17. }

复制代码

我们前面先容过，服务端利用Winform步伐来处理它的启动，制止的，如下所示。

因此界面上通过按钮变乱举行启动，启动服务的代码如下所示。

1. private void btnStart_Click(object sender, EventArgs e)
2. {
3. this.btnStart.Enabled = false;
4. WriteToInfo("正在毗连中....");
6. Task.Run(() =>
7. {
8. ServerStart();
9. });
10. }

复制代码

这里通过启动别的一个线程的处理，通过WebApp.Start启动入口类，并传入设置好的端口毗连地点。

1. /// <summary>
2. /// 开启服务
3. /// </summary>
4. private void ServerStart()
5. {
6. try
7. {
8. //开启服务
9. signalR = WebApp.Start<Startup>(serverUrl);
11. InitControlState(true);
12. }
13. catch (Exception ex)
14. {
15. //服务失败时的处理
16. WriteToInfo("服务开启失败,缘故因由:" + ex.Message);
17. InitControlState(false);
18. return;
19. }
21. WriteToInfo("服务开启乐成 : " + serverUrl);
22. }

复制代码

毗连地点我们设置在xml文件内里，此中的 serverUrl 就是指向下面的键url, 设置的url如下所示：

1. <?xml version="1.0" encoding="utf-8"?>
2. <configuration>
3. <startup>
4. <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/>
5. </startup>
6. <appSettings>
7. <add key="url" value="http://localhost:17284"/>
8. </appSettings>

复制代码

制止服务代码如下所示，通过一个异步操纵制止服务。

1. /// <summary>
2. /// 制止服务
3. /// </summary>
4. /// <returns></returns>
5. private async Task StopServer()
6. {
7. if (signalR != null)
8. {
9. //向客户端广播消息
10. hubContext = GlobalHost.ConnectionManager.GetHubContext<SignalRHub>();
11. await hubContext.Clients.All.SendClose("服务端已关闭");
13. //开释对象
14. signalR.Dispose();
15. signalR = null;
17. WriteToInfo("服务端已关闭");
18. }
19. }

复制代码

服务端对SignalR客户端的管理是通过一个继承于Hub的类SignalRHub举行管理，这个就是整个SignalR的核心了，它重要有几个函数必要重写，如OnConnected、OnDisconnected、OnReconnected、以及一个通用的消息发送AddMessage函数。

客户端有接入的时候，我们会通过参数获取毗连客户端的信息，并同一广播当前客户的状态信息，如下所示是服务端对于接入客户端的管理代码。

1. /// <summary>
2. /// 在毗连上时
3. /// </summary>
4. public override Task OnConnected()
5. {
6. var client = JsonConvert.DeserializeObject<ClientModel>(Context.QueryString.Get("Param"));
7. if (client != null)
8. {
9. client.ConnId = Context.ConnectionId;
10. //将客户端毗连加入列表
11. if (!Portal.gc.ClientList.Exists(e => e.ConnId == client.ConnId))
12. {
13. Portal.gc.ClientList.Add(client);
14. }
15. Groups.Add(client.ConnId, "Client");
17. //向服务端写入一些数据
18. Portal.gc.MainForm.WriteToInfo("客户端毗连ID:" + Context.ConnectionId);
19. Portal.gc.MainForm.WriteToInfo(string.Format("客户端 【{0}】接入: {1} , IP地点: {2} \n 客户端总数: {3}", client.Name, Context.ConnectionId, client.IPAddress, Portal.gc.ClientList.Count));
21. //先全部毗连客户端广播毗连客户状态
22. var imcp = new StateMessage()
23. {
24. Client = client,
25. MsgType = MsgType.State,
26. FromConnId = client.ConnId,
27. Success = true
28. };
29. var jsonStr = JsonConvert.SerializeObject(imcp);
30. Clients.Group("Client", new string[0]).addMessage(jsonStr);
32. return base.OnConnected();
34. }
35. return Task.FromResult(0);
36. }

复制代码

客户端的接入，必要对相应的HubConnection变乱举行处理，并初始化干系信息，如下代码所示。

1. /// <summary>
2. /// 初始化服务毗连
3. /// </summary>
4. private void InitHub()
5. {
6. 。。。。。。
8. //毗连的时候转达参数Param
9. var param = new Dictionary<string, string> {
10. { "Param", JsonConvert.SerializeObject(client) }
11. };
12. //创建毗连对象，并实现干系变乱
13. Connection = new HubConnection(serverUrl, param);
15. 。。。。。。//实现干系变乱
16. Connection.Closed += HubConnection_Closed;
17. Connection.Received += HubConnection_Received;
18. Connection.Reconnected += HubConnection_Succeed;
19. Connection.TransportConnectTimeout = new TimeSpan(3000);
21. //绑定一个集线器
22. hubProxy = Connection.CreateHubProxy("SignalRHub");
23. AddProtocal();
24. }

复制代码

1. private async Task StartConnect()
2. {
3. try
4. {
5. //开始毗连
6. await Connection.Start();
7. await hubProxy.Invoke<CommonResult>("CheckLogin", this.txtUser.Text);
9. HubConnection_Succeed();//处理毗连后的初始化
11. 。。。。。。
12. }
13. catch (Exception ex)
14. {
15. Console.WriteLine(ex.StackTrace);
16. this.richTextBox.AppendText("服务器毗连失败：" + ex.Message);
18. InitControlStatus(false);
19. return;
20. }
21. }

复制代码

客户端根据收到的差别协议信息，举行差别的变乱处理，如下代码所示。

1. /// <summary>
2. /// 对各种协议的变乱举行处理
3. /// </summary>
4. private void AddProtocal()
5. {
6. //吸取实时信息
7. hubProxy.On<string>("AddMessage", DealMessage);
9. //毗连上触发connected处理
10. hubProxy.On("logined", () =>
11. this.Invoke((Action)(() =>
12. {
13. this.Text = string.Format("当前用户:{0}", this.txtUser.Text);
14. richTextBox.AppendText(string.Format("以名称【" + this.txtUser.Text + "】毗连乐成!" + Environment.NewLine));
15. InitControlStatus(true);
16. }))
17. );
19. //服务端拒绝的处理
20. hubProxy.On("rejected", () =>
21. this.Invoke((Action)(() =>
22. {
23. richTextBox.AppendText(string.Format("无法利用名称【" + this.txtUser.Text + "】举行毗连!" + Environment.NewLine));
24. InitControlStatus(false);
25. CloseHub();
26. }))
27. );
29. //客户端收到服务关闭消息
30. hubProxy.On("SendClose", () =>
31. {
32. CloseHub();
33. });
34. }

复制代码

例如我们对收到的文本信息，如一对一的发送消息大概广播消息，同一举行展示处理。

1. /// <summary>
2. /// 处理文本消息
3. /// </summary>
4. /// <param name="data"></param>
5. /// <param name="basemsg"></param>
6. private void DealText(string data, BaseMessage basemsg)
7. {
8. //JSON转换为文本消息
9. var msg = JsonConvert.DeserializeObject<TextMessage>(data);
10. var ownerClient = ClientList.FirstOrDefault(f => f.ConnId == basemsg.FromConnId);
11. var ownerName = ownerClient == null ? "体系广播" : ownerClient.Name;
13. this.Invoke(new Action(() =>
14. {
15. richTextBox.AppendText(string.Format("{0} - {1}:\n {2}" + Environment.NewLine, DateTime.Now, ownerName, msg.Message));
16. richTextBox.ScrollToCaret();
17. }));
18. }

复制代码

客户端对消息的处理界面

而客户端发送消息，则是同一通过调用Hub的AddMessage方法举行发送即可，如下代码所示。

1. private void BtnSendMessage_Click(object sender, EventArgs e)
2. {
3. if (txtMessage.Text.Length == 0)
4. return;
6. var message = new TextMessage() {
7. MsgType = MsgType.Text,
8. FromConnId = client.ConnId,
9. ToConnId = this.toId,
10. Message = txtMessage.Text,
11. Success = true };
13. hubProxy.Invoke("AddMessage", JsonConvert.SerializeObject(message));
14. txtMessage.Text = string.Empty;
15. txtMessage.Focus();
16. }

复制代码

此中的hubProxy是我们前面毗连服务端的时候，构造出的一个署理对象

1. hubProxy = Connection.CreateHubProxy("SignalRHub");

复制代码

客户端关闭的时候，我们烧毁干系的对象即可。

1. private void Form1_FormClosing(object sender, FormClosingEventArgs e)
2. {
3. if (Connection != null)
4. {
5. Connection.Stop();
6. Connection.Dispose();
7. }
8. }

复制代码

以上就是SignalR的服务端和客户端的相互共同，相互通讯过程。