Task вызов

private static async Task ClientService(Client client, CancellationToken ct)
{
    await ReadAsync(client, ct);
}

var task = ClientService(client, cts.Token);

var task = Task.Run(() => ClientService(client, cts.Token));

private static void ClientService(Client client, CancellationToken ct)
{
     var task = Task.Run(() => ReadAsync(client, cts.Token));
}

ClientService(client, cts.Token);

private static Task ClientService(Client client, CancellationToken ct)
{
    return ReadAsync(client, ct);
}

while (!cts.IsCancellationRequested)
                {
                    Console.WriteLine("Waiting for a connection...");
                    var client = await AcceptClient();
                    var task = ClientService(client, cts.Token);
                }

private static async void ClientService(Client client, CancellationToken ct)
{
    return ReadAsync(client, ct);
}

private static async Task<Client> AcceptClient(CancellationToken ct)
{
     var client = new Client();
     var socket = await Task<Socket>.Factory.FromAsync(listener.BeginAccept, listener.EndAccept, null).ConfigureAwait(false);;
     client.workSocket = socket;
     client.id = clients.Count;
     client.ip = socket.RemoteEndPoint.ToString();
     clients.Add(client);
     Console.WriteLine("Clients count is: " + clients.Count + " IP: " + client.ip);
     return client;
}

private static async Task<Client> AcceptClient(CancellationToken ct)
{
     var socket = await Task<Socket>.Factory.FromAsync(listener.BeginAccept, listener.EndAccept, null).ConfigureAwait(false);
     ct.ThrowIfCancellationRequested();
 
     var client = new Client();
     client.workSocket = socket;
     client.id = clients.Count;
     client.ip = socket.RemoteEndPoint.ToString();
     clients.Add(client);
     Console.WriteLine("Clients count is: " + clients.Count + " IP: " + client.ip);
     return client;
}

var token = cts.Token;
using (var registration = token.Register(client.Close))
{
   while (!token.IsCancellationRequested)
   {
      Console.WriteLine("Waiting for a connection...");
      try
      {
         var client = await AcceptClient();
         var task = ClientService(client, token);
      }
      catch (OperationCancelledException) { break; }
      catch (ObjectDisposedException) when (token.IsCancellationRequested) { break; }
   }
}

 using (var registration = cts.Token.Register(() => listener.Close()))
            {
                while (!cts.IsCancellationRequested)
                {
                    Console.WriteLine("Waiting for a connection...");
                    try
                    {
                        var client = await AcceptClient(cts.Token);
                        var task = Task.Run(() => ClientService(client, cts.Token));
                    }
                    catch (OperationCanceledException) { break; }
                    catch (ObjectDisposedException) when (cts.Token.IsCancellationRequested) { break; }
                }
            }

using (var registration = token.Register(listener.Close))

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using Database;
using MongoScripts;
using Microservices;
using System.Linq;
using System.Threading.Tasks;
using MongoDB.Driver;
using System.Collections.Concurrent;
using Server;
using System.IO;
 
namespace Server
{
    public class Client
    { 
        public Socket socket = null;        
        public int id { get; set; }
        public string userId { get; set; }
        public string ip { get; set; }
        public string authToken { get; set; }
        public string characterId { get; set; }
        //Size of receive buffer.
        public const int BufferSize = 1000000;
        //Receive buffer.
        public byte[] buffer = new byte[BufferSize];
        //Received data string.
        public StringBuilder sb = new StringBuilder();  
    }
 
    public static class Connector
    {
        public static List<Client> clients = new List<Client>();
        private static CancellationTokenSource cts;
        private static Socket listener;
 
        /// <summary>
        /// Start tcp server
        /// </summary>
        public static async Task StartListening()
        {  
            cts = new CancellationTokenSource();      
 
            // IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
            // IPAddress ipAddress = ipHostInfo.AddressList[0];
            // IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
 
            //Establish the endpoint for the socket.
            IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 1121);
 
            //Create a TCP/IP socket.
            listener = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);
            Console.WriteLine(@"  
            ===================================================  
                   Started listening requests at: {0}:{1}  
            ===================================================",   
            endPoint.Address, endPoint.Port);  
            try 
            {
                //Bind the socket to the local endpoint and listen for incoming connections.
                listener.Bind(endPoint);
                listener.Listen(100);
 
                DbConnect.Connect();
                // var monstersGenerator = new MonstersGenerator();
                // var skillsGenerator = new SkillsGenerator();
                // var eliteMonstersGenerator = new EliteMonstersGenerator();
                // var bosses = new BossesGenerator();
                // var locationGenerator = new LocationGenerator();
                // ServerGenerator.ServerGeneratorAsync("Server3");
                // CharacterClassesGenerator.CharacterClassesGeneratorAsync();
                // monstersGenerator.GenerateMonster();
                // skillsGenerator.GenerateSkills();
                // eliteMonstersGenerator.EliteGenerateMonsterArmor();
                // eliteMonstersGenerator.EliteGenerateMonsterDmg();
                // eliteMonstersGenerator.EliteGenerateMonsterHp();
                // bosses.GenerateBoss();
                // locationGenerator.GenerateLocation();
                // ItemGenerator.itemGeneratorAsync(characterId: "5aa4eeb4482907ab7479adf9", level: 1, quantity: 30);
                // BotsGenerator.BotsGeneratorAsync();
            }
            catch (Exception e) 
            {
                Console.WriteLine(e.ToString());
            }
            Stop();
            using (var registration = cts.Token.Register(listener.Close))
            {
                while (!cts.IsCancellationRequested)
                {
                    Console.WriteLine("Waiting for a connection...");
                    try
                    {
                        var client = await AcceptClient(cts.Token);
                        var task = Task.Run(() => ClientService(client, cts.Token));
                    }
                    catch (OperationCanceledException) { break; }
                    catch (ObjectDisposedException) when (cts.Token.IsCancellationRequested) { break; }
                }
            }
        }
 
        private static async Task ClientService(Client client, CancellationToken ct)
        {
            await ReadAsync(client, ct);
        }
 
        private static async Task<Client> AcceptClient(CancellationToken ct)
        {
            var socket = await Task<Socket>.Factory.FromAsync(listener.BeginAccept, listener.EndAccept, null).ConfigureAwait(false);
            ct.ThrowIfCancellationRequested();
            var client = new Client();
            client.socket = socket;
            client.id = clients.Count;
            client.ip = socket.RemoteEndPoint.ToString();
            clients.Add(client);
            Console.WriteLine("Clients count is: " + clients.Count + " IP: " + client.ip);
            return client;
        }
 
        private static async void Stop()
        {
            await Task.Delay(7000);
            try
            {
                cts.Cancel();
            }
            finally
            {
            }
            for (int i = 0; i < clients.Count; i++)
            {
                clients[i].socket.Shutdown(SocketShutdown.Both);
            }
            
            Console.Write("Server Stopped! ");
        }
 
        private static async Task ReadAsync(Client client, CancellationToken ct)
        {
            while (!ct.IsCancellationRequested)
            {
                try
                {
                    client.socket.SetKeepAlive(1000, 1000);
                    string content = string.Empty;
 
                    var bytesRead = await Task.Factory.FromAsync(
                        client.socket.BeginReceive(client.buffer, 0, Client.BufferSize, SocketFlags.None, null, client.socket),
                            client.socket.EndReceive).ConfigureAwait(false);
                    ct.ThrowIfCancellationRequested();
 
                    if (bytesRead > 0) 
                    {
                        client.sb.Append(Encoding.UTF8.GetString(
                            client.buffer, 0, bytesRead));
                        content = client.sb.ToString();
 
                        //Check for end-of-file tag. If it is not there, read 
                        //more data.
                        if (content.EndsWith("±☭")) 
                        {
                            string[] fullCommands = content.Remove(content.Length - 1).Split('☭');
 
                            for (int i = 0; i < fullCommands.Length; i++)
                            {
                                string[] commands = fullCommands[i].Remove(fullCommands[i].Length - 1).Split('§');
                            
                                //string[] commands = content.Remove(content.Length - 2).Split('§');
                                //All the data has been read from the 
                                //client. Display it on the console.
                                Console.WriteLine("Read {0} bytes from socket. \nData : {1}",
                                    content.Length, content );
                                //для дебага
                                for (int j = 0; j < commands.Length; j++)
                                {
                                    Console.WriteLine($"Command {j}: " + commands[j]);
                                }
 
                                if (commands[0].Contains("GetServers"))
                                    CommandProcessor.GetServers(commands[0], client.socket);
                                else if (commands[0].Contains("Login"))
                                    CommandProcessor.Login(commands[0], commands[1], client.socket);
                                else if (commands[0].Contains("GetCharacterClasses"))
                                    CommandProcessor.GetCharacterClasses(commands[0], commands[1], client.socket);
                                else if (commands[0].Contains("CreateCharacter"))
                                    CommandProcessor.CreateCharacter(commands[0], commands[1], client.socket);
                                else if (!string.IsNullOrEmpty(commands[2]) && !string.IsNullOrEmpty(commands[3]))
                                {
                                    if(clients.Any(c => c.authToken == commands[2] && c.characterId == commands[3]))
                                    {
                                        CommandProcessor.CommandHandler(commands[0], commands[1], client.socket);
                                    }
                                    else
                                    {
                                        SocketClose(client);
                                        break;
                                    }
                                }
                                else
                                {
                                    SocketClose(client);
                                    break;
                                }
                                    
                                client.sb.Clear();
                                Array.Clear(commands, 0, commands.Length); //очищаем команды
                            }
                        }
                    }
                    else
                    {
                        //Disconnect clients
                        SocketClose(client);
                        break;
                    }
                }
                catch (SocketException se)
                {
                    Console.WriteLine(se.SocketErrorCode.ToString());
                    SocketClose(client);
                    break;
                }
            }
        }
 
        private static void SocketClose(Client client)
        {
            client.socket.Shutdown(SocketShutdown.Both);
            client.socket.Disconnect(false);
            client.socket.Close();
 
            if(!string.IsNullOrEmpty(client.characterId))
                ClientsHandler.UpdateUserConnectDisconnectTime(client.characterId, "lastSeen").GetAwaiter().GetResult();
 
            clients.Remove(client);
            Console.WriteLine($"User with ID: {client.id} and IP: {client.ip} is disconnected");
        }
 
        public static async Task SendAsync(Socket client, string data)
        {
            // Convert the string data to byte data using UTF8 encoding.
            byte[] byteData = Encoding.UTF8.GetBytes(data);
            try
            {
                var bytesSent = await Task.Factory.FromAsync(
                    client.BeginSend(byteData, 0, byteData.Length, SocketFlags.None, null, client),
                        client.EndSend).ConfigureAwait(false);
                Console.WriteLine("Sent {0} bytes to client with ID: {1}.", bytesSent, clients.FirstOrDefault(c => c.socket == client).id);
            }
            catch(SocketException e)
            {
                Console.WriteLine("Send: " + e.SocketErrorCode);
            }         
        }
 
        public static async Task SendToAllClientsAsync(string data)
        {
            for (int i = 0; i < clients.Count; i++)
            {
                await SendAsync(clients[i].socket, data);
            }
        }
        
        public static int Main(String[] args) 
        {
            StartListening().GetAwaiter().GetResult();
          
            return 0;
        }
    }
}