Не могу получить сообщение, пока не отправлю своё. Или не могу отправить своё пока не получу чужое

private Socket listener = new(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
private IPEndPoint IPEndPoint = new(IPAddress.Any, port);
private ConcurrentDictionary<string, Socket> _sockets = [];
private byte[]? data;
 
public async Task Start()
{
    listener.Bind(IPEndPoint);
    listener.Listen();
    await Console.Out.WriteLineAsync("Сервер запущен. Ожидание подключений. . .");
}
 
public async Task GetConnectionsAsync()
{
    while(true)
    {
        var tcpClient = await listener.AcceptAsync();
 
        await Console.Out.WriteLineAsync($"Установлено соединение с {tcpClient.RemoteEndPoint}");
 
        await ReceiveRequestAsync(tcpClient);
    }
}
 
public async Task ReceiveRequestAsync(Socket socket)
{
    data = new byte[512];
    int bytes = await socket.ReceiveAsync(data);
    if(bytes > 0)
    {
        string request = Encoding.UTF8.GetString(data, 0, bytes);
        var received = JsonSerializer.Deserialize<ClientObject>(request);
        if(_sockets.TryAdd(received.Id, socket))
        {
            if(string.IsNullOrEmpty(received.Message))
            {
                var response = $"Привет, {received.Name}";
                await SendMessageAsync(socket, response);
            }
        }
    }
}
 
private async Task SendMessageAsync(Socket socket, string message)
{
    data = Encoding.UTF8.GetBytes(message);
    using var stream = new NetworkStream(socket);
    await stream.WriteAsync(data.AsMemory(0, data.Length));
}
 
 
public async Task StartChatAsync()
{
    while(true)
    {
        foreach(var socket in _sockets.Values)
        {
            using(var stream = new NetworkStream(socket))
            {
                var data = new byte[512];
                int bytes = await socket.ReceiveAsync(data);
 
                if(data[0] != 0)
                {
                    var co = JsonSerializer.Deserialize<ClientObject>(Encoding.UTF8.GetString(data, 0, bytes));
                    
                    await ChattingAsync(co);
                }
                else
                {
                    break;
                }
            };
 
        }
    }
}
 
private async Task ChattingAsync(ClientObject client)
{
    byte[] data = new byte[512];
    var msg = string.Empty;
    msg = $"{client.Name}: {client.Message}";
 
    data = Encoding.UTF8.GetBytes(msg);
 
    if(_sockets.Count > 1)
    {
        foreach(var socket in _sockets.Values)
        {
            if(socket.Connected && _sockets[client.Id] != socket)
            {
                using var stream = new NetworkStream(socket);
                await stream.WriteAsync(data.AsMemory(0, data.Length));
            }
        }
    }
    else
    {
        data = Encoding.UTF8.GetBytes("Сообщение доставлено!");
        using var stream = new NetworkStream(_sockets[client.Id]);
        await stream.WriteAsync(data.AsMemory(0, data.Length));
    }
}

        public string Id { get; } = Guid.NewGuid().ToString();
        public string Name { get; } = name;
        public string? Message { get; set; }
 
        [NonSerialized]
        private IPAddress _serverAddress = IPAddress.Parse("127.0.0.1");
        [NonSerialized]
        private int _serverPort = 8888;
        [NonSerialized]
        private static Socket _client = new(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        [NonSerialized]
        private byte[]? data;
        [NonSerialized]
        private (int, int) _lines = (0,3);
 
        public async Task Connect()
        {
            await _client.ConnectAsync(_serverAddress, _serverPort);
 
 
            data = new byte[512];
 
            data = Encoding.UTF8.GetBytes(ToText());
 
            await _client.SendAsync(data);
        }
 
        public async Task ReceiveResponseAsync()
        {
            data = new byte[512];
            int bytes = await _client.ReceiveAsync(data);
            if(bytes > 0)
            {
                string response = Encoding.UTF8.GetString(data, 0, bytes);
                var pos = Console.GetCursorPosition();
                Console.SetCursorPosition(_lines.Item1, _lines.Item2);
                await Console.Out.WriteLineAsync(response);
                _lines.Item2++;
                Console.SetCursorPosition(pos.Left, pos.Top);
            }
        }
 
        public async Task SendMessageAsync()
        {
            Console.Write("Введите сообщение: ");
            var pos = Console.GetCursorPosition();
            while(true)
            {
                byte[] data = new byte[512];
                string? msg = Console.ReadLine();
                Console.SetCursorPosition(pos.Left, pos.Top);
                Console.Write(MakeWhiteSpace(msg));
                Console.SetCursorPosition(pos.Left, pos.Top);
                if(!string.IsNullOrEmpty(msg))
                {
                    Message = msg;
 
                    data = Encoding.UTF8.GetBytes(ToText());
                    await _client.SendAsync(data);
                }
 
                int bytes = await _client.ReceiveAsync(data);
                if(bytes > 0)
                {
                    string response = Encoding.UTF8.GetString(data, 0, bytes);
                    Console.SetCursorPosition(_lines.Item1, _lines.Item2);
                    await Console.Out.WriteLineAsync(response);
                    _lines.Item2++;
                    Console.SetCursorPosition(pos.Left, pos.Top);
                }
            }
        }
 
        private string MakeWhiteSpace(string text)
        {
            string whiteSpaces = string.Empty;
            for(int i = 0; i < text.Length; i++)
            {
                whiteSpaces += " ";
            }
            return whiteSpaces;
        }
 
        private string ToText() => JsonSerializer.Serialize(this, typeof(Client));

Server server = new(8888);
 
await server.Start();
 
Thread thread = new(async () => await server.GetConnectionsAsync());
 
thread.Start();
 
await server.StartChatAsync();

string name = string.Empty;
 
Console.WriteLine("Введите своё имя:");
 
name = Console.ReadLine();
if(!string.IsNullOrEmpty(name))
{
 
    Client client = new(name);
 
    await Task.Run(async () => await client.Connect());
 
    Thread t = new(async () => await client.ReceiveResponseAsync());
    t.Start();
    await client.SendMessageAsync();
}

public async Task ReceiveRequestAsync(Socket socket)
{
    data = new byte[512];
   // сначала получить от сокета
    int bytes = await socket.ReceiveAsync(data);
    if(bytes > 0)
    {
        string request = Encoding.UTF8.GetString(data, 0, bytes);
        var received = JsonSerializer.Deserialize<ClientObject>(request);
        if(_sockets.TryAdd(received.Id, socket))
        {
            if(string.IsNullOrEmpty(received.Message))
            {
                // затем ответить собеседнику
                var response = $"Привет, {received.Name}";
                await SendMessageAsync(socket, response);
            }
        }
    }
}

public async Task StartChatAsync()
{
    while(true)
    {
        foreach(var socket in _sockets.Values)
        {
            using(var stream = new NetworkStream(socket))
            {
                var data = new byte[512];
 
                // получить данные с этого хоста, зачем - непонятно
                int bytes = await socket.ReceiveAsync(data);
 
                if(data[0] != 0)
                {
                    var co = JsonSerializer.Deserialize<ClientObject>(Encoding.UTF8.GetString(data, 0, bytes));                    
                    // и только потом продолжить общение
                    await ChattingAsync(co);
                }
                else
                {
                    break;
                }
            };
 
        }
    }
}

public async Task ReceiveRequestAsync(Socket socket)
{
    data = new byte[512];
    int bytes = await socket.ReceiveAsync(data);
   ....
}

while(true)

    while(true)
    {
// ждем новое подключение(!)
        var tcpClient = await listener.AcceptAsync();
// пишем лог  
        await Console.Out.WriteLineAsync($"Установлено соединение с {tcpClient.RemoteEndPoint}");
// выполняем один раз чтение и отправку ответа 
        await ReceiveRequestAsync(tcpClient);
// возращаемся в начало цикла
    }

var received = JsonSerializer.Deserialize<ClientObject>(request);

if(_sockets.TryAdd(received.Id, socket))

private async Task SendMessageAsync(Socket socket, string message)
{
    data = Encoding.UTF8.GetBytes(message);
    using var stream = new NetworkStream(socket);
    await stream.WriteAsync(data.AsMemory(0, data.Length));
}

public async Task StartChatAsync()
{
//..
        foreach(var socket in _sockets.Values)
        {
            using(var stream = new NetworkStream(socket))
            {
                var data = new byte[512];
                int bytes = await socket.ReceiveAsync(data);
//..
            };
 
        }

        public async Task Connect()
        {
            await _client.ConnectAsync(_serverAddress, _serverPort);
            data = new byte[512];
            data = Encoding.UTF8.GetBytes(ToText());

        public async Task ReceiveResponseAsync()
        {
            data = new byte[512];
            int bytes = await _client.ReceiveAsync(data);

int bytes = await _client.ReceiveAsync(data);
            if(bytes > 0)