Rework the server connection to be more structured

MistoxServer/Server/Connection.cs

@@ -1,10 +0,0 @@
-using System.Net;
-
-namespace MistoxServer.Server {
-
-    public class Connection {
-        public mTCPServer slowClient { get; set; }
-        public IPEndPoint fastClient { get; set; }
-    }
-
-}

MistoxServer/Server/ServerListener.cs

@@ -6,48 +6,46 @@ using System.Threading.Tasks;
 
 // Client Connections
 
-namespace MistoxServer.Server {
-    public class mTCPListener : IDisposable {
+namespace Mistox.Server {
+    public class ServerListener : IDisposable {
 
         public event EventHandler onConnected;
         public event EventHandler onDisconnected;
         public event EventHandler onReceive;
 
+        MistoxServer _MistoxServer;
         TcpListener Listener;
-        bool Alive;
-        int port;
 
-        public mTCPListener( int Port ) {
-            port = Port;
-            Alive = true;
+        public ServerListener( MistoxServer ServerInstance ) {
+            _MistoxServer = ServerInstance;
             Thread ConnectionThread = new Thread(async () => await ListenerThread() );
             ConnectionThread.Start();
         }
 
         async Task ListenerThread() {
-            Listener = new TcpListener( IPAddress.Any, port );
+            Listener = new TcpListener( _MistoxServer.BindAddress, _MistoxServer.Port );
             Listener.Start();
-            while( Alive ) {
+            while( _MistoxServer.Alive ) {
                 TcpClient client = await Listener.AcceptTcpClientAsync();
+                
+                if (_MistoxServer.Connections.Count + 1 > _MistoxServer.MaxClients) {
+                    continue;
+                }
 
-                Connection user = new Connection(){
-                    slowClient = new mTCPServer( client ),
-                    fastClient = new IPEndPoint( ((IPEndPoint)client.Client.RemoteEndPoint).Address, port )
+                IPEndPoint remote = client.Client.RemoteEndPoint as IPEndPoint;
+                string connectionID = Guid.NewGuid().ToString();
+
+                _MistoxServer.Connections[connectionID] = new TcpClientConnection() {
+                    Connection = new TCPConnection( client, _MistoxServer, connectionID ),
+                    RemoteAddress = remote.Address
                 };
 
                 Console.WriteLine( "New User Connected" );
-
-                onConnected?.Invoke( user, new EventArgs() );
-                user.slowClient.onDisconnected += onDisconnected;
-                user.slowClient.onReceived += onReceive;
-
-                Thread receiveThread = new Thread(async () => await user.slowClient.ReceiveThread(user) );
-                receiveThread.Start();
+                onConnected?.Invoke( _MistoxServer.Connections[connectionID], new EventArgs() );
             }
         }
 
         public void Dispose() {
-            Alive = false;
             Listener.Stop();
             Listener = null;
         }

MistoxServer/Server/TCPConnection.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Mistox.Server {
+    public class TCPConnection : IDisposable {
+        
+        TcpClient _client;
+        MistoxServer _instance;
+        string _connectionID;
+
+        public TCPConnection( TcpClient tcpClient, MistoxServer ServerInstance, string ConnectionID ) {
+            _client = tcpClient;
+            _instance = ServerInstance;
+            _connectionID = ConnectionID;
+            _client.NoDelay = true;
+
+            // Start the receive thread
+            Thread receiveThread = new Thread(async () => await ReceiveThread() );
+            receiveThread.Start();
+        }
+
+        public async Task ReceiveThread() {
+            while( _client.Connected && _instance.Connections[_connectionID].Connected ) {
+                try {
+                    _instance.Connections[_connectionID].LastHeartbeat = DateTime.UtcNow;
+                    byte[] StreamData = new byte[1024];
+                    int bytesRead = await _client.GetStream().ReadAsync(StreamData, 0, StreamData.Length);
+                    if( bytesRead > 0 ) {
+                        dynamic data = mSerialize.tReceive( StreamData.Sub( 0, bytesRead ) );
+                        if( data != null ) {
+                            _instance.onReceived?.Invoke( data, new EventArgs() );
+                        }
+                    }
+                } catch( Exception ) {
+                    Console.WriteLine( "User disconnected" );
+                    Dispose();
+                }
+            }
+        }
+
+        public async Task Send<T>( T packet ) {
+            byte[] byteData = DataPacket.Serialize( packet );
+            await _client.GetStream().WriteAsync( byteData, 0, byteData.Length );
+        }
+
+        public void Dispose() {
+            _instance.Connections[_connectionID].Connected = false;
+            _instance.onUserDisconnected?.Invoke( _instance.Connections[_connectionID], new EventArgs() );
+            _instance.Connections.TryRemove( _connectionID, out _ );
+        }
+    }
+}

MistoxServer/Server/TCPServer.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Net.Sockets;
-using System.Threading.Tasks;
-
-namespace MistoxServer.Server {
-    public class mTCPServer : IDisposable {
-        public TcpClient slowClient;
-
-        public event EventHandler onReceived;
-        public event EventHandler onDisconnected;
-
-        public mTCPServer( TcpClient client ) {
-            slowClient = client;
-            slowClient.Client.NoDelay = true;
-        }
-
-        bool Alive = true;
-        public async Task ReceiveThread( Connection Client ) {
-            bool connected = true;
-            while( Alive && connected ) {
-                try {
-                    byte[] StreamData = new byte[1024];
-                    int bytesRead = await slowClient.GetStream().ReadAsync(StreamData, 0, StreamData.Length);
-                    if( bytesRead > 0 ) {
-                        dynamic data = mSerialize.tReceive( StreamData.Sub( 0, bytesRead ) );
-                        if( data != null ) {
-                            onReceived?.Invoke( data, new EventArgs() );
-                        }
-                    }
-                } catch( Exception ) {
-                    Console.WriteLine( "User disconnected" );
-                    connected = false;
-                    onDisconnected?.Invoke( Client, new EventArgs() );
-                }
-            }
-        }
-
-        public async Task Send<T>( T packet ) {
-            byte[] byteData = DataPacket.Serialize( packet );
-            await slowClient.GetStream().WriteAsync( byteData, 0, byteData.Length );
-        }
-
-        public void Dispose() {
-            Alive = false;
-        }
-    }
-}

MistoxServer/Server/serverConnection.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Concurrent;
+using System.Net;
+
+namespace Mistox.Server {
+
+    public class MistoxServer {
+        public string ServerName { get; set; } = "";
+        public IPAddress BindAddress { get; set; } = IPAddress.Any;
+        public int Port { get; set; } = 9126;
+        public int MaxClients { get; set; } = 10;
+        public bool Alive { get; set; } = true;
+        public ServerListener serverListener;
+        public ConcurrentDictionary<string, TcpClientConnection> Connections { get; set; }
+
+        public EventHandler onUserConnected;
+        public EventHandler onReceived;
+        public EventHandler onUserDisconnected;
+    }
+
+    public class TcpClientConnection {
+        public string UserName { get; set; } = "";
+        public bool IsAuthenticated { get; set; } = false;
+        public DateTime LastHeartbeat { get; set; } = DateTime.UtcNow;
+        public bool Connected { get; set; } = true;
+        public IPAddress RemoteAddress { get; set; }
+        public TCPConnection Connection { get; set; }
+    }
+
+}