WebSockets представляют собой протокол, который обеспечивает двустороннюю связь между клиентом и сервером по одной полупостоянной TCP-соединению. Это позволяет передавать данные в реальном времени без необходимости производить частые переподключения, как это делают традиционные HTTP-запросы. В данной статье мы подробно разберем, как можно реализовать собственный механизм работы с WebSockets на языке C#. Мы охватим основные аспекты от установления соединения до обработки сообщений и закрытия соединения.
Перед тем как приступить к реализации, давайте познакомимся с основными концепциями WebSockets. Этот протокол позволяет клиенту и серверу обмениваться данными без необходимости отправлять запросы отдельно для каждого сообщения. Веб-клиент (обычно браузер) может установить WebSocket соединение с сервером, после чего можно передавать данные в обоих направлениях до тех пор, пока соединение активно.
- Реальное время: Обеспечивает возможность обмена данными без задержки, что критически важно для таких приложений, как чаты или игры.
- Эффективность: Устраняет необходимость в периодическом отправлении запросов от клиента, используя постоянное соединение.
- Простота обмена сообщениями: Веб-сервер и клиент могут обмениваться данными с минимальными ограничениями.
На языке C# для работы с WebSockets существует несколько подходов. Наиболее распространенные из них:
- Использование стандартной библиотеки .NET Core/ASP.NET Core.
- Реализация на основе
Socketкласса для полного контроля. - Создание пользовательского серверного движка.
Фреймворк ASP.NET Core имеет встроенную поддержку WebSockets, что значительно упрощает процесс разработки. Рассмотрим его использование на примере.
Для начала необходимо создать новый проект ASP.NET Core:
dotnet new webapp -n WebSocketDemo
cd WebSocketDemo
Затем в файл Startup.cs нужно добавить поддержку WebSockets:
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
// Стандартная настройка услуг
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
// Включение WebSockets
app.UseWebSockets();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
}
Создадим контроллер для обработки соединений:
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
public class WebSocketController : Controller
{
private readonly RequestDelegate _next;
public WebSocketController(RequestDelegate next)
{
_next = next;
}
[HttpGet("ws")]
public async Task Get()
{
if (HttpContext.WebSockets.IsWebSocketRequest)
{
using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
await Echo(webSocket);
}
else
{
// Ответ на некорректные запросы, которые не являются WebSocket
HttpContext.Response.StatusCode = 400;
}
}
private async Task Echo(WebSocket webSocket)
{
var buffer = new byte[1024 * 4];
while (webSocket.State == WebSocketState.Open)
{
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
await webSocket.SendAsync(
new ArraySegment<byte>(Encoding.UTF8.GetBytes(message)),
WebSocketMessageType.Text,
true,
CancellationToken.None);
}
else
{
break;
}
}
}
}
Если требуется более глубокий контроль над соединением, можно использовать классы из пространства имен System.Net.Sockets. Это позволяет реализовывать собственные механизмы обработки сообщений.
Для работы с WebSockets на уровне ниже, используя класс Socket, необходимо выполнять несколько шагов:
- Создание серверного
Socketобъекта. - Прием и обработка WebSocket handshake (рукопожатия).
- Обработка сообщений со стороны клиента.
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class CustomWebSocketServer
{
private readonly Socket _serverSocket;
public CustomWebSocketServer(int port)
{
_serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, port));
_serverSocket.Listen(100);
}
public void Start()
{
while (true)
{
var clientSocket = _serverSocket.Accept();
HandleClient(clientSocket);
}
}
private async Task HandleClient(Socket clientSocket)
{
byte[] buffer = new byte[1024];
// Прием handshake
string request;
do
{
int bytesReceived = await clientSocket.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);
request += Encoding.UTF8.GetString(buffer, 0, bytesReceived);
if (request.Length > 10000)
{
throw new Exception("The request is too big!");
}
} while (!request.Contains("\r\n\r\n"));
// Отправка handshake-ответа
var response = GetWebSocketResponse(request);
await clientSocket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(response)), SocketFlags.None);
// Обработка сообщений
HandleMessages(clientSocket);
}
private string GetWebSocketResponse(string request)
{
const string websocketKeyHeader = "Sec-WebSocket-Key: ";
int keyIndex = request.IndexOf(websocketKeyHeader, StringComparison.Ordinal);
if (keyIndex == -1)
throw new Exception("Invalid WebSocket handshake.");
keyIndex += websocketKeyHeader.Length;
var headerEndIndex = request.IndexOf("\r\n", keyIndex, StringComparison.Ordinal);
string clientKey = request.Substring(keyIndex, headerEndIndex - keyIndex).Trim();
// Создание ответа на handshake
var magicString = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
var acceptVal = Convert.ToBase64String(
System.Security.Cryptography.SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(clientKey + magicString)));
return $"HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n" +
"Sec-WebSocket-Accept: {acceptVal}\r\n\r\n";
}
private async Task HandleMessages(Socket clientSocket)
{
byte[] buffer = new byte[1024];
while (clientSocket.Connected)
{
var receiveResult = await clientSocket.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);
if (receiveResult == 0)
break;
// Обработка пакета WebSocket сообщения
string message = Encoding.UTF8.GetString(buffer, 0, receiveResult);
Console.WriteLine("Received: " + message);
await clientSocket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(message)), SocketFlags.None);
}
}
}
public static void Main()
{
var server = new CustomWebSocketServer(8080);
server.Start();
}
Если требуется полный контроль над обработкой WebSocket соединений, можно реализовать собственный серверный движок. Это позволит настраивать механизмы управления потоками, безопасность и другие важные аспекты.
- Построение основной структуры: Создание классов для обработки соединений и сообщений.
- Обеспечение безопасности: Использование SSL/TLS для защиты данных.
- Асинхронная обработка запросов: Реализация методов, позволяющих эффективно управлять множеством соединений.
using System;
using System.Collections.Concurrent;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
public class CustomWebSocketServerEngine
{
private readonly ConcurrentDictionary<string, WebSocketConnection> _connections = new();
public void Start(int port)
{
var listener = new TcpListener(System.Net.IPAddress.Any, port);
listener.Start();
Console.WriteLine("Listening on port " + port);
while (true)
{
var client = listener.AcceptTcpClient();
Task.Run(() => HandleConnection(client));
}
}
private async Task HandleConnection(TcpClient client)
{
using var sslStream = new SslStream(
client.GetStream(),
false,
new RemoteCertificateValidationCallback(ValidateServerCertificate),
null);
try
{
await sslStream.AuthenticateAsServerAsync(new X509Certificate2("server.pfx"), false, System.Security.Authentication.SslProtocols.Tls12, true);
if (IsWebSocketRequest(client.GetStream()))
{
var connectionId = Guid.NewGuid().ToString();
var webSocketConnection = new WebSocketConnection(sslStream, connectionId);
_connections.TryAdd(connectionId, webSocketConnection);
await webSocketConnection.HandshakeAsync();
await webSocketConnection.ReceiveLoopAsync();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return true; // Установка настраиваемой логики проверки сертификатов
}
private bool IsWebSocketRequest(NetworkStream stream)
{
byte[] buffer = new byte[1024];
int bytesRead = stream.Read(buffer, 0, buffer.Length);
string request = Encoding.UTF8.GetString(buffer, 0, bytesRead);
return request.StartsWith("GET") && request.Contains("Upgrade: websocket");
}
}
Веб-соединение WebSockets позволяет передавать данные в формате “фрагментов”. Каждый фрагмент начинается с байта заголовка, который содержит информацию о типе и контрольных данных сообщения.
Основные поля заголовка:
- FIN: Показывает, является ли данный пакет последним в соединении.
- Opcode: Определяет тип пакета (текст, бинарный или управление).
- Mask: Используется для проверки корректности данных на стороне клиента.
Для расшифровки и отправки пакетов используются следующие шаги:
- Чтение заголовков: Парсинг первых двух байт для получения информации о флагах и длине сообщения.
- Обработка заголовков: В зависимости от размера данных, необходимо прочитать соответствующее количество дополнительных байт для определения полной длины пакета.
- Декодирование: Если сообщение зашифровано (клиент -> сервер), нужно использовать маску из заголовка для расшифровки данных.
using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
public class WebSocketConnection
{
private readonly SslStream _sslStream;
private readonly string _connectionId;
public WebSocketConnection(SslStream sslStream, string connectionId)
{
_sslStream = sslStream;
_connectionId = connectionId;
}
public async Task HandshakeAsync()
{
byte[] buffer = new byte[1024];
// Прием запроса
int bytesRead = await _sslStream.ReadAsync(buffer, 0, buffer.Length);
string request = Encoding.UTF8.GetString(buffer, 0, bytesRead);
// Отправка ответа на handshake
var response = GetWebSocketResponse(request);
byte[] responseBytes = Encoding.UTF8.GetBytes(response);
await _sslStream.WriteAsync(responseBytes, 0, responseBytes.Length);
}
public async Task ReceiveLoopAsync()
{
while (_sslStream.IsAuthenticated)
{
WebSocketFrame frame = await ReadFrameAsync();
// Обработка полученного сообщения
string message = Encoding.UTF8.GetString(frame.PayloadData);
Console.WriteLine($"Received from {_connectionId}: {message}");
await SendFrameAsync(new WebSocketFrame(WebSocketOpcode.Text, Encoding.UTF8.GetBytes(message)));
}
}
private async Task<WebSocketFrame> ReadFrameAsync()
{
byte[] buffer = new byte[2];
await _sslStream.ReadAsync(buffer, 0, 2);
var firstByte = buffer[0];
var secondByte = buffer[1];
bool fin = (firstByte & 0x80) != 0;
WebSocketOpcode opcode = (WebSocketOpcode)(firstByte & 0x0F);
bool masked = (secondByte & 0x80) != 0;
int payloadLength = secondByte & 0x7F;
if (payloadLength == 126)
{
buffer = new byte[2];
await _sslStream.ReadAsync(buffer, 0, 2);
payloadLength = BitConverter.ToUInt16(new[] { buffer[1], buffer[0] }, 0);
}
else if (payloadLength == 127)
{
buffer = new byte[8];
await _sslStream.ReadAsync(buffer, 0, 8);
payloadLength = (int)BitConverter.ToInt64(new[] { buffer[7], buffer[6], buffer[5], buffer[4], buffer[3], buffer[2], buffer[1], buffer[0] }, 0);
}
byte[] maskingKey = new byte[4];
if (masked)
{
await _sslStream.ReadAsync(maskingKey, 0, 4);
}
byte[] payloadData = new byte[payloadLength];
await _sslStream.ReadAsync(payloadData, 0, payloadLength);
if (masked)
{
for (int i = 0; i < payloadData.Length; i++)
payloadData[i] ^= maskingKey[i % 4];
}
return new WebSocketFrame(opcode, payloadData);
}
private async Task SendFrameAsync(WebSocketFrame frame)
{
byte[] dataToWrite = BuildFrame(frame);
await _sslStream.WriteAsync(dataToWrite, 0, dataToWrite.Length);
}
// Метод для создания пакета WebSocket сообщения
private byte[] BuildFrame(WebSocketFrame frame)
{
int payloadLength = frame.PayloadData.Length;
List<byte> bytes = new();
// Основные байты заголовка
bytes.Add((byte)((frame.Fin ? 0x80 : 0) | (int)frame.Opcode));
if (payloadLength < 126)
bytes.Add((byte)(payloadLength));
else if (payloadLength <= ushort.MaxValue)
{
bytes.Add((byte)126);
bytes.AddRange(BitConverter.GetBytes((ushort)payloadLength).Reverse());
}
else
{
bytes.Add((byte)127);
bytes.AddRange(BitConverter.GetBytes(ulong.MaxValue).Reverse()); // Поскольку размер пакета ограничен, используем максимальное значение 64 бит
bytes.AddRange(BitConverter.GetBytes(payloadLength).Reverse());
}
bytes.AddRange(frame.PayloadData);
return bytes.ToArray();
}
}
public enum WebSocketOpcode : byte
{
Continuation = 0x0,
Text = 0x1,
Binary = 0x2,
Close = 0x8,
Ping = 0x9,
Pong = 0xA
}
public class WebSocketFrame
{
public bool Fin { get; }
public WebSocketOpcode Opcode { get; }
public byte[] PayloadData { get; }
public WebSocketFrame(WebSocketOpcode opcode, byte[] payloadData)
{
Fin = true;
Opcode = opcode;
PayloadData = payloadData ?? throw new ArgumentNullException(nameof(payloadData));
}
}
В данной статье мы рассмотрели создание клиентского приложения на C# для работы с WebSocket соединением, включая обработку сообщений и передачу данных. Мы также привели примеры реализации собственного сервера WebSocket на основе SslStream и использования сторонних библиотек для упрощения процесса.
Создание и использование WebSocket соединений на C# — это удобный способ реализации двусторонней коммуникации в современных приложениях, таких как чаты, онлайн-игры или системы дальнего контроля. Мы надеемся, что данная статья поможет разработчикам успешно решить задачи, связанные с WebSocket.

