Ошибка подключения к серверу WebSocket

using Microsoft.AspNetCore.HttpOverrides;
using System.Text.Json.Serialization;
 
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers().AddJsonOptions(options =>
{
    options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
});
var connectionString = builder.Configuration.GetConnectionString("Programs");
builder.Services.AddSqlite<ContextProgram>(connectionString);
var app = builder.Build();
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
app.UseHttpsRedirection();
 
var webSocketOptions = new WebSocketOptions
{
    KeepAliveInterval = TimeSpan.FromMinutes(15)
};
app.UseWebSockets(webSocketOptions);
app.UseAuthorization();
app.MapControllers();
 
app.Run();

public class SocketController : Controller
    {
        [HttpGet("/ws")]
        public async Task Get()
        {
            if (HttpContext.WebSockets.IsWebSocketRequest)
            {
                using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
                await Socket(webSocket);
            }
            else
            {
             //   HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
            }
        }
        private async Task Socket(WebSocket webSocket)
        {
            try
            {
                var buffer = new byte[1024 * 4];
                var receiveResult = await webSocket.ReceiveAsync(
                    new ArraySegment<byte>(buffer), CancellationToken.None);
 
                while (!receiveResult.CloseStatus.HasValue)
                {
                    await webSocket.SendAsync(
                        new ArraySegment<byte>(buffer, 0, receiveResult.Count),
                        receiveResult.MessageType,
                        receiveResult.EndOfMessage,
                        CancellationToken.None);
 
                    receiveResult = await webSocket.ReceiveAsync(
                        new ArraySegment<byte>(buffer), CancellationToken.None);
                    await Task.Delay(10);
                }
                await webSocket.CloseAsync(
                    receiveResult.CloseStatus.Value,
                    receiveResult.CloseStatusDescription,
                    CancellationToken.None);
            }
            catch (Exception ex) 
            {
                string message = ex.Message.ToString();
               // webSocket.Abort();
            }
        }
    }

using System.Net.WebSockets;
using System.Text;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
 
 
SemaphoreSlim _semaphore;
CancellationTokenSource _cancelToken;
CancellationTokenSource CancellationTokenSource = new();
Console.WriteLine("Start");
 
int thread = 1000;
_semaphore = new SemaphoreSlim(thread);
_cancelToken = new CancellationTokenSource();
 
var pool = new List<Task>(thread);
 
for (int i = 0; i < thread; i++)
{
    await _semaphore.WaitAsync().ConfigureAwait(false);
    int val = i;
    ClientWebSocket webSocketClient = new ClientWebSocket();
    CancellationToken cancellationToken = new();
    pool.Add(Task.Run(async () =>
    {
        await Socket(webSocketClient, cancellationToken, val);
        _semaphore.Release();
    }, _cancelToken.Token));
}
 
await Task.WhenAll(pool.ToArray()).ConfigureAwait(false);
Console.WriteLine("Done");
Console.ReadKey();
async Task Socket(ClientWebSocket webSocketClient, CancellationToken cancellationToken, int i)
{
    string error = "";
    try
    {
        await webSocketClient.ConnectAsync(new Uri("ws://localhost:5000/ws"), cancellationToken).ConfigureAwait(false);
        if (webSocketClient.State == WebSocketState.Open)
        {
            await Send(webSocketClient, i.ToString(), cancellationToken);
            await SocketNew(webSocketClient);
        }
    }
    catch (Exception ex)
    {
        error = ex.Message.ToString();
        Console.WriteLine("Ошибка подключения" + $" {error}");
        return;
    }
}
async Task Send(ClientWebSocket webSocketClient, string requestString, CancellationToken cancellationToken)
{
    var requestBytes = UTF8Encoding.UTF8.GetBytes(requestString);
    var subscribeRequest = new ArraySegment<byte>(requestBytes);
    await webSocketClient.SendAsync(subscribeRequest, WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
}
async Task SocketNew(WebSocket webSocket)
{
    try
    {
        var buffer = new byte[1024 * 4];
        var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        while (!receiveResult.CloseStatus.HasValue)
        {
            string message = Encoding.UTF8.GetString(buffer, 0, receiveResult.Count);
            Console.WriteLine("Ответ от сокета " + message + $" Поток: {Thread.CurrentThread.ManagedThreadId}");
            if (message != "")
            {
                await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Connection closed", CancellationToken.None);
                return;
            }
            receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Ошибка при получение ответа");
    }
}

await webSocketClient.ConnectAsync(new Uri("ws://localhost:5000/ws"), cancellationToken).ConfigureAwait(false);