افضل سوكت

انا فى الحقيقيه لست خبير فى تكويد السوكت لكنى بحاجه لسوكت للعبه مالتى بلابير اونلاين بنظام السيرفر و الكلينت تم برمجتها بالسى شارب

مشكلتى فى السوكت انى احتاج الى سوكت يتيح للاكبر عدد من اللاعبين الدخول و التحرك و اللعب داخل السيرفر دون ان يسبب ازدحام او يؤدى الى lag او بمعنى ادق غلق الاتصال مع اللاعبين

و بعد البحث وجدت هذين السوكتين و بصراحه لا اعلم ايهما افضل و يحقق لى استقرار اعلى او ايهما افضل فى الكود كاساس و يمكن عمل اضافات عليه تصل بىى الى النتيجه المطلوبه

فهل احد يساعدنى

هذا هو كود السوكت الاول

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;

namespace Hellmouth.Connections
{
    public class Counter
    {
        uint Start = 0;
        uint finish = uint.MaxValue;
        public uint Finish
        {
            get
            {
                return finish;
            }
            set { finish = value; }
        }
        private uint now;
        public uint Next
        {
            get
            {               
                    now++;
                    if (now == Finish)
                        now = Start;

                Database.ItemCount++;
                return now;
            }
        }
        public Counter()
        { now = Start; }
        public Counter(uint startFrom)
        { Start = startFrom; now = startFrom; }
    }
    public class Wrapper
    {
        public byte[] buffer;
        public Socket _socket;
        public object connector;
    }
    public class WinSocket
    {
        private Counter Incrementer;
        private Dictionary<string, byte> Connections;
        public event Action<Wrapper> AnnounceNewConnection;
        public event Action<Wrapper> AnnounceDisconnection;
        public event Action<byte[], Wrapper, byte[]> AnnounceReceive;
        private Socket _socket;

        public WinSocket(ushort port)
        {
            try
            {
                Incrementer = new Counter();
                Connections = new Dictionary<string, byte>();
                _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _socket.Bind(new IPEndPoint(IPAddress.Any, port));
                _socket.Listen(500);
                _socket.BeginAccept(AcceptConnections, new Wrapper());
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }


        private void AcceptConnections(IAsyncResult result)
        {
            try
            {
                Wrapper wr = result.AsyncState as Wrapper;
                wr._socket = _socket.EndAccept(result);
                #region Invisible
                string IP = wr._socket.RemoteEndPoint.ToString().Split(':')[0].ToString();               
                if (!Connections.ContainsKey(IP))
                    Connections.Add(IP, 1);
                else
                    if (Connections[IP] <= 3)
                    {
                        byte connections = Connections[IP];
                        Connections.Remove(IP);
                        Connections.Add(IP, (byte)(connections + 1));
                    }
                    else
                    {
                        wr._socket.Disconnect(false);
                        _socket.BeginAccept(AcceptConnections, new Wrapper());
                        return;
                    }
                #endregion
                wr.buffer = new byte[65535];
                wr._socket.BeginReceive(wr.buffer, 0, 65535, SocketFlags.None, ReceiveData, wr);
                AnnounceNewConnection.Invoke(wr);
                _socket.BeginAccept(AcceptConnections, new Wrapper());
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
        private void ReceiveData(IAsyncResult result)
        {
            try
            {
                Wrapper wr = result.AsyncState as Wrapper;
                string IP = wr._socket.RemoteEndPoint.ToString().Split(':')[0].ToString();
                if (Connections.ContainsKey(IP))
                {
                    SocketError error = SocketError.Disconnecting;
                    int size = wr._socket.EndReceive(result, out error);
                    if (error == SocketError.Success && size != 0)
                    {
                        byte[] buffer = new byte[size];
                        Buffer.BlockCopy(wr.buffer, 0, buffer, 0, size);
                        byte[] question = new byte[] { 1 };
                        AnnounceReceive.Invoke(buffer, wr, question);
                        if (wr._socket.Connected && question[0] == 1)
                            wr._socket.BeginReceive(wr.buffer, 0, 65535, SocketFlags.None, ReceiveData, wr);
                    }
                    else
                    {
                        if (wr._socket.Connected)
                        {
                            wr._socket.Disconnect(true);
                        }
                        byte connections = Connections[IP];
                        Connections.Remove(IP);
                        Connections.Add(IP, (byte)(connections - 1));
                        try
                        {
                            AnnounceDisconnection.Invoke(wr);
                        }
                        catch { }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }
}

و هذا هو كود السوكت الثانى

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace Hellmouth.Connections
{
    public class NetworkClient
    { 
        private Socket socket;
        private byte[] buffer;
        private NetworkServerSocket server;
        public Socket Socket { get { return socket; } }
        public NetworkServerSocket Server { get { return server; } }
        public object Owner;
        public string IP;
        public bool Alive;

        public NetworkClient(NetworkServerSocket _server, Socket _socket, int buffer_len)
        {
            Alive = true;
            server = _server;
            socket = _socket;
            buffer = new byte[buffer_len];
            try { IP = (socket.RemoteEndPoint as IPEndPoint).Address.ToString(); }
            catch (SocketException) { }
        }
        public void BeginReceive()
        {
            try
            {
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Receive), null);
            }
            catch (SocketException)
            {
                server.InvokeDisconnect(this);
            }
        }
        private void Receive(IAsyncResult res)
        {
            if (socket != null)
            {
                try
                {
                    int len = socket.EndReceive(res);
                    if (this.Alive)
                    {
                        if (len > 0)
                        {
                            byte[] received = new byte[len];
                            Buffer.BlockCopy(buffer, 0, received, 0, len);                            
                            if (server.OnReceive != null)
                            {
                                server.OnReceive(this, received);
                            }

                            BeginReceive();
                        }
                        else
                        {
                            server.InvokeDisconnect(this);
                        }
                    }
                }
                catch (SocketException)
                {
                    server.InvokeDisconnect(this);
                }
            }
        }
        public void Send(byte[] Packet)
        {
            if (Alive)
            {
                try
                {
                    socket.BeginSend(Packet, 0, Packet.Length, SocketFlags.None, new AsyncCallback(EndSend), null);
                }
                catch (SocketException)
                {
                    Server.InvokeDisconnect(this);
                }
            }
        }
        private void EndSend(IAsyncResult res)
        {
            try
            {
                socket.EndSend(res);
            }
            catch (SocketException)
            {
                server.InvokeDisconnect(this);
            }
        }
        public void Disconnect()
        {
            try { socket.Disconnect(false); }
            catch (SocketException) { }
            server.InvokeDisconnect(this);
        }
    }

    public delegate void NetworkClientConnection(NetworkClient Client);
    public delegate void NetworkClientReceive(NetworkClient Client, byte[] Packet);

    public class NetworkServerSocket
    {
        private Socket server;
        private int m_Port;

        public Socket Socket { get { return server; } }
        public int Port { get { return m_Port; } }

        public NetworkClientConnection OnConnect;
        public NetworkClientReceive OnReceive;
        public NetworkClientConnection OnDisconnect;

        public int ClientBufferSize;

        public NetworkServerSocket()
        {
            server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }
        public void Prepare(int port, int backlog)
        {
            m_Port = port;
            server.Bind(new IPEndPoint(IPAddress.Any, m_Port));
            server.Listen(backlog);
        }
        public void BeginAccept()
        {
            server.BeginAccept(new AsyncCallback(Accept), null);
        }
        private void Accept(IAsyncResult res)
        {
            Socket client_socket;
            try { client_socket = server.EndAccept(res); }
            catch (SocketException)
            {
                BeginAccept();
                return;
            }

            client_socket.ReceiveBufferSize = ClientBufferSize;
            NetworkClient client = new NetworkClient(this, client_socket, ClientBufferSize);
            if (OnConnect != null)
            {
                OnConnect(client);
            }
            client.BeginReceive();
            BeginAccept();
        }
        public void InvokeDisconnect(NetworkClient Client)
        {
            if (!Client.Alive)
                return;
            Client.Alive = false;
            if (OnDisconnect != null)
                OnDisconnect(Client);
        }
    }
}