C#之WebSocket服务端

效果演示

什么是 WebSocket？

在现代的Web开发中，实时数据传输已成为提升用户体验的重要组成部分。传统的HTTP协议是一个基于请求-响应模式的协议，这意味着客户端每次需要获取新数据时都必须发起一个请求。而对于一些需要实时更新的应用（例如在线聊天、股票行情、实时游戏等），这种方式效率低下且带来了不必要的延迟。

这时，WebSocket应运而生，它为双向通信提供了一个高效、持久的通道。本文将介绍WebSocket的工作原理、应用场景以及如何在Web开发中实现WebSocket。 WebSocket 是一个网络协议，它使得客户端和服务器之间能够建立持久的双向通信通道。与传统的HTTP请求-响应模型不同，WebSocket 连接一旦建立，客户端和服务器之间可以随时相互发送数据，而不需要频繁地建立连接。

WebSocket的特点

1、全双工通信：WebSocket 允许客户端和服务器进行实时的双向通信，不像传统的HTTP协议只能由客户端发起请求。

2、持久连接：WebSocket连接在客户端和服务器之间保持开放，直到显式地关闭连接，这比HTTP的每次请求-响应方式更高效。

3、低延迟：由于是持久连接，WebSocket 可以减少每次请求和响应时的延迟，适合实时更新场景。

4、节省资源：WebSocket 只需要一次握手建立连接，之后的数据交换不需要重新发送HTTP头，减少了网络负担。

使用TouchSocket编写服务端

public delegate void GetReceivedEvent(IWebSocket client, WSDataFrameEventArgs e);

public delegate void TcpClosedEvent(ClosedEventArgs e);

public delegate void TcpClosedEvent2(IWebSocket client,ClosedEventArgs e);

public delegate void TcpConnectedEvent();

public delegate void TcpConnectedEvent2(IWebSocket client, HttpContextEventArgs e);

public class Server
{
	public event GetReceivedEvent OnGetReceivedEvent;

	public event TcpClosedEvent2 OnTcpClosedEvent;

	public event TcpConnectedEvent2 OnTcpConnectedEvent;

	//private Thread scanThread = null;
	public HttpService service = null;

	private IPHost[] port = null;

	public string wsURL = string.Empty;

	public Server(params IPHost[] port)
	{
		this.port = port;
	}

	public async Task StartService()
	{
		try
		{
			service = new HttpService();
			await service.SetupAsync(new TouchSocketConfig()//加载配置
						.SetListenIPHosts(port)
						.ConfigureContainer(a =>
						{
							a.AddConsoleLogger();
							a.RegisterSingleton<IHttpService>(service);
							a.RegisterSingleton<Server>(this);
						})
						.ConfigurePlugins(a =>
						{
							if (!string.IsNullOrEmpty(wsURL))
							{
								a.UseWebSocket()//添加WebSocket功能
								.SetVerifyConnection(VerifyConnection)
									.SetWSUrl(wsURL)
									.UseAutoPong(); ;
								a.Add<MyWebSocketPlugin>();//自定义插件。

							}
							else
							{
								a.UseWebSocket()//添加WebSocket功能
								.SetVerifyConnection(VerifyConnection)
									.SetWSUrl("/ws");
								a.Add<MyWebSocketPlugin>();//自定义插件。
							}
						}));
			await service.StartAsync();
		}
		catch (Exception ex)
		{
			throw ex;
		}
	}

	private void ScanThread()
	{
		int count = 0;

		while (true)
		{

			IClientCollection<HttpSessionClient> clients = service.Clients;

			foreach (var item in clients)
			{
				Console.WriteLine($"Id:{item.Id},IP:{item.IP},port:{item.Port}");
			}
		}
	}

	/// <summary>
	/// 验证websocket的连接
	/// </summary>
	/// <param name="client"></param>
	/// <param name="context"></param>
	/// <returns></returns>
	private static bool VerifyConnection(IHttpSessionClient client, HttpContext context)
	{
		if (!context.Request.IsUpgrade())//如果不包含升级协议的header，就直接返回false。
		{
			return false;
		}
		if (context.Request.UrlEquals("/ws"))//以此连接，则直接可以连接
		{
			return true;
		}
		else if (context.Request.UrlEquals("/wsquery"))//以此连接，则需要传入token才可以连接
		{
			if (context.Request.Query.Get("token") == "123456")
			{
				return true;
			}
			else
			{
				context.Response
					.SetStatus(403, "token不正确")
					.AnswerAsync();
			}
		}
		else if (context.Request.UrlEquals("/wsheader"))//以此连接，则需要从header传入token才可以连接
		{
			if (context.Request.Headers.Get("token") == "123456")
			{
				return true;
			}
			else
			{
				context.Response
					.SetStatus(403, "token不正确")
					.AnswerAsync();
			}
		}
		return false;
	}

	public void GetReceive(IWebSocket client, WSDataFrameEventArgs e)
	{
		OnGetReceivedEvent?.Invoke(client, e);
	}

	public void TcpClosed(IWebSocket webSocket,ClosedEventArgs e)
	{
		OnTcpClosedEvent?.Invoke(webSocket,e);
	}

	public void TcpConnection(IWebSocket webSocket, HttpContextEventArgs e)
	{
		OnTcpConnectedEvent?.Invoke(webSocket,e);
	}

	public async Task SendAsync(string id, string text, bool endOfMessage = true)
	{
		try
		{
			HttpSessionClient client = service?.Clients.Where(it => it.Id == id).FirstOrDefault();
			await client.WebSocket.SendAsync(text, endOfMessage);
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task SendAsync(string id, WSDataFrame dataFrame, bool endOfMessage = true)
	{
		try
		{
			HttpSessionClient client = service?.Clients.Where(it => it.Id == id).FirstOrDefault();
			await client.WebSocket.SendAsync(dataFrame, endOfMessage);
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task SendAsync(string id, ReadOnlyMemory<byte> memory, bool endOfMessage = true)
	{
		try
		{
			HttpSessionClient client = service?.Clients.Where(it => it.Id == id).FirstOrDefault();
			await client.WebSocket.SendAsync(memory, endOfMessage);
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task SendAsync(string text, bool endOfMessage = true)
	{
		try
		{
			if(null !=service)
			{
				var clients = service.Clients;
				foreach (var item in clients)
					if (item.Protocol == Protocol.WebSocket)//先判断是不是websocket协议
						await item.WebSocket.SendAsync(text, endOfMessage);
			}
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task SendAsync(WSDataFrame dataFrame, bool endOfMessage = true)
	{
		try
		{
			if (null != service)
			{
				var clients = service.Clients;
				foreach (var item in clients)
					if (item.Protocol == Protocol.WebSocket)//先判断是不是websocket协议
						await item.WebSocket.SendAsync(dataFrame, endOfMessage);
			}
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task SendAsync(ReadOnlyMemory<byte> memory, bool endOfMessage = true)
	{
		try
		{
			if (null != service)
			{
				var clients = service.Clients;
				foreach (var item in clients)
					if (item.Protocol == Protocol.WebSocket)//先判断是不是websocket协议
						await item.WebSocket.SendAsync(memory, endOfMessage);
			}
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}


	public async void Close(string id)
	{
		try
		{
			HttpSessionClient client = service?.Clients.Where(it => it.Id == id).FirstOrDefault();
			await client.WebSocket.CloseAsync($"Id:{client.Id},IP:{client.IP},port:{client.Port}客户端已被关闭");
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}

	public async Task Close()
	{
		try
		{
			
			var clients = service?.Clients;
			foreach (var item in clients)
				if (item.Protocol == Protocol.WebSocket)//先判断是不是websocket协议
					await item.WebSocket.CloseAsync($"Id:{item.Id},IP:{item.IP},port:{item.Port}客户端已被关闭");
			service.Dispose();
			service = null;
		}
		catch (Exception ex)
		{
			Console.WriteLine($"{ex.Message}");
		}
	}
}

public class MyWebSocketPlugin : PluginBase, IWebSocketReceivedPlugin, IWebSocketClosedPlugin, IWebSocketHandshakedPlugin
{
	private readonly ILog m_logger;

	private readonly IHttpService m_httpService;

	private readonly Server m_server;
	public MyWebSocketPlugin(ILog logger, IHttpService httpServic, Server server)
	{
		this.m_logger = logger;
		this.m_httpService = httpServic;
		this.m_server = server;
	}

	public async Task OnWebSocketClosed(IWebSocket webSocket, ClosedEventArgs e)
	{
		m_server.TcpClosed(webSocket,e);
		await e.InvokeNext();
	}

	public async Task OnWebSocketHandshaked(IWebSocket webSocket, HttpContextEventArgs e)
	{
		m_server.TcpConnection(webSocket,e);
		await e.InvokeNext();
	}

	public async Task OnWebSocketReceived(IWebSocket client, WSDataFrameEventArgs e)
	{
		if (e.DataFrame.Opcode == WSDataType.Ping)
			Console.WriteLine($"{client.Client.GetIPPort()}|心跳包:连接中");
		else
			m_server.GetReceive(client, e);
		await e.InvokeNext();
	}
}

TouchSocket是一组非常优秀的类库,我是在它的基础上面封装我常用的调用方法！