/// <summary> /// Method responsible for start the server. /// </summary> public static void StartServer() { _networkListenerType = NetworkListenerType.WSText; _server = new KingServer(); _server.OnMessageReceivedHandler = OnMessageReceived; new Thread(() => { _stopwatch = Stopwatch.StartNew(); while (true) { Thread.Sleep(1000 / _serverFrequency); if (_stopwatch.ElapsedMilliseconds > 1000 * 10) { Console.WriteLine(string.Format("Server in={0} ({1} KB/s) out={0} ({1} KB/s)", _messagesReceived, (_dataReceived * 1000 / (_stopwatch.ElapsedMilliseconds * 1024)))); _stopwatch.Stop(); _stopwatch = Stopwatch.StartNew(); _messagesReceived = 0; _dataReceived = 0; } } }).Start(); _server.Start(_networkListenerType); }
/// <summary> /// Creates a new instance of a <see cref="WebSocketNetworkListener"/>. /// </summary> /// <param name="port">The port of server.</param> /// <param name="listenerType">The listener type of client connection.</param> /// <param name="clientConnectedHandler">The client connected handler callback implementation.</param> /// <param name="messageReceivedHandler">The callback of message received handler implementation.</param> /// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param> /// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param> public WebSocketNetworkListener(NetworkListenerType listenerType, ushort port, ClientConnectedHandler clientConnectedHandler, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer) : base(port, clientConnectedHandler, messageReceivedHandler, clientDisconnectedHandler, maxMessageBuffer) { try { //var host = Dns.GetHostEntry(Dns.GetHostName()); //var hostIp = host.AddressList.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork).ToString(); _listenerType = listenerType; _httpListener = new HttpListener(); _httpListener.Prefixes.Add($"http://localhost:{port}/"); _httpListener.Prefixes.Add($"http://127.0.0.1:{port}/"); //_httpListener.Prefixes.Add($"http://{hostIp}:{port}/"); _httpListener.Start(); Console.WriteLine($"Starting the WebSocket network listener on port: {port}."); WaitForConnections(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// Method responsible to connect client in server. /// </summary> /// <param name="ip">The ip address from server.</param> /// <param name="port">The port number from server, the default value us 7171</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> /// <param name="maxMessageBuffer">The max length of message buffer, the default value is 4096.</param> /// <returns>The boolean value of client connection.</returns> public bool Connect(string ip, ushort port = 7171, NetworkListenerType listenerType = NetworkListenerType.TCP, ushort maxMessageBuffer = 4096) { try { if (listenerType == NetworkListenerType.TCP) { _networkListener = new TcpNetworkListener(OnMessageReceived, OnDisconnected); } else if (listenerType == NetworkListenerType.UDP) { _networkListener = new UdpNetworkListener(OnMessageReceived, OnDisconnected); } else if (listenerType == NetworkListenerType.WSBinary || listenerType == NetworkListenerType.WSText) { _networkListener = new WSNetworkListener(listenerType, OnMessageReceived, OnDisconnected); } _clientThread = new Thread(() => { _networkListener.StartClient(ip, port, maxMessageBuffer); }); _clientThread.IsBackground = true; _clientThread.Start(); Thread.Sleep(15); // Delay for socket connection. } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } return(HasConnected); }
/// <summary> /// Method responsible for start the async network listener. /// </summary> /// <param name="cancellationToken">The cancellation token for the task execution.</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> private async Task StartListenerAsync(CancellationToken cancellationToken, NetworkListenerType listenerType = NetworkListenerType.TCP) { try { if (listenerType == NetworkListenerType.TCP) { _networkListener = new TcpNetworkListener(_port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } else if (listenerType == NetworkListenerType.UDP) { _networkListener = new UdpNetworkListener(_port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } else if (listenerType == NetworkListenerType.WSBinary || listenerType == NetworkListenerType.WSText) { _networkListener = new WebSocketNetworkListener(listenerType, _port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } OnServerStartedHandler?.Invoke(); while (!cancellationToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); } } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
public static ServerManager GetInstance(NetworkListenerType type) { if (_instance == null) { _instance = new ServerManager(type); } return(_instance); }
public static NetworkListener CreateForType(NetworkListenerType listenerType, ushort port, ClientConnectedHandler clientConnectedHandler) { if (listenerType == NetworkListenerType.TCP) { return(new TcpNetworkListener(port, clientConnectedHandler)); } return(new UdpNetworkListener(port, clientConnectedHandler)); }
public static NetworkListener CreateForType(NetworkListenerType listenerType, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler) { if (listenerType == NetworkListenerType.TCP) { return(new TcpNetworkListener(messageReceivedHandler, clientDisconnectedHandler)); } return(new UdpNetworkListener(messageReceivedHandler, clientDisconnectedHandler)); }
public ServerManager(NetworkListenerType type) { _serverTread = new Thread(() => { KingServer = new KingServer(); KingServer.Start(type); }); _serverTread.Start(); }
/// <summary> /// Method responsible for start the server. /// </summary> /// <param name="listenerType">The listener type to creation of listener.</param> public void Start(NetworkListenerType listenerType = NetworkListenerType.TCP) { try { var cancellationTokenSource = new CancellationTokenSource(); var listeningTask = StartListenerAsync(cancellationTokenSource.Token, listenerType); listeningTask.Wait(cancellationTokenSource.Token); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// This method is responsible for main execution of console application. /// </summary> /// <param name="args">The string args received by parameters.</param> static void Main(string[] args) { try { _networkListenerType = NetworkListenerType.UDP; var server = new KingServer(); server.OnMessageReceivedHandler = OnMessageReceived; server.OnClientConnectedHandler = OnClientConnectedHandler; server.Start(_networkListenerType); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } }
/// <summary> /// Method responsible for start the async network listener. /// </summary> /// <param name="cancellationToken">The cancellation token for the task execution.</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> private async Task StartListenerAsync(CancellationToken cancellationToken, NetworkListenerType listenerType = NetworkListenerType.TCP) { try { _networkListener = NetworkListenerFactory.CreateForType(listenerType, _port, OnClientConnected); if (OnServerStartedHandler != null) { OnServerStartedHandler(); } while (!cancellationToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); } } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// This method is responsible for main execution of console application. /// </summary> /// <param name="args">The string args received by parameters.</param> static void Main(string[] args) { try { _networkListenerType = NetworkListenerType.UDP; var client = new KingClient(); client.MessageReceivedHandler = OnMessageReceived; client.Connect("127.0.0.1", 7171, _networkListenerType); if (client.HasConnected) { Console.WriteLine("client.HasConnected"); } new Thread(() => { Thread.Sleep(5000); using (var buffer = KingBufferWriter.Create()) { if (_networkListenerType != NetworkListenerType.WSText) { buffer.Write(MyPackets.PacketOne); } buffer.Write("Testinho1"); client.SendMessage(buffer); } }).Start(); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } }
/// <summary> /// Creates a new instance of a <see cref="WSClient"/>. /// </summary> /// <param name="id">The identifier number of connected client.</param> /// <param name="id">The identifier number of connected client.</param> /// <param name="listenerType">The listener type of client connection.</param> /// <param name="ws">The websocket connection.</param> /// <param name="listenerContext">The websocket http listener context.</param> /// <param name="messageReceivedHandler">The callback of message received handler implementation.</param> /// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param> /// <param name="maxMessageBuffer">The max length of message buffer.</param> public WSClient(ushort id, string remoteEndPoint, NetworkListenerType listenerType, WebSocket ws, HttpListenerContext listenerContext, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer) { try { IpAddress = remoteEndPoint; _webSocket = ws; _listenerContext = listenerContext; _listenerType = listenerType; _buff = new ArraySegment <byte>(new byte[maxMessageBuffer]); _messageReceivedHandler = messageReceivedHandler; _clientDisconnectedHandler = clientDisconnectedHandler; Id = id; WaitConnection(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// Method responsible for start the clients. /// </summary> /// <param name="ip">The ip address from the server.</param> /// <param name="clientConnections">The number of client connections.</param> public static void StartClients(string ip, int clientConnections) { _networkListenerType = NetworkListenerType.WSBinary; var kingBuffer = KingBufferWriter.Create(); //kingBuffer.Write((byte)0); kingBuffer.Write("Sometimes we just need a good networking library"); _stopwatch = Stopwatch.StartNew(); var clientFrequency = 14; var clients = new List <KingClient>(); for (int i = 0; i < clientConnections; ++i) { var client = new KingClient(); client.MessageReceivedHandler = OnMessageReceived; client.Connect(ip, 7171, _networkListenerType); clients.Add(client); Thread.Sleep(15); } Console.WriteLine("started all clients"); new Thread(() => { Thread.Sleep(10000); foreach (var client in clients) { //if (client.HasConnected) //{ // send 2 messages each time var bytes = Encoding.GetEncoding("UTF-8").GetBytes("Testinho"); kingBuffer.Reset(); kingBuffer.Write(bytes); client.SendMessage(kingBuffer); //client.SendMessage(kingBuffer); _messagesSent += 1; //} } }).Start(); //foreach (var client in clients) //{ // if (client.HasConnected) // { // // send 2 messages each time // client.SendMessage(kingBuffer); // //client.SendMessage(kingBuffer); // _messagesSent += 1; // } //} var timer = new System.Timers.Timer(1000.0 / clientFrequency); timer.Elapsed += (object sender, ElapsedEventArgs e) => { //foreach (var client in clients) //{ // if (client.HasConnected) // { // // send 2 messages each time // client.SendMessage(kingBuffer); // //client.SendMessage(kingBuffer); // _messagesSent += 1; // } //} //// report every 10 seconds //if (_stopwatch.ElapsedMilliseconds > 1000 * 10) //{ // long bandwithIn = _dataReceived * 1000 / (_stopwatch.ElapsedMilliseconds * 1024); // long bandwithOut = _messagesSent * _bufferLength * 1000 / (_stopwatch.ElapsedMilliseconds * 1024); // Console.WriteLine(string.Format("Client in={0} ({1} KB/s) out={2} ({3} KB/s) bufferL={4}", // _messagesReceived, // bandwithIn, // _messagesSent, // bandwithOut, // _bufferLength)); // _stopwatch.Stop(); // _stopwatch = Stopwatch.StartNew(); // _messagesSent = 0; // _dataReceived = 0; // _messagesReceived = 0; //} }; timer.AutoReset = true; timer.Enabled = true; Console.ReadLine(); timer.Stop(); timer.Dispose(); }
/// <summary> /// Creates a new instance of a <see cref="WSNetworkListener"/>. /// </summary> /// <param name="listenerType">The listener type of client connection.</param> /// <param name="messageReceivedHandler">The callback of message received handler implementation.</param> /// <param name="disconnectedHandler">The callback of client disconnected handler implementation.</param> public WSNetworkListener(NetworkListenerType listenerType, MessageReceivedHandler messageReceivedHandler, DisconnectedHandler disconnectedHandler) : base(messageReceivedHandler, disconnectedHandler) { _listenerType = listenerType; }
/// <summary> /// Method responsible to connect client in server. /// </summary> /// <param name="ip">The ip address from server.</param> /// <param name="port">The port number from server, the default value us 7171</param> /// <param name="maxMessageBuffer">The max length of message buffer, the default value is 4096.</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> public void Connect(string ip, ushort port = 7171, ushort maxMessageBuffer = 4096, NetworkListenerType listenerType = NetworkListenerType.TCP) { try { _clientThread = new Thread(() => { _networkListener = NetworkListenerFactory.CreateForType(listenerType, OnMessageReceived, OnClientDisconnected); _networkListener.StartClient(ip, port, maxMessageBuffer); }); _clientThread.IsBackground = true; _clientThread.Start(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }