C# Server

//Тут если подключился новый клиент
private void AsyncAcceptCompleted(object sender, SocketAsyncEventArgs e) //When who connected
        {
            try
            {
                //Заново идем принимать новые подключения
                AsyncAccept();
                Socket newSock = e.AcceptSocket;
                if (newSock != null)
                {
                    Buffer buffer = new Buffer();
                    var checkIp = players.AsParallel().Where(player => (player.socket.RemoteEndPoint as IPEndPoint).Address.ToString() == (newSock.RemoteEndPoint as IPEndPoint).Address.ToString());
                   /* if (checkIp.Count() != 0)
                    {
                        buffer.writer.Write((short)2);
                        newSock.Send(buffer.memory.ToArray());
                        buffer.Clear();
                        Console.WriteLine("Попытка множественного подключения с " + (newSock.RemoteEndPoint as IPEndPoint).Address);
                        newSock.Dispose();
                        return;
                    }*/
                    Player p = new Player(newSock,getId()); //Создаем нового игрока
                    players.Add(p);;
                    Console.WriteLine("New connection from " + (newSock.RemoteEndPoint as IPEndPoint).Address);
                    buffer.WriteByte(0);
                    buffer.WriteIn16(p.id);
                    p.socket.Send(buffer.memory.ToArray());
                    buffer.Clear();
                    AsyncReceive(p); //Принимаем от этого клиента данные
                }
                e.Dispose();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                e.Dispose();
            }
        }

//Запускаем асинхронную операцию для ожидания данных от сокета
private void AsyncReceive(Player player)
        {
            try
            {
                if (player.socket.Connected)
                {
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                    e.Completed += AsyncReceiveCompleted;
                    e.SetBuffer(player.data, 0, player.data.Length);
                    player.socket.ReceiveAsync(e);
                }
                else
                {
                    IdMap[player.id] = -1;
                    lock (players)
                        players.Remove(player);
                    Console.WriteLine("{0} disconnected", (player.socket.RemoteEndPoint as IPEndPoint).Address);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
//Если пришли данные
private void AsyncReceiveCompleted(object sender, SocketAsyncEventArgs e)
        {
            try
            {
                Player player = FindPlayer(sender as Socket);
                if (!player.socket.Connected)
                {
                    IdMap[player.id] = -1;
                    lock (players)
                        players.Remove(player);
                    Console.WriteLine("{0} disconnected", (player.socket.RemoteEndPoint as IPEndPoint).Address);
                    e.Dispose();
                    return;
                }
                SocketAsyncEventArgs sendAsyncEvent = new SocketAsyncEventArgs();
                sendAsyncEvent.Completed += SendAsyncCompleted;
                Buffer buffer = new Buffer();
                Buffer buff = new Buffer(e.Buffer);
                bool disconnected = false;
                int count = 0;
                do
                {
                    count++;
                    byte message_id = buff.ReadByte();
                    switch (message_id)
                    {
                        case 0: //Получаем имя игрока
                            string name = buff.ReadString();
                            player.Init(name, gameplay.spawnX, gameplay.spawnY, gameplay.startDirection);
                            buffer.WriteByte(3);
                            buffer.WriteIn16(player.id);
                            buffer.WriteInt32(player.x);
                            buffer.WriteInt32(player.y);
                            buffer.WriteDouble(player.direction);
                            buffer.WriteString(player.username);
                            SendAll(buffer.memory.ToArray());
                            buffer.SeekStart();
                            buffer.WriteByte(4);
                            buffer.WriteInt32(players.Count - 1);
                            foreach (var p in players)
                            {
                                if (p.id != player.id)
                                {
                                    buffer.WriteIn16(p.id);
                                    buffer.WriteInt32(p.x);
                                    buffer.WriteInt32(p.y);
                                    buffer.WriteDouble(p.direction);
                                    buffer.WriteString(p.username);
                                }
                            }
                            sendAsyncEvent.SetBuffer(buffer.memory.ToArray(), 0, buffer.memory.ToArray().Length);
                            player.socket.SendAsync(sendAsyncEvent);
                            break;

                        case 1: //Disconnect
                            Console.WriteLine("{0} disconnected", (player.socket.RemoteEndPoint as IPEndPoint).Address);
                            buffer.WriteByte(5);
                            buffer.WriteIn16(player.id);
                            SendAll(buffer.memory.ToArray());
                            IdMap[player.id] = -1;
                            lock (players)
                            {
                                player.socket.Dispose();
                                players.Remove(player);
                            }
                            disconnected = true;
                            break;

                        case 2: //Получаем координаты от игрока
                            int x = buff.ReadInt32();
                            int y = buff.ReadInt32();
                            double dir = buff.ReadDouble();
                            player.x = x;
                            player.y = y;
                            player.direction = dir;
                            buffer.WriteByte(6);
                            buffer.WriteIn16(player.id);
                            buffer.WriteInt32(x);
                            buffer.WriteInt32(y);
                            buffer.WriteDouble(dir);
                            SendAll(buffer.memory.ToArray());
                            break;
                    }
                }
                while (buff.Tell() != e.BytesTransferred); //На всякий случай, если пакеты склеются
                if (count != 1)
                    Console.WriteLine("sdjfk"); //Не обращай внимания, это просто для дебага
                Array.Clear(player.data, 0, player.data.Length); //Чистим байтовый массив у игрока
                if (!disconnected)
                    AsyncReceive(player); //Если игрок не отключился, то идем заново принимать от него данные
                buffer.Clear();
                buff.Clear();
                e.Dispose(); //Для высвобождения памяти, асинхронность, сам понимаешь
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                e.Dispose();
            }
        }
//Отправляем всем данные
private void SendAll(byte[] data)
        {
            try
            {
                lock (players) //Нужно, потому что у меня в отдельном потоке стоит цикл, который проверяет внезапные дисконнекты у игроков
                {
                    foreach (var p in players)
                    {
                        SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                        e.SetBuffer(data, 0, data.Length);
                        e.Completed += SendAsyncCompleted;
                        p.socket.SendAsync(e);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }