/// <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}.");
}
}
