Продам сайты

Реализация своего механизма работы с WebSockets

WebSockets представляют собой протокол, который обеспечивает двустороннюю связь между клиентом и сервером по одной полупостоянной TCP-соединению. Это позволяет передавать данные в реальном времени без необходимости производить частые переподключения, как это делают традиционные HTTP-запросы. В данной статье мы подробно разберем, как можно реализовать собственный механизм работы с WebSockets на языке C#. Мы охватим основные аспекты от установления соединения до обработки сообщений и закрытия соединения.

Перед тем как приступить к реализации, давайте познакомимся с основными концепциями WebSockets. Этот протокол позволяет клиенту и серверу обмениваться данными без необходимости отправлять запросы отдельно для каждого сообщения. Веб-клиент (обычно браузер) может установить WebSocket соединение с сервером, после чего можно передавать данные в обоих направлениях до тех пор, пока соединение активно.

  • Реальное время: Обеспечивает возможность обмена данными без задержки, что критически важно для таких приложений, как чаты или игры.
  • Эффективность: Устраняет необходимость в периодическом отправлении запросов от клиента, используя постоянное соединение.
  • Простота обмена сообщениями: Веб-сервер и клиент могут обмениваться данными с минимальными ограничениями.

На языке C# для работы с WebSockets существует несколько подходов. Наиболее распространенные из них:

  1. Использование стандартной библиотеки .NET Core/ASP.NET Core.
  2. Реализация на основе Socket класса для полного контроля.
  3. Создание пользовательского серверного движка.

Фреймворк 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, необходимо выполнять несколько шагов:

  1. Создание серверного Socket объекта.
  2. Прием и обработка WebSocket handshake (рукопожатия).
  3. Обработка сообщений со стороны клиента.
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 соединений, можно реализовать собственный серверный движок. Это позволит настраивать механизмы управления потоками, безопасность и другие важные аспекты.

  1. Построение основной структуры: Создание классов для обработки соединений и сообщений.
  2. Обеспечение безопасности: Использование SSL/TLS для защиты данных.
  3. Асинхронная обработка запросов: Реализация методов, позволяющих эффективно управлять множеством соединений.
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: Используется для проверки корректности данных на стороне клиента.

Для расшифровки и отправки пакетов используются следующие шаги:

  1. Чтение заголовков: Парсинг первых двух байт для получения информации о флагах и длине сообщения.
  2. Обработка заголовков: В зависимости от размера данных, необходимо прочитать соответствующее количество дополнительных байт для определения полной длины пакета.
  3. Декодирование: Если сообщение зашифровано (клиент -> сервер), нужно использовать маску из заголовка для расшифровки данных.
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.

Оцените статью
Все о языке программирования C#