知识图谱>> NetCoreServer>> 返回
项目作者： chronoxor

项目描述 ：
Ultra fast and low latency asynchronous socket server & client C# .NET Core library with support TCP, SSL, UDP, HTTP, HTTPS, WebSocket protocols and 10K connections problem solution
高级语言： C#
项目地址: git://github.com/chronoxor/NetCoreServer.git
创建时间： 2019-01-16T22:41:53Z
项目社区：https://github.com/chronoxor/NetCoreServer
开源协议：MIT License
下载


NetCoreServer

Awesome .NET
License
Release
NuGet


Linux
MacOS
Windows (Visual Studio)

Ultra fast and low latency asynchronous socket server & client C# .NET Core
library with support TCP, SSL, UDP, Unix Domain Socket, HTTP, HTTPS, WebSocket protocols and 10K connections problem
solution.

Has integration with high-level message protocol based on Fast Binary Encoding

NetCoreServer documentation

NetCoreServer downloads

Contents

Features

Requirements

Optional:

How to build?

Setup repository

  1. git clone https://github.com/chronoxor/NetCoreServer.git
  2. cd NetCoreServer

Linux

  1. cd build
  2. ./unix.sh

MacOS

  1. cd build
  2. ./unix.sh

Windows (Visual Studio)

Open and build NetCoreServer.sln or run the build script:

  1. cd build
  2. vs.bat

The build script will create “release” directory with zip files:

  • NetCoreServer.zip - C# Server assembly
  • Benchmarks.zip - C# Server benchmarks
  • Examples.zip - C# Server examples

Examples

Example: TCP chat server

Here comes the example of the TCP chat server. It handles multiple TCP client
sessions and multicast received message from any session to all ones. Also it
is possible to send admin message directly from the server.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using NetCoreServer;
  7. namespace TcpChatServer
  8. {
  9.     class ChatSession : TcpSession
  10.     {
  11.         public ChatSession(TcpServer server) : base(server) {}
  13.         protected override void OnConnected()
  14.         {
  15.             Console.WriteLine($"Chat TCP session with Id {Id} connected!");
  17.             // Send invite message
  18.             string message = "Hello from TCP chat! Please send a message or '!' to disconnect the client!";
  19.             SendAsync(message);
  20.         }
  22.         protected override void OnDisconnected()
  23.         {
  24.             Console.WriteLine($"Chat TCP session with Id {Id} disconnected!");
  25.         }
  27.         protected override void OnReceived(byte[] buffer, long offset, long size)
  28.         {
  29.             string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
  30.             Console.WriteLine("Incoming: " + message);
  32.             // Multicast message to all connected sessions
  33.             Server.Multicast(message);
  35.             // If the buffer starts with '!' the disconnect the current session
  36.             if (message == "!")
  37.                 Disconnect();
  38.         }
  40.         protected override void OnError(SocketError error)
  41.         {
  42.             Console.WriteLine($"Chat TCP session caught an error with code {error}");
  43.         }
  44.     }
  46.     class ChatServer : TcpServer
  47.     {
  48.         public ChatServer(IPAddress address, int port) : base(address, port) {}
  50.         protected override TcpSession CreateSession() { return new ChatSession(this); }
  52.         protected override void OnError(SocketError error)
  53.         {
  54.             Console.WriteLine($"Chat TCP server caught an error with code {error}");
  55.         }
  56.     }
  58.     class Program
  59.     {
  60.         static void Main(string[] args)
  61.         {
  62.             // TCP server port
  63.             int port = 1111;
  64.             if (args.Length > 0)
  65.                 port = int.Parse(args[0]);
  67.             Console.WriteLine($"TCP server port: {port}");
  69.             Console.WriteLine();
  71.             // Create a new TCP chat server
  72.             var server = new ChatServer(IPAddress.Any, port);
  74.             // Start the server
  75.             Console.Write("Server starting...");
  76.             server.Start();
  77.             Console.WriteLine("Done!");
  79.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  81.             // Perform text input
  82.             for (;;)
  83.             {
  84.                 string line = Console.ReadLine();
  85.                 if (string.IsNullOrEmpty(line))
  86.                     break;
  88.                 // Restart the server
  89.                 if (line == "!")
  90.                 {
  91.                     Console.Write("Server restarting...");
  92.                     server.Restart();
  93.                     Console.WriteLine("Done!");
  94.                     continue;
  95.                 }
  97.                 // Multicast admin message to all sessions
  98.                 line = "(admin) " + line;
  99.                 server.Multicast(line);
  100.             }
  102.             // Stop the server
  103.             Console.Write("Server stopping...");
  104.             server.Stop();
  105.             Console.WriteLine("Done!");
  106.         }
  107.     }
  108. }

Example: TCP chat client

Here comes the example of the TCP chat client. It connects to the TCP chat
server and allows to send message to it and receive new messages.

  1. using System;
  2. using System.Net.Sockets;
  3. using System.Text;
  4. using System.Threading;
  5. using TcpClient = NetCoreServer.TcpClient;
  7. namespace TcpChatClient
  8. {
  9.     class ChatClient : TcpClient
  10.     {
  11.         public ChatClient(string address, int port) : base(address, port) {}
  13.         public void DisconnectAndStop()
  14.         {
  15.             _stop = true;
  16.             DisconnectAsync();
  17.             while (IsConnected)
  18.                 Thread.Yield();
  19.         }
  21.         protected override void OnConnected()
  22.         {
  23.             Console.WriteLine($"Chat TCP client connected a new session with Id {Id}");
  24.         }
  26.         protected override void OnDisconnected()
  27.         {
  28.             Console.WriteLine($"Chat TCP client disconnected a session with Id {Id}");
  30.             // Wait for a while...
  31.             Thread.Sleep(1000);
  33.             // Try to connect again
  34.             if (!_stop)
  35.                 ConnectAsync();
  36.         }
  38.         protected override void OnReceived(byte[] buffer, long offset, long size)
  39.         {
  40.             Console.WriteLine(Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  41.         }
  43.         protected override void OnError(SocketError error)
  44.         {
  45.             Console.WriteLine($"Chat TCP client caught an error with code {error}");
  46.         }
  48.         private bool _stop;
  49.     }
  51.     class Program
  52.     {
  53.         static void Main(string[] args)
  54.         {
  55.             // TCP server address
  56.             string address = "127.0.0.1";
  57.             if (args.Length > 0)
  58.                 address = args[0];
  60.             // TCP server port
  61.             int port = 1111;
  62.             if (args.Length > 1)
  63.                 port = int.Parse(args[1]);
  65.             Console.WriteLine($"TCP server address: {address}");
  66.             Console.WriteLine($"TCP server port: {port}");
  68.             Console.WriteLine();
  70.             // Create a new TCP chat client
  71.             var client = new ChatClient(address, port);
  73.             // Connect the client
  74.             Console.Write("Client connecting...");
  75.             client.ConnectAsync();
  76.             Console.WriteLine("Done!");
  78.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  80.             // Perform text input
  81.             for (;;)
  82.             {
  83.                 string line = Console.ReadLine();
  84.                 if (string.IsNullOrEmpty(line))
  85.                     break;
  87.                 // Disconnect the client
  88.                 if (line == "!")
  89.                 {
  90.                     Console.Write("Client disconnecting...");
  91.                     client.DisconnectAsync();
  92.                     Console.WriteLine("Done!");
  93.                     continue;
  94.                 }
  96.                 // Send the entered text to the chat server
  97.                 client.SendAsync(line);
  98.             }
  100.             // Disconnect the client
  101.             Console.Write("Client disconnecting...");
  102.             client.DisconnectAndStop();
  103.             Console.WriteLine("Done!");
  104.         }
  105.     }
  106. }

Example: SSL chat server

Here comes the example of the SSL chat server. It handles multiple SSL client
sessions and multicast received message from any session to all ones. Also it
is possible to send admin message directly from the server.

This example is very similar to the TCP one except the code that prepares SSL
context and handshake handler.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Security.Authentication;
  5. using System.Security.Cryptography.X509Certificates;
  6. using System.Text;
  7. using NetCoreServer;
  9. namespace SslChatServer
  10. {
  11.     class ChatSession : SslSession
  12.     {
  13.         public ChatSession(SslServer server) : base(server) {}
  15.         protected override void OnConnected()
  16.         {
  17.             Console.WriteLine($"Chat SSL session with Id {Id} connected!");
  18.         }
  20.         protected override void OnHandshaked()
  21.         {
  22.             Console.WriteLine($"Chat SSL session with Id {Id} handshaked!");
  24.             // Send invite message
  25.             string message = "Hello from SSL chat! Please send a message or '!' to disconnect the client!";
  26.             Send(message);
  27.         }
  29.         protected override void OnDisconnected()
  30.         {
  31.             Console.WriteLine($"Chat SSL session with Id {Id} disconnected!");
  32.         }
  34.         protected override void OnReceived(byte[] buffer, long offset, long size)
  35.         {
  36.             string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
  37.             Console.WriteLine("Incoming: " + message);
  39.             // Multicast message to all connected sessions
  40.             Server.Multicast(message);
  42.             // If the buffer starts with '!' the disconnect the current session
  43.             if (message == "!")
  44.                 Disconnect();
  45.         }
  47.         protected override void OnError(SocketError error)
  48.         {
  49.             Console.WriteLine($"Chat SSL session caught an error with code {error}");
  50.         }
  51.     }
  53.     class ChatServer : SslServer
  54.     {
  55.         public ChatServer(SslContext context, IPAddress address, int port) : base(context, address, port) {}
  57.         protected override SslSession CreateSession() { return new ChatSession(this); }
  59.         protected override void OnError(SocketError error)
  60.         {
  61.             Console.WriteLine($"Chat SSL server caught an error with code {error}");
  62.         }
  63.     }
  65.     class Program
  66.     {
  67.         static void Main(string[] args)
  68.         {
  69.             // SSL server port
  70.             int port = 2222;
  71.             if (args.Length > 0)
  72.                 port = int.Parse(args[0]);
  74.             Console.WriteLine($"SSL server port: {port}");
  76.             Console.WriteLine();
  78.             // Create and prepare a new SSL server context
  79.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("server.pfx", "qwerty"));
  81.             // Create a new SSL chat server
  82.             var server = new ChatServer(context, IPAddress.Any, port);
  84.             // Start the server
  85.             Console.Write("Server starting...");
  86.             server.Start();
  87.             Console.WriteLine("Done!");
  89.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  91.             // Perform text input
  92.             for (;;)
  93.             {
  94.                 string line = Console.ReadLine();
  95.                 if (string.IsNullOrEmpty(line))
  96.                     break;
  98.                 // Restart the server
  99.                 if (line == "!")
  100.                 {
  101.                     Console.Write("Server restarting...");
  102.                     server.Restart();
  103.                     Console.WriteLine("Done!");
  104.                     continue;
  105.                 }
  107.                 // Multicast admin message to all sessions
  108.                 line = "(admin) " + line;
  109.                 server.Multicast(line);
  110.             }
  112.             // Stop the server
  113.             Console.Write("Server stopping...");
  114.             server.Stop();
  115.             Console.WriteLine("Done!");
  116.         }
  117.     }
  118. }

Example: SSL chat client

Here comes the example of the SSL chat client. It connects to the SSL chat
server and allows to send message to it and receive new messages.

This example is very similar to the TCP one except the code that prepares SSL
context and handshake handler.

  1. using System;
  2. using System.Net.Sockets;
  3. using System.Security.Authentication;
  4. using System.Security.Cryptography.X509Certificates;
  5. using System.Text;
  6. using System.Threading;
  7. using NetCoreServer;
  9. namespace SslChatClient
  10. {
  11.     class ChatClient : SslClient
  12.     {
  13.         public ChatClient(SslContext context, string address, int port) : base(context, address, port) {}
  15.         public void DisconnectAndStop()
  16.         {
  17.             _stop = true;
  18.             DisconnectAsync();
  19.             while (IsConnected)
  20.                 Thread.Yield();
  21.         }
  23.         protected override void OnConnected()
  24.         {
  25.             Console.WriteLine($"Chat SSL client connected a new session with Id {Id}");
  26.         }
  28.         protected override void OnHandshaked()
  29.         {
  30.             Console.WriteLine($"Chat SSL client handshaked a new session with Id {Id}");
  31.         }
  33.         protected override void OnDisconnected()
  34.         {
  35.             Console.WriteLine($"Chat SSL client disconnected a session with Id {Id}");
  37.             // Wait for a while...
  38.             Thread.Sleep(1000);
  40.             // Try to connect again
  41.             if (!_stop)
  42.                 ConnectAsync();
  43.         }
  45.         protected override void OnReceived(byte[] buffer, long offset, long size)
  46.         {
  47.             Console.WriteLine(Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  48.         }
  50.         protected override void OnError(SocketError error)
  51.         {
  52.             Console.WriteLine($"Chat SSL client caught an error with code {error}");
  53.         }
  55.         private bool _stop;
  56.     }
  58.     class Program
  59.     {
  60.         static void Main(string[] args)
  61.         {
  62.             // SSL server address
  63.             string address = "127.0.0.1";
  64.             if (args.Length > 0)
  65.                 address = args[0];
  67.             // SSL server port
  68.             int port = 2222;
  69.             if (args.Length > 1)
  70.                 port = int.Parse(args[1]);
  72.             Console.WriteLine($"SSL server address: {address}");
  73.             Console.WriteLine($"SSL server port: {port}");
  75.             Console.WriteLine();
  77.             // Create and prepare a new SSL client context
  78.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("client.pfx", "qwerty"), (sender, certificate, chain, sslPolicyErrors) => true);
  80.             // Create a new SSL chat client
  81.             var client = new ChatClient(context, address, port);
  83.             // Connect the client
  84.             Console.Write("Client connecting...");
  85.             client.ConnectAsync();
  86.             Console.WriteLine("Done!");
  88.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  90.             // Perform text input
  91.             for (;;)
  92.             {
  93.                 string line = Console.ReadLine();
  94.                 if (string.IsNullOrEmpty(line))
  95.                     break;
  97.                 // Disconnect the client
  98.                 if (line == "!")
  99.                 {
  100.                     Console.Write("Client disconnecting...");
  101.                     client.DisconnectAsync();
  102.                     Console.WriteLine("Done!");
  103.                     continue;
  104.                 }
  106.                 // Send the entered text to the chat server
  107.                 client.SendAsync(line);
  108.             }
  110.             // Disconnect the client
  111.             Console.Write("Client disconnecting...");
  112.             client.DisconnectAndStop();
  113.             Console.WriteLine("Done!");
  114.         }
  115.     }
  116. }

Example: UDP echo server

Here comes the example of the UDP echo server. It receives a datagram mesage
from any UDP client and resend it back without any changes.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using NetCoreServer;
  7. namespace UdpEchoServer
  8. {
  9.     class EchoServer : UdpServer
  10.     {
  11.         public EchoServer(IPAddress address, int port) : base(address, port) {}
  13.         protected override void OnStarted()
  14.         {
  15.             // Start receive datagrams
  16.             ReceiveAsync();
  17.         }
  19.         protected override void OnReceived(EndPoint endpoint, byte[] buffer, long offset, long size)
  20.         {
  21.             Console.WriteLine("Incoming: " + Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  23.             // Echo the message back to the sender
  24.             SendAsync(endpoint, buffer, 0, size);
  25.         }
  27.         protected override void OnSent(EndPoint endpoint, long sent)
  28.         {
  29.             // Continue receive datagrams
  30.             ReceiveAsync();
  31.         }
  33.         protected override void OnError(SocketError error)
  34.         {
  35.             Console.WriteLine($"Echo UDP server caught an error with code {error}");
  36.         }
  37.     }
  39.     class Program
  40.     {
  41.         static void Main(string[] args)
  42.         {
  43.             // UDP server port
  44.             int port = 3333;
  45.             if (args.Length > 0)
  46.                 port = int.Parse(args[0]);
  48.             Console.WriteLine($"UDP server port: {port}");
  50.             Console.WriteLine();
  52.             // Create a new UDP echo server
  53.             var server = new EchoServer(IPAddress.Any, port);
  55.             // Start the server
  56.             Console.Write("Server starting...");
  57.             server.Start();
  58.             Console.WriteLine("Done!");
  60.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  62.             // Perform text input
  63.             for (;;)
  64.             {
  65.                 string line = Console.ReadLine();
  66.                 if (string.IsNullOrEmpty(line))
  67.                     break;
  69.                 // Restart the server
  70.                 if (line == "!")
  71.                 {
  72.                     Console.Write("Server restarting...");
  73.                     server.Restart();
  74.                     Console.WriteLine("Done!");
  75.                 }
  76.             }
  78.             // Stop the server
  79.             Console.Write("Server stopping...");
  80.             server.Stop();
  81.             Console.WriteLine("Done!");
  82.         }
  83.     }
  84. }

Example: UDP echo client

Here comes the example of the UDP echo client. It sends user datagram message
to UDP server and listen for response.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using System.Threading;
  6. using UdpClient = NetCoreServer.UdpClient;
  8. namespace UdpEchoClient
  9. {
  10.     class EchoClient : UdpClient
  11.     {
  12.         public EchoClient(string address, int port) : base(address, port) {}
  14.         public void DisconnectAndStop()
  15.         {
  16.             _stop = true;
  17.             Disconnect();
  18.             while (IsConnected)
  19.                 Thread.Yield();
  20.         }
  22.         protected override void OnConnected()
  23.         {
  24.             Console.WriteLine($"Echo UDP client connected a new session with Id {Id}");
  26.             // Start receive datagrams
  27.             ReceiveAsync();
  28.         }
  30.         protected override void OnDisconnected()
  31.         {
  32.             Console.WriteLine($"Echo UDP client disconnected a session with Id {Id}");
  34.             // Wait for a while...
  35.             Thread.Sleep(1000);
  37.             // Try to connect again
  38.             if (!_stop)
  39.                 Connect();
  40.         }
  42.         protected override void OnReceived(EndPoint endpoint, byte[] buffer, long offset, long size)
  43.         {
  44.             Console.WriteLine("Incoming: " + Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  46.             // Continue receive datagrams
  47.             ReceiveAsync();
  48.         }
  50.         protected override void OnError(SocketError error)
  51.         {
  52.             Console.WriteLine($"Echo UDP client caught an error with code {error}");
  53.         }
  55.         private bool _stop;
  56.     }
  58.     class Program
  59.     {
  60.         static void Main(string[] args)
  61.         {
  62.             // UDP server address
  63.             string address = "127.0.0.1";
  64.             if (args.Length > 0)
  65.                 address = args[0];
  67.             // UDP server port
  68.             int port = 3333;
  69.             if (args.Length > 1)
  70.                 port = int.Parse(args[1]);
  72.             Console.WriteLine($"UDP server address: {address}");
  73.             Console.WriteLine($"UDP server port: {port}");
  75.             Console.WriteLine();
  77.             // Create a new TCP chat client
  78.             var client = new EchoClient(address, port);
  80.             // Connect the client
  81.             Console.Write("Client connecting...");
  82.             client.Connect();
  83.             Console.WriteLine("Done!");
  85.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  87.             // Perform text input
  88.             for (;;)
  89.             {
  90.                 string line = Console.ReadLine();
  91.                 if (string.IsNullOrEmpty(line))
  92.                     break;
  94.                 // Disconnect the client
  95.                 if (line == "!")
  96.                 {
  97.                     Console.Write("Client disconnecting...");
  98.                     client.Disconnect();
  99.                     Console.WriteLine("Done!");
  100.                     continue;
  101.                 }
  103.                 // Send the entered text to the chat server
  104.                 client.Send(line);
  105.             }
  107.             // Disconnect the client
  108.             Console.Write("Client disconnecting...");
  109.             client.DisconnectAndStop();
  110.             Console.WriteLine("Done!");
  111.         }
  112.     }
  113. }

Example: UDP multicast server

Here comes the example of the UDP multicast server. It use multicast IP address
to multicast datagram messages to all client that joined corresponding UDP
multicast group.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using NetCoreServer;
  6. namespace UdpMulticastServer
  7. {
  8.     class MulticastServer : UdpServer
  9.     {
  10.         public MulticastServer(IPAddress address, int port) : base(address, port) {}
  12.         protected override void OnError(SocketError error)
  13.         {
  14.             Console.WriteLine($"Multicast UDP server caught an error with code {error}");
  15.         }
  16.     }
  18.     class Program
  19.     {
  20.         static void Main(string[] args)
  21.         {
  22.             // UDP multicast address
  23.             string multicastAddress = "239.255.0.1";
  24.             if (args.Length > 0)
  25.                 multicastAddress = args[0];
  27.             // UDP multicast port
  28.             int multicastPort = 3334;
  29.             if (args.Length > 1)
  30.                 multicastPort = int.Parse(args[1]);
  32.             Console.WriteLine($"UDP multicast address: {multicastAddress}");
  33.             Console.WriteLine($"UDP multicast port: {multicastPort}");
  35.             Console.WriteLine();
  37.             // Create a new UDP multicast server
  38.             var server = new MulticastServer(IPAddress.Any, 0);
  40.             // Start the multicast server
  41.             Console.Write("Server starting...");
  42.             server.Start(multicastAddress, multicastPort);
  43.             Console.WriteLine("Done!");
  45.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  47.             // Perform text input
  48.             for (;;)
  49.             {
  50.                 string line = Console.ReadLine();
  51.                 if (string.IsNullOrEmpty(line))
  52.                     break;
  54.                 // Restart the server
  55.                 if (line == "!")
  56.                 {
  57.                     Console.Write("Server restarting...");
  58.                     server.Restart();
  59.                     Console.WriteLine("Done!");
  60.                     continue;
  61.                 }
  63.                 // Multicast admin message to all sessions
  64.                 line = "(admin) " + line;
  65.                 server.Multicast(line);
  66.             }
  68.             // Stop the server
  69.             Console.Write("Server stopping...");
  70.             server.Stop();
  71.             Console.WriteLine("Done!");
  72.         }
  73.     }
  74. }

Example: UDP multicast client

Here comes the example of the UDP multicast client. It use multicast IP address
and joins UDP multicast group in order to receive multicasted datagram messages
from UDP server.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using System.Threading;
  6. using UdpClient = NetCoreServer.UdpClient;
  8. namespace UdpMulticastClient
  9. {
  10.     class MulticastClient : UdpClient
  11.     {
  12.         public string Multicast;
  14.         public MulticastClient(string address, int port) : base(address, port) {}
  16.         public void DisconnectAndStop()
  17.         {
  18.             _stop = true;
  19.             Disconnect();
  20.             while (IsConnected)
  21.                 Thread.Yield();
  22.         }
  24.         protected override void OnConnected()
  25.         {
  26.             Console.WriteLine($"Multicast UDP client connected a new session with Id {Id}");
  28.             // Join UDP multicast group
  29.             JoinMulticastGroup(Multicast);
  31.             // Start receive datagrams
  32.             ReceiveAsync();
  33.         }
  35.         protected override void OnDisconnected()
  36.         {
  37.             Console.WriteLine($"Multicast UDP client disconnected a session with Id {Id}");
  39.             // Wait for a while...
  40.             Thread.Sleep(1000);
  42.             // Try to connect again
  43.             if (!_stop)
  44.                 Connect();
  45.         }
  47.         protected override void OnReceived(EndPoint endpoint, byte[] buffer, long offset, long size)
  48.         {
  49.             Console.WriteLine("Incoming: " + Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  51.             // Continue receive datagrams
  52.             ReceiveAsync();
  53.         }
  55.         protected override void OnError(SocketError error)
  56.         {
  57.             Console.WriteLine($"Multicast UDP client caught an error with code {error}");
  58.         }
  60.         private bool _stop;
  61.     }
  63.     class Program
  64.     {
  65.         static void Main(string[] args)
  66.         {
  67.             // UDP listen address
  68.             string listenAddress = "0.0.0.0";
  69.             if (args.Length > 0)
  70.                 listenAddress = args[0];
  72.             // UDP multicast address
  73.             string multicastAddress = "239.255.0.1";
  74.             if (args.Length > 1)
  75.                 multicastAddress = args[1];
  77.             // UDP multicast port
  78.             int multicastPort = 3334;
  79.             if (args.Length > 2)
  80.                 multicastPort = int.Parse(args[2]);
  82.             Console.WriteLine($"UDP listen address: {listenAddress}");
  83.             Console.WriteLine($"UDP multicast address: {multicastAddress}");
  84.             Console.WriteLine($"UDP multicast port: {multicastPort}");
  86.             Console.WriteLine();
  88.             // Create a new TCP chat client
  89.             var client = new MulticastClient(listenAddress, multicastPort);
  90.             client.SetupMulticast(true);
  91.             client.Multicast = multicastAddress;
  93.             // Connect the client
  94.             Console.Write("Client connecting...");
  95.             client.Connect();
  96.             Console.WriteLine("Done!");
  98.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  100.             // Perform text input
  101.             for (;;)
  102.             {
  103.                 string line = Console.ReadLine();
  104.                 if (string.IsNullOrEmpty(line))
  105.                     break;
  107.                 // Disconnect the client
  108.                 if (line == "!")
  109.                 {
  110.                     Console.Write("Client disconnecting...");
  111.                     client.Disconnect();
  112.                     Console.WriteLine("Done!");
  113.                     continue;
  114.                 }
  115.             }
  117.             // Disconnect the client
  118.             Console.Write("Client disconnecting...");
  119.             client.DisconnectAndStop();
  120.             Console.WriteLine("Done!");
  121.         }
  122.     }
  123. }

Example: Unix Domain Socket chat server

Here comes the example of the Unix Domain Socket chat server. It handles
multiple Unix Domain Socket client sessions and multicast received message from
any session to all ones. Also it is possible to send admin message directly
from the server.

  1. using System;
  2. using System.IO;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using NetCoreServer;
  7. namespace UdsChatServer
  8. {
  9.     class ChatSession : UdsSession
  10.     {
  11.         public ChatSession(UdsServer server) : base(server) {}
  13.         protected override void OnConnected()
  14.         {
  15.             Console.WriteLine($"Chat Unix Domain Socket session with Id {Id} connected!");
  17.             // Send invite message
  18.             string message = "Hello from Unix Domain Socket chat! Please send a message or '!' to disconnect the client!";
  19.             SendAsync(message);
  20.         }
  22.         protected override void OnDisconnected()
  23.         {
  24.             Console.WriteLine($"Chat Unix Domain Socket session with Id {Id} disconnected!");
  25.         }
  27.         protected override void OnReceived(byte[] buffer, long offset, long size)
  28.         {
  29.             string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
  30.             Console.WriteLine("Incoming: " + message);
  32.             // Multicast message to all connected sessions
  33.             Server.Multicast(message);
  35.             // If the buffer starts with '!' the disconnect the current session
  36.             if (message == "!")
  37.                 Disconnect();
  38.         }
  40.         protected override void OnError(SocketError error)
  41.         {
  42.             Console.WriteLine($"Chat Unix Domain Socket session caught an error with code {error}");
  43.         }
  44.     }
  46.     class ChatServer : UdsServer
  47.     {
  48.         public ChatServer(string path) : base(path) {}
  50.         protected override UdsSession CreateSession() { return new ChatSession(this); }
  52.         protected override void OnError(SocketError error)
  53.         {
  54.             Console.WriteLine($"Chat Unix Domain Socket server caught an error with code {error}");
  55.         }
  56.     }
  58.     class Program
  59.     {
  60.         static void Main(string[] args)
  61.         {
  62.             // Unix Domain Socket path
  63.             string path = Path.Combine(Path.GetTempPath(), "chat.sock");
  64.             if (args.Length > 0)
  65.                 path = args[0];
  67.             Console.WriteLine($"Unix Domain Socket server path: {path}");
  69.             Console.WriteLine();
  71.             // Create a new Unix Domain Socket chat server
  72.             var server = new ChatServer(path);
  74.             // Start the server
  75.             Console.Write("Server starting...");
  76.             server.Start();
  77.             Console.WriteLine("Done!");
  79.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  81.             // Perform text input
  82.             for (;;)
  83.             {
  84.                 string line = Console.ReadLine();
  85.                 if (string.IsNullOrEmpty(line))
  86.                     break;
  88.                 // Restart the server
  89.                 if (line == "!")
  90.                 {
  91.                     Console.Write("Server restarting...");
  92.                     server.Restart();
  93.                     Console.WriteLine("Done!");
  94.                     continue;
  95.                 }
  97.                 // Multicast admin message to all sessions
  98.                 line = "(admin) " + line;
  99.                 server.Multicast(line);
  100.             }
  102.             // Stop the server
  103.             Console.Write("Server stopping...");
  104.             server.Stop();
  105.             Console.WriteLine("Done!");
  106.         }
  107.     }
  108. }

Example: Unix Domain Socket chat client

Here comes the example of the Unix Domain Socket chat client. It connects to
the Unix Domain Socket chat server and allows to send message to it and receive
new messages.

  1. using System;
  2. using System.IO;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using System.Threading;
  6. using UdsClient = NetCoreServer.UdsClient;
  8. namespace UdsChatClient
  9. {
  10.     class ChatClient : UdsClient
  11.     {
  12.         public ChatClient(string path) : base(path) {}
  14.         public void DisconnectAndStop()
  15.         {
  16.             _stop = true;
  17.             DisconnectAsync();
  18.             while (IsConnected)
  19.                 Thread.Yield();
  20.         }
  22.         protected override void OnConnected()
  23.         {
  24.             Console.WriteLine($"Chat Unix Domain Socket client connected a new session with Id {Id}");
  25.         }
  27.         protected override void OnDisconnected()
  28.         {
  29.             Console.WriteLine($"Chat Unix Domain Socket client disconnected a session with Id {Id}");
  31.             // Wait for a while...
  32.             Thread.Sleep(1000);
  34.             // Try to connect again
  35.             if (!_stop)
  36.                 ConnectAsync();
  37.         }
  39.         protected override void OnReceived(byte[] buffer, long offset, long size)
  40.         {
  41.             Console.WriteLine(Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
  42.         }
  44.         protected override void OnError(SocketError error)
  45.         {
  46.             Console.WriteLine($"Chat Unix Domain Socket client caught an error with code {error}");
  47.         }
  49.         private bool _stop;
  50.     }
  52.     class Program
  53.     {
  54.         static void Main(string[] args)
  55.         {
  56.             // Unix Domain Socket path
  57.             string path = Path.Combine(Path.GetTempPath(), "chat.sock");
  58.             if (args.Length > 0)
  59.                 path = args[0];
  61.             Console.WriteLine($"Unix Domain Socket server path: {path}");
  63.             Console.WriteLine();
  65.             // Create a new Unix Domain Socket chat client
  66.             var client = new ChatClient(path);
  68.             // Connect the client
  69.             Console.Write("Client connecting...");
  70.             client.ConnectAsync();
  71.             Console.WriteLine("Done!");
  73.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  75.             // Perform text input
  76.             for (;;)
  77.             {
  78.                 string line = Console.ReadLine();
  79.                 if (string.IsNullOrEmpty(line))
  80.                     break;
  82.                 // Disconnect the client
  83.                 if (line == "!")
  84.                 {
  85.                     Console.Write("Client disconnecting...");
  86.                     client.DisconnectAsync();
  87.                     Console.WriteLine("Done!");
  88.                     continue;
  89.                 }
  91.                 // Send the entered text to the chat server
  92.                 client.SendAsync(line);
  93.             }
  95.             // Disconnect the client
  96.             Console.Write("Client disconnecting...");
  97.             client.DisconnectAndStop();
  98.             Console.WriteLine("Done!");
  99.         }
  100.     }
  101. }

Example: Simple protocol

Simple protocol is defined in simple.fbe file:

  1. /*
  2.    Simple Fast Binary Encoding protocol for CppServer
  3.    https://github.com/chronoxor/FastBinaryEncoding
  5.    Generate protocol command: fbec --csharp --proto --input=simple.fbe --output=.
  6. */
  8. // Domain declaration
  9. domain com.chronoxor
  11. // Package declaration
  12. package simple
  14. // Protocol version
  15. version 1.0
  17. // Simple request message
  18. [request]
  19. [response(SimpleResponse)]
  20. [reject(SimpleReject)]
  21. message SimpleRequest
  22. {
  23.     // Request Id
  24.     uuid [id] = uuid1;
  25.     // Request message
  26.     string Message;
  27. }
  29. // Simple response
  30. message SimpleResponse
  31. {
  32.     // Response Id
  33.     uuid [id] = uuid1;
  34.     // Calculated message length
  35.     uint32 Length;
  36.     // Calculated message hash
  37.     uint32 Hash;
  38. }
  40. // Simple reject
  41. message SimpleReject
  42. {
  43.     // Reject Id
  44.     uuid [id] = uuid1;
  45.     // Error message
  46.     string Error;
  47. }
  49. // Simple notification
  50. message SimpleNotify
  51. {
  52.     // Server notification
  53.     string Notification;
  54. }
  56. // Disconnect request message
  57. [request]
  58. message DisconnectRequest
  59. {
  60.     // Request Id
  61.     uuid [id] = uuid1;
  62. }

Example: Simple protocol server

Here comes the example of the simple protocol server. It process client
requests, answer with corresponding responses and send server notifications
back to clients.

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using NetCoreServer;
  6. using com.chronoxor.simple;
  7. using com.chronoxor.simple.FBE;
  9. namespace ProtoServer
  10. {
  11.     public class SimpleProtoSessionSender : Sender, ISenderListener
  12.     {
  13.         public SimpleProtoSession Session { get; }
  15.         public SimpleProtoSessionSender(SimpleProtoSession session) { Session = session; }
  17.         public long OnSend(byte[] buffer, long offset, long size)
  18.         {
  19.             return Session.SendAsync(buffer, offset, size) ? size : 0;
  20.         }
  21.     }
  23.     public class SimpleProtoSessionReceiver : Receiver, IReceiverListener
  24.     {
  25.         public SimpleProtoSession Session { get; }
  27.         public SimpleProtoSessionReceiver(SimpleProtoSession session) { Session = session; }
  29.         public void OnReceive(DisconnectRequest request) { Session.OnReceive(request); }
  30.         public void OnReceive(SimpleRequest request) { Session.OnReceive(request); }
  31.     }
  33.     public class SimpleProtoSession : TcpSession
  34.     {
  35.         public SimpleProtoSessionSender Sender { get; }
  36.         public SimpleProtoSessionReceiver Receiver { get; }
  38.         public SimpleProtoSession(TcpServer server) : base(server)
  39.         {
  40.             Sender = new SimpleProtoSessionSender(this);
  41.             Receiver = new SimpleProtoSessionReceiver(this);
  42.         }
  44.         protected override void OnConnected()
  45.         {
  46.             Console.WriteLine($"TCP protocol session with Id '{Id}' connected to remote address '{(Socket.RemoteEndPoint as IPEndPoint)?.Address}' and port {(Socket.RemoteEndPoint as IPEndPoint)?.Port}");
  48.             // Send invite notification
  49.             SimpleNotify notify = SimpleNotify.Default;
  50.             notify.Notification = "Hello from Simple protocol server! Please send a message or '!' to disconnect the client!";
  51.             Sender.Send(notify);
  52.         }
  54.         protected override void OnDisconnected()
  55.         {
  56.             Console.WriteLine($"TCP protocol session with Id '{Id}' disconnected");
  57.         }
  59.         protected override void OnReceived(byte[] buffer, long offset, long size)
  60.         {
  61.             Receiver.Receive(buffer, offset, size);
  62.         }
  64.         protected override void OnError(SocketError error)
  65.         {
  66.             Console.WriteLine($"TCP protocol session with Id '{Id}' caught a socket error: {error}");
  67.         }
  69.         // Protocol handlers
  70.         public void OnReceive(DisconnectRequest request) { Disconnect(); }
  71.         public void OnReceive(SimpleRequest request)
  72.         {
  73.             Console.WriteLine($"Received: {request}");
  75.             // Validate request
  76.             if (string.IsNullOrEmpty(request.Message))
  77.             {
  78.                 // Send reject
  79.                 SimpleReject reject = SimpleReject.Default;
  80.                 reject.id = request.id;
  81.                 reject.Error = "Request message is empty!";
  82.                 Sender.Send(reject);
  83.                 return;
  84.             }
  86.             // Send response
  87.             SimpleResponse response = SimpleResponse.Default;
  88.             response.id = request.id;
  89.             response.Hash = (uint)request.Message.GetHashCode();
  90.             response.Length = (uint)request.Message.Length;
  91.             Sender.Send(response);
  92.         }
  93.     }
  95.     public class SimpleProtoSender : Sender, ISenderListener
  96.     {
  97.         public SimpleProtoServer Server { get; }
  99.         public SimpleProtoSender(SimpleProtoServer server) { Server = server; }
  101.         public long OnSend(byte[] buffer, long offset, long size)
  102.         {
  103.             Server.Multicast(buffer, offset, size);
  104.             return size;
  105.         }
  106.     }
  108.     public class SimpleProtoServer : TcpServer
  109.     {
  110.         public SimpleProtoSender Sender { get; }
  112.         public SimpleProtoServer(IPAddress address, int port) : base(address, port)
  113.         {
  114.             Sender = new SimpleProtoSender(this);
  115.         }
  117.         protected override TcpSession CreateSession() { return new SimpleProtoSession(this); }
  119.         protected override void OnStarted()
  120.         {
  121.             Console.WriteLine($"Simple protocol server with Id '{Id}' started!");
  122.         }
  124.         protected override void OnStopped()
  125.         {
  126.             Console.WriteLine($"Simple protocol server with Id '{Id}' stopped!");
  127.         }
  129.         protected override void OnError(SocketError error)
  130.         {
  131.             Console.WriteLine($"Simple protocol server with Id '{Id}' caught an error: {error}");
  132.         }
  133.     }
  135.     class Program
  136.     {
  137.         static void Main(string[] args)
  138.         {
  139.             // Simple protocol server port
  140.             int port = 4444;
  141.             if (args.Length > 0)
  142.                 port = int.Parse(args[0]);
  144.             Console.WriteLine($"Simple protocol server port: {port}");
  146.             Console.WriteLine();
  148.             // Create a new simple protocol server
  149.             var server = new SimpleProtoServer(IPAddress.Any, port);
  151.             // Start the server
  152.             Console.Write("Server starting...");
  153.             server.Start();
  154.             Console.WriteLine("Done!");
  156.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  158.             // Perform text input
  159.             for (;;)
  160.             {
  161.                 string line = Console.ReadLine();
  162.                 if (string.IsNullOrEmpty(line))
  163.                     break;
  165.                 // Restart the server
  166.                 if (line == "!")
  167.                 {
  168.                     Console.Write("Server restarting...");
  169.                     server.Restart();
  170.                     Console.WriteLine("Done!");
  171.                     continue;
  172.                 }
  174.                 // Multicast admin notification to all sessions
  175.                 SimpleNotify notify = SimpleNotify.Default;
  176.                 notify.Notification = "(admin) " + line;
  177.                 server.Sender.Send(notify);
  178.             }
  180.             // Stop the server
  181.             Console.Write("Server stopping...");
  182.             server.Stop();
  183.             Console.WriteLine("Done!");
  184.         }
  185.     }
  186. }

Example: Simple protocol client

Here comes the example of the simple protocol client. It connects to the
simple protocol server and allows to send requests to it and receive
corresponding responses.

  1. using System;
  2. using System.Net.Sockets;
  3. using System.Threading;
  4. using TcpClient = NetCoreServer.TcpClient;
  6. using com.chronoxor.simple;
  7. using com.chronoxor.simple.FBE;
  9. namespace ProtoClient
  10. {
  11.     public class TcpProtoClient : TcpClient
  12.     {
  13.         public TcpProtoClient(string address, int port) : base(address, port) {}
  15.         public bool ConnectAndStart()
  16.         {
  17.             Console.WriteLine($"TCP protocol client starting a new session with Id '{Id}'...");
  19.             StartReconnectTimer();
  20.             return ConnectAsync();
  21.         }
  23.         public bool DisconnectAndStop()
  24.         {
  25.             Console.WriteLine($"TCP protocol client stopping the session with Id '{Id}'...");
  27.             StopReconnectTimer();
  28.             DisconnectAsync();
  29.             return true;
  30.         }
  32.         public override bool Reconnect()
  33.         {
  34.             return ReconnectAsync();
  35.         }
  37.         private Timer _reconnectTimer;
  39.         public void StartReconnectTimer()
  40.         {
  41.             // Start the reconnect timer
  42.             _reconnectTimer = new Timer(state =>
  43.             {
  44.                 Console.WriteLine($"TCP reconnect timer connecting the client session with Id '{Id}'...");
  45.                 ConnectAsync();
  46.             }, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
  47.         }
  49.         public void StopReconnectTimer()
  50.         {
  51.             // Stop the reconnect timer
  52.             _reconnectTimer?.Dispose();
  53.             _reconnectTimer = null;
  54.         }
  56.         public delegate void ConnectedHandler();
  57.         public event ConnectedHandler Connected = () => {};
  59.         protected override void OnConnected()
  60.         {
  61.             Console.WriteLine($"TCP protocol client connected a new session with Id '{Id}' to remote address '{Address}' and port {Port}");
  63.             Connected?.Invoke();
  64.         }
  66.         public delegate void DisconnectedHandler();
  67.         public event DisconnectedHandler Disconnected = () => {};
  69.         protected override void OnDisconnected()
  70.         {
  71.             Console.WriteLine($"TCP protocol client disconnected the session with Id '{Id}'");
  73.             // Setup and asynchronously wait for the reconnect timer
  74.             _reconnectTimer?.Change(TimeSpan.FromSeconds(1), Timeout.InfiniteTimeSpan);
  76.             Disconnected?.Invoke();
  77.         }
  79.         public delegate void ReceivedHandler(byte[] buffer, long offset, long size);
  80.         public event ReceivedHandler Received = (buffer, offset, size) => {};
  82.         protected override void OnReceived(byte[] buffer, long offset, long size)
  83.         {
  84.             Received?.Invoke(buffer, offset, size);
  85.         }
  87.         protected override void OnError(SocketError error)
  88.         {
  89.             Console.WriteLine($"TCP protocol client caught a socket error: {error}");
  90.         }
  92.         #region IDisposable implementation
  94.         // Disposed flag.
  95.         private bool _disposed;
  97.         protected override void Dispose(bool disposingManagedResources)
  98.         {
  99.             if (!_disposed)
  100.             {
  101.                 if (disposingManagedResources)
  102.                 {
  103.                     // Dispose managed resources here...
  104.                     StopReconnectTimer();
  105.                 }
  107.                 // Dispose unmanaged resources here...
  109.                 // Set large fields to null here...
  111.                 // Mark as disposed.
  112.                 _disposed = true;
  113.             }
  115.             // Call Dispose in the base class.
  116.             base.Dispose(disposingManagedResources);
  117.         }
  119.         // The derived class does not have a Finalize method
  120.         // or a Dispose method without parameters because it inherits
  121.         // them from the base class.
  123.         #endregion
  124.     }
  126.     public class SimpleProtoClient : Client, ISenderListener, IReceiverListener, IDisposable
  127.     {
  128.         private readonly TcpProtoClient _tcpProtoClient;
  130.         public Guid Id => _tcpProtoClient.Id;
  131.         public bool IsConnected => _tcpProtoClient.IsConnected;
  133.         public SimpleProtoClient(string address, int port)
  134.         {
  135.             _tcpProtoClient = new TcpProtoClient(address, port);
  136.             _tcpProtoClient.Connected += OnConnected;
  137.             _tcpProtoClient.Disconnected += OnDisconnected;
  138.             _tcpProtoClient.Received += OnReceived;
  139.             ReceivedResponse_DisconnectRequest += HandleDisconnectRequest;
  140.             ReceivedResponse_SimpleResponse += HandleSimpleResponse;
  141.             ReceivedResponse_SimpleReject += HandleSimpleReject;
  142.             ReceivedResponse_SimpleNotify += HandleSimpleNotify;
  143.         }
  145.         private void DisposeClient()
  146.         {
  147.             _tcpProtoClient.Connected -= OnConnected;
  148.             _tcpProtoClient.Connected -= OnDisconnected;
  149.             _tcpProtoClient.Received -= OnReceived;
  150.             ReceivedResponse_DisconnectRequest -= HandleDisconnectRequest;
  151.             ReceivedResponse_SimpleResponse -= HandleSimpleResponse;
  152.             ReceivedResponse_SimpleReject -= HandleSimpleReject;
  153.             ReceivedResponse_SimpleNotify -= HandleSimpleNotify;
  154.             _tcpProtoClient.Dispose();
  155.         }
  157.         public bool ConnectAndStart() { return _tcpProtoClient.ConnectAndStart(); }
  158.         public bool DisconnectAndStop() { return _tcpProtoClient.DisconnectAndStop(); }
  159.         public bool Reconnect() { return _tcpProtoClient.Reconnect(); }
  161.         private bool _watchdog;
  162.         private Thread _watchdogThread;
  164.         public bool StartWatchdog()
  165.         {
  166.             if (_watchdog)
  167.                 return false;
  169.             Console.WriteLine("Watchdog thread starting...");
  171.             // Start the watchdog thread
  172.             _watchdog = true;
  173.             _watchdogThread = new Thread(WatchdogThread);
  175.             Console.WriteLine("Watchdog thread started!");
  177.             return true;
  178.         }
  180.         public bool StopWatchdog()
  181.         {
  182.             if (!_watchdog)
  183.                 return false;
  185.             Console.WriteLine("Watchdog thread stopping...");
  187.             // Stop the watchdog thread
  188.             _watchdog = false;
  189.             _watchdogThread.Join();
  191.             Console.WriteLine("Watchdog thread stopped!");
  193.             return true;
  194.         }
  196.         public static void WatchdogThread(object obj)
  197.         {
  198.             var instance = obj as SimpleProtoClient;
  199.             if (instance == null)
  200.                 return;
  202.             try
  203.             {
  204.                 // Watchdog loop...
  205.                 while (instance._watchdog)
  206.                 {
  207.                     var utc = DateTime.UtcNow;
  209.                     // Watchdog the client
  210.                     instance.Watchdog(utc);
  212.                     // Sleep for a while...
  213.                     Thread.Sleep(1000);
  214.                 }
  215.             }
  216.             catch (Exception e)
  217.             {
  218.                 Console.WriteLine($"Config client watchdog thread terminated: {e}");
  219.             }
  220.         }
  222.         #region Connection handlers
  224.         public delegate void ConnectedHandler();
  225.         public event ConnectedHandler Connected = () => {};
  227.         private void OnConnected()
  228.         {
  229.             // Reset FBE protocol buffers
  230.             Reset();
  232.             Connected?.Invoke();
  233.         }
  235.         public delegate void DisconnectedHandler();
  236.         public event DisconnectedHandler Disconnected = () => {};
  238.         private void OnDisconnected()
  239.         {
  240.             Disconnected?.Invoke();
  241.         }
  243.         public long OnSend(byte[] buffer, long offset, long size)
  244.         {
  245.             return _tcpProtoClient.SendAsync(buffer, offset, size) ? size : 0;
  246.         }
  248.         public void OnReceived(byte[] buffer, long offset, long size)
  249.         {
  250.             Receive(buffer, offset, size);
  251.         }
  253.         #endregion
  255.         #region Protocol handlers
  257.         private void HandleDisconnectRequest(DisconnectRequest request) { Console.WriteLine($"Received: {request}"); _tcpProtoClient.DisconnectAsync(); }
  258.         private void HandleSimpleResponse(SimpleResponse response) { Console.WriteLine($"Received: {response}"); }
  259.         private void HandleSimpleReject(SimpleReject reject) { Console.WriteLine($"Received: {reject}"); }
  260.         private void HandleSimpleNotify(SimpleNotify notify) { Console.WriteLine($"Received: {notify}"); }
  262.         #endregion
  264.         #region IDisposable implementation
  266.         // Disposed flag.
  267.         private bool _disposed;
  269.         // Implement IDisposable.
  270.         public void Dispose()
  271.         {
  272.             Dispose(true);
  273.             GC.SuppressFinalize(this);
  274.         }
  276.         protected virtual void Dispose(bool disposingManagedResources)
  277.         {
  278.             // The idea here is that Dispose(Boolean) knows whether it is
  279.             // being called to do explicit cleanup (the Boolean is true)
  280.             // versus being called due to a garbage collection (the Boolean
  281.             // is false). This distinction is useful because, when being
  282.             // disposed explicitly, the Dispose(Boolean) method can safely
  283.             // execute code using reference type fields that refer to other
  284.             // objects knowing for sure that these other objects have not been
  285.             // finalized or disposed of yet. When the Boolean is false,
  286.             // the Dispose(Boolean) method should not execute code that
  287.             // refer to reference type fields because those objects may
  288.             // have already been finalized."
  290.             if (!_disposed)
  291.             {
  292.                 if (disposingManagedResources)
  293.                 {
  294.                     // Dispose managed resources here...
  295.                     DisposeClient();
  296.                 }
  298.                 // Dispose unmanaged resources here...
  300.                 // Set large fields to null here...
  302.                 // Mark as disposed.
  303.                 _disposed = true;
  304.             }
  305.         }
  307.         #endregion
  308.     }
  310.     class Program
  311.     {
  312.         static void Main(string[] args)
  313.         {
  314.             // Simple protocol server address
  315.             string address = "127.0.0.1";
  316.             if (args.Length > 0)
  317.                 address = args[0];
  319.             // Simple protocol server port
  320.             int port = 4444;
  321.             if (args.Length > 1)
  322.                 port = int.Parse(args[1]);
  324.             Console.WriteLine($"Simple protocol server address: {address}");
  325.             Console.WriteLine($"Simple protocol server port: {port}");
  327.             Console.WriteLine();
  329.             // Create a new simple protocol chat client
  330.             var client = new SimpleProtoClient(address, port);
  332.             // Connect the client
  333.             Console.Write("Client connecting...");
  334.             client.ConnectAndStart();
  335.             Console.WriteLine("Done!");
  337.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  339.             // Perform text input
  340.             for (;;)
  341.             {
  342.                 string line = Console.ReadLine();
  343.                 if (string.IsNullOrEmpty(line))
  344.                     break;
  346.                 // Disconnect the client
  347.                 if (line == "!")
  348.                 {
  349.                     Console.Write("Client disconnecting...");
  350.                     client.Reconnect();
  351.                     Console.WriteLine("Done!");
  352.                     continue;
  353.                 }
  355.                 // Send request to the simple protocol server
  356.                 SimpleRequest request = SimpleRequest.Default;
  357.                 request.Message = line;
  358.                 var response = client.Request(request).Result;
  360.                 // Show string hash calculation result
  361.                 Console.WriteLine($"Hash of '{line}' = 0x{response.Hash:X8}");
  362.             }
  364.             // Disconnect the client
  365.             Console.Write("Client disconnecting...");
  366.             client.DisconnectAndStop();
  367.             Console.WriteLine("Done!");
  368.         }
  369.     }
  370. }

Example: HTTP server

Here comes the example of the HTTP cache server. It allows to manipulate
cache data with HTTP methods (GET, POST, PUT and DELETE).

Use the following link to open Swagger OpenAPI iterative documentation: http://localhost:8080/api/index.html

OpenAPI-HTTP

  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Text;
  6. using NetCoreServer;
  8. namespace HttpServer
  9. {
  10.     class CommonCache
  11.     {
  12.         public static CommonCache GetInstance()
  13.         {
  14.             if (_instance == null)
  15.                 _instance = new CommonCache();
  16.             return _instance;
  17.         }
  19.         public string GetAllCache()
  20.         {
  21.             var result = new StringBuilder();
  22.             result.Append("[\n");
  23.             foreach (var item in _cache)
  24.             {
  25.                 result.Append("  {\n");
  26.                 result.AppendFormat($"    \"key\": \"{item.Key}\",\n");
  27.                 result.AppendFormat($"    \"value\": \"{item.Value}\",\n");
  28.                 result.Append("  },\n");
  29.             }
  30.             result.Append("]\n");
  31.             return result.ToString();
  32.         }
  34.         public bool GetCacheValue(string key, out string value)
  35.         {
  36.             return _cache.TryGetValue(key, out value);
  37.         }
  39.         public void PutCacheValue(string key, string value)
  40.         {
  41.             _cache[key] = value;
  42.         }
  44.         public bool DeleteCacheValue(string key, out string value)
  45.         {
  46.             return _cache.TryRemove(key, out value);
  47.         }
  49.         private readonly ConcurrentDictionary<string, string> _cache = new ConcurrentDictionary<string, string>();
  50.         private static CommonCache _instance;
  51.     }
  53.     class HttpCacheSession : HttpSession
  54.     {
  55.         public HttpCacheSession(NetCoreServer.HttpServer server) : base(server) {}
  57.         protected override void OnReceivedRequest(HttpRequest request)
  58.         {
  59.             // Show HTTP request content
  60.             Console.WriteLine(request);
  62.             // Process HTTP request methods
  63.             if (request.Method == "HEAD")
  64.                 SendResponseAsync(Response.MakeHeadResponse());
  65.             else if (request.Method == "GET")
  66.             {
  67.                 string key = request.Url;
  69.                 // Decode the key value
  70.                 key = Uri.UnescapeDataString(key);
  71.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  72.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  74.                 if (string.IsNullOrEmpty(key))
  75.                 {
  76.                     // Response with all cache values
  77.                     SendResponseAsync(Response.MakeGetResponse(CommonCache.GetInstance().GetAllCache(), "application/json; charset=UTF-8"));
  78.                 }
  79.                 // Get the cache value by the given key
  80.                 else if (CommonCache.GetInstance().GetCacheValue(key, out var value))
  81.                 {
  82.                     // Response with the cache value
  83.                     SendResponseAsync(Response.MakeGetResponse(value));
  84.                 }
  85.                 else
  86.                     SendResponseAsync(Response.MakeErrorResponse(404, "Required cache value was not found for the key: " + key));
  87.             }
  88.             else if ((request.Method == "POST") || (request.Method == "PUT"))
  89.             {
  90.                 string key = request.Url;
  91.                 string value = request.Body;
  93.                 // Decode the key value
  94.                 key = Uri.UnescapeDataString(key);
  95.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  96.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  98.                 // Put the cache value
  99.                 CommonCache.GetInstance().PutCacheValue(key, value);
  101.                 // Response with the cache value
  102.                 SendResponseAsync(Response.MakeOkResponse());
  103.             }
  104.             else if (request.Method == "DELETE")
  105.             {
  106.                 string key = request.Url;
  108.                 // Decode the key value
  109.                 key = Uri.UnescapeDataString(key);
  110.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  111.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  113.                 // Delete the cache value
  114.                 if (CommonCache.GetInstance().DeleteCacheValue(key, out var value))
  115.                 {
  116.                     // Response with the cache value
  117.                     SendResponseAsync(Response.MakeGetResponse(value));
  118.                 }
  119.                 else
  120.                     SendResponseAsync(Response.MakeErrorResponse(404, "Deleted cache value was not found for the key: " + key));
  121.             }
  122.             else if (request.Method == "OPTIONS")
  123.                 SendResponseAsync(Response.MakeOptionsResponse());
  124.             else if (request.Method == "TRACE")
  125.                 SendResponseAsync(Response.MakeTraceResponse(request.Cache.Data));
  126.             else
  127.                 SendResponseAsync(Response.MakeErrorResponse("Unsupported HTTP method: " + request.Method));
  128.         }
  130.         protected override void OnReceivedRequestError(HttpRequest request, string error)
  131.         {
  132.             Console.WriteLine($"Request error: {error}");
  133.         }
  135.         protected override void OnError(SocketError error)
  136.         {
  137.             Console.WriteLine($"HTTP session caught an error: {error}");
  138.         }
  139.     }
  141.     class HttpCacheServer : NetCoreServer.HttpServer
  142.     {
  143.         public HttpCacheServer(IPAddress address, int port) : base(address, port) {}
  145.         protected override TcpSession CreateSession() { return new HttpCacheSession(this); }
  147.         protected override void OnError(SocketError error)
  148.         {
  149.             Console.WriteLine($"HTTP session caught an error: {error}");
  150.         }
  151.     }
  153.     class Program
  154.     {
  155.         static void Main(string[] args)
  156.         {
  157.             // HTTP server port
  158.             int port = 8080;
  159.             if (args.Length > 0)
  160.                 port = int.Parse(args[0]);
  161.             // HTTP server content path
  162.             string www = "../../../../../www/api";
  163.             if (args.Length > 1)
  164.                 www = args[1];
  166.             Console.WriteLine($"HTTP server port: {port}");
  167.             Console.WriteLine($"HTTP server static content path: {www}");
  168.             Console.WriteLine($"HTTP server website: http://localhost:{port}/api/index.html");
  170.             Console.WriteLine();
  172.             // Create a new HTTP server
  173.             var server = new HttpCacheServer(IPAddress.Any, port);
  174.             server.AddStaticContent(www, "/api");
  176.             // Start the server
  177.             Console.Write("Server starting...");
  178.             server.Start();
  179.             Console.WriteLine("Done!");
  181.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  183.             // Perform text input
  184.             for (;;)
  185.             {
  186.                 string line = Console.ReadLine();
  187.                 if (string.IsNullOrEmpty(line))
  188.                     break;
  190.                 // Restart the server
  191.                 if (line == "!")
  192.                 {
  193.                     Console.Write("Server restarting...");
  194.                     server.Restart();
  195.                     Console.WriteLine("Done!");
  196.                 }
  197.             }
  199.             // Stop the server
  200.             Console.Write("Server stopping...");
  201.             server.Stop();
  202.             Console.WriteLine("Done!");
  203.         }
  204.     }
  205. }

Example: HTTP client

Here comes the example of the HTTP client. It allows to send HTTP requests
(GET, POST, PUT and DELETE) and receive HTTP responses.

  1. using System;
  2. using NetCoreServer;
  4. namespace HttpClient
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             // HTTP server address
  11.             string address = "127.0.0.1";
  12.             if (args.Length > 0)
  13.                 address = args[0];
  15.             // HTTP server port
  16.             int port = 8080;
  17.             if (args.Length > 1)
  18.                 port = int.Parse(args[1]);
  20.             Console.WriteLine($"HTTP server address: {address}");
  21.             Console.WriteLine($"HTTP server port: {port}");
  23.             Console.WriteLine();
  25.             // Create a new HTTP client
  26.             var client = new HttpClientEx(address, port);
  28.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  30.             // Perform text input
  31.             for (;;)
  32.             {
  33.                 string line = Console.ReadLine();
  34.                 if (string.IsNullOrEmpty(line))
  35.                     break;
  37.                 // Reconnect the client
  38.                 if (line == "!")
  39.                 {
  40.                     Console.Write("Client reconnecting...");
  41.                     if (client.IsConnected)
  42.                         client.ReconnectAsync();
  43.                     else
  44.                         client.ConnectAsync();
  45.                     Console.WriteLine("Done!");
  46.                     continue;
  47.                 }
  49.                 var commands = line.Split(' ');
  50.                 if (commands.Length < 2)
  51.                 {
  52.                     Console.WriteLine("HTTP method and URL must be entered!");
  53.                     continue;
  54.                 }
  56.                 if (commands[0].ToUpper() == "HEAD")
  57.                 {
  58.                     var response = client.SendHeadRequest(commands[1]).Result;
  59.                     Console.WriteLine(response);
  60.                 }
  61.                 else if (commands[0].ToUpper() == "GET")
  62.                 {
  63.                     var response = client.SendGetRequest(commands[1]).Result;
  64.                     Console.WriteLine(response);
  65.                 }
  66.                 else if (commands[0].ToUpper() == "POST")
  67.                 {
  68.                     if (commands.Length < 3)
  69.                     {
  70.                         Console.WriteLine("HTTP method, URL and body must be entered!");
  71.                         continue;
  72.                     }
  74.                     var response = client.SendPostRequest(commands[1], commands[2]).Result;
  75.                     Console.WriteLine(response);
  76.                 }
  77.                 else if (commands[0].ToUpper() == "PUT")
  78.                 {
  79.                     if (commands.Length < 3)
  80.                     {
  81.                         Console.WriteLine("HTTP method, URL and body must be entered!");
  82.                         continue;
  83.                     }
  85.                     var response = client.SendPutRequest(commands[1], commands[2]).Result;
  86.                     Console.WriteLine(response);
  87.                 }
  88.                 else if (commands[0].ToUpper() == "DELETE")
  89.                 {
  90.                     var response = client.SendDeleteRequest(commands[1]).Result;
  91.                     Console.WriteLine(response);
  92.                 }
  93.                 else if (commands[0].ToUpper() == "OPTIONS")
  94.                 {
  95.                     var response = client.SendOptionsRequest(commands[1]).Result;
  96.                     Console.WriteLine(response);
  97.                 }
  98.                 else if (commands[0].ToUpper() == "TRACE")
  99.                 {
  100.                     var response = client.SendTraceRequest(commands[1]).Result;
  101.                     Console.WriteLine(response);
  102.                 }
  103.                 else
  104.                     Console.WriteLine("Unknown HTTP method");
  105.             }
  107.             // Disconnect the client
  108.             Console.Write("Client disconnecting...");
  109.             client.Disconnect();
  110.             Console.WriteLine("Done!");
  111.         }
  112.     }
  113. }

Example: HTTPS server

Here comes the example of the HTTPS cache server. It allows to manipulate
cache data with HTTP methods (GET, POST, PUT and DELETE) with secured
transport protocol.

Use the following link to open Swagger OpenAPI iterative documentation: https://localhost:8443/api/index.html

OpenAPI-HTTPS

  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Security.Authentication;
  6. using System.Security.Cryptography.X509Certificates;
  7. using System.Text;
  8. using NetCoreServer;
  10. namespace HttpsServer
  11. {
  12.     class CommonCache
  13.     {
  14.         public static CommonCache GetInstance()
  15.         {
  16.             if (_instance == null)
  17.                 _instance = new CommonCache();
  18.             return _instance;
  19.         }
  21.         public string GetAllCache()
  22.         {
  23.             var result = new StringBuilder();
  24.             result.Append("[\n");
  25.             foreach (var item in _cache)
  26.             {
  27.                 result.Append("  {\n");
  28.                 result.AppendFormat($"    \"key\": \"{item.Key}\",\n");
  29.                 result.AppendFormat($"    \"value\": \"{item.Value}\",\n");
  30.                 result.Append("  },\n");
  31.             }
  32.             result.Append("]\n");
  33.             return result.ToString();
  34.         }
  36.         public bool GetCacheValue(string key, out string value)
  37.         {
  38.             return _cache.TryGetValue(key, out value);
  39.         }
  41.         public void PutCacheValue(string key, string value)
  42.         {
  43.             _cache[key] = value;
  44.         }
  46.         public bool DeleteCacheValue(string key, out string value)
  47.         {
  48.             return _cache.TryRemove(key, out value);
  49.         }
  51.         private readonly ConcurrentDictionary<string, string> _cache = new ConcurrentDictionary<string, string>();
  52.         private static CommonCache _instance;
  53.     }
  55.     class HttpsCacheSession : HttpsSession
  56.     {
  57.         public HttpsCacheSession(NetCoreServer.HttpsServer server) : base(server) {}
  59.         protected override void OnReceivedRequest(HttpRequest request)
  60.         {
  61.             // Show HTTP request content
  62.             Console.WriteLine(request);
  64.             // Process HTTP request methods
  65.             if (request.Method == "HEAD")
  66.                 SendResponseAsync(Response.MakeHeadResponse());
  67.             else if (request.Method == "GET")
  68.             {
  69.                 string key = request.Url;
  71.                 // Decode the key value
  72.                 key = Uri.UnescapeDataString(key);
  73.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  74.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  76.                 if (string.IsNullOrEmpty(key))
  77.                 {
  78.                     // Response with all cache values
  79.                     SendResponseAsync(Response.MakeGetResponse(CommonCache.GetInstance().GetAllCache(), "application/json; charset=UTF-8"));
  80.                 }
  81.                 // Get the cache value by the given key
  82.                 else if (CommonCache.GetInstance().GetCacheValue(key, out var value))
  83.                 {
  84.                     // Response with the cache value
  85.                     SendResponseAsync(Response.MakeGetResponse(value));
  86.                 }
  87.                 else
  88.                     SendResponseAsync(Response.MakeErrorResponse(404, "Required cache value was not found for the key: " + key));
  89.             }
  90.             else if ((request.Method == "POST") || (request.Method == "PUT"))
  91.             {
  92.                 string key = request.Url;
  93.                 string value = request.Body;
  95.                 // Decode the key value
  96.                 key = Uri.UnescapeDataString(key);
  97.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  98.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  100.                 // Put the cache value
  101.                 CommonCache.GetInstance().PutCacheValue(key, value);
  103.                 // Response with the cache value
  104.                 SendResponseAsync(Response.MakeOkResponse());
  105.             }
  106.             else if (request.Method == "DELETE")
  107.             {
  108.                 string key = request.Url;
  110.                 // Decode the key value
  111.                 key = Uri.UnescapeDataString(key);
  112.                 key = key.Replace("/api/cache", "", StringComparison.InvariantCultureIgnoreCase);
  113.                 key = key.Replace("?key=", "", StringComparison.InvariantCultureIgnoreCase);
  115.                 // Delete the cache value
  116.                 if (CommonCache.GetInstance().DeleteCacheValue(key, out var value))
  117.                 {
  118.                     // Response with the cache value
  119.                     SendResponseAsync(Response.MakeGetResponse(value));
  120.                 }
  121.                 else
  122.                     SendResponseAsync(Response.MakeErrorResponse(404, "Deleted cache value was not found for the key: " + key));
  123.             }
  124.             else if (request.Method == "OPTIONS")
  125.                 SendResponseAsync(Response.MakeOptionsResponse());
  126.             else if (request.Method == "TRACE")
  127.                 SendResponseAsync(Response.MakeTraceResponse(request.Cache));
  128.             else
  129.                 SendResponseAsync(Response.MakeErrorResponse("Unsupported HTTP method: " + request.Method));
  130.         }
  132.         protected override void OnReceivedRequestError(HttpRequest request, string error)
  133.         {
  134.             Console.WriteLine($"Request error: {error}");
  135.         }
  137.         protected override void OnError(SocketError error)
  138.         {
  139.             Console.WriteLine($"HTTPS session caught an error: {error}");
  140.         }
  141.     }
  143.     class HttpsCacheServer : NetCoreServer.HttpsServer
  144.     {
  145.         public HttpsCacheServer(SslContext context, IPAddress address, int port) : base(context, address, port) {}
  147.         protected override SslSession CreateSession() { return new HttpsCacheSession(this); }
  149.         protected override void OnError(SocketError error)
  150.         {
  151.             Console.WriteLine($"HTTPS server caught an error: {error}");
  152.         }
  153.     }
  155.     class Program
  156.     {
  157.         static void Main(string[] args)
  158.         {
  159.             // HTTPS server port
  160.             int port = 8443;
  161.             if (args.Length > 0)
  162.                 port = int.Parse(args[0]);
  163.             // HTTPS server content path
  164.             string www = "../../../../../www/api";
  165.             if (args.Length > 1)
  166.                 www = args[1];
  168.             Console.WriteLine($"HTTPS server port: {port}");
  169.             Console.WriteLine($"HTTPS server static content path: {www}");
  170.             Console.WriteLine($"HTTPS server website: https://localhost:{port}/api/index.html");
  172.             Console.WriteLine();
  174.             // Create and prepare a new SSL server context
  175.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("server.pfx", "qwerty"));
  177.             // Create a new HTTP server
  178.             var server = new HttpsCacheServer(context, IPAddress.Any, port);
  179.             server.AddStaticContent(www, "/api");
  181.             // Start the server
  182.             Console.Write("Server starting...");
  183.             server.Start();
  184.             Console.WriteLine("Done!");
  186.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  188.             // Perform text input
  189.             for (;;)
  190.             {
  191.                 string line = Console.ReadLine();
  192.                 if (string.IsNullOrEmpty(line))
  193.                     break;
  195.                 // Restart the server
  196.                 if (line == "!")
  197.                 {
  198.                     Console.Write("Server restarting...");
  199.                     server.Restart();
  200.                     Console.WriteLine("Done!");
  201.                 }
  202.             }
  204.             // Stop the server
  205.             Console.Write("Server stopping...");
  206.             server.Stop();
  207.             Console.WriteLine("Done!");
  208.         }
  209.     }
  210. }

Example: HTTPS client

Here comes the example of the HTTPS client. It allows to send HTTP requests
(GET, POST, PUT and DELETE) and receive HTTP responses with secured
transport protocol.

  1. using System;
  2. using System.Security.Authentication;
  3. using System.Security.Cryptography.X509Certificates;
  4. using NetCoreServer;
  6. namespace HttpsClient
  7. {
  8.     class Program
  9.     {
  10.         static void Main(string[] args)
  11.         {
  12.             // HTTPS server address
  13.             string address = "127.0.0.1";
  14.             if (args.Length > 0)
  15.                 address = args[0];
  17.             // HTTPS server port
  18.             int port = 8443;
  19.             if (args.Length > 1)
  20.                 port = int.Parse(args[1]);
  22.             Console.WriteLine($"HTTPS server address: {address}");
  23.             Console.WriteLine($"HTTPS server port: {port}");
  25.             Console.WriteLine();
  27.             // Create and prepare a new SSL client context
  28.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("client.pfx", "qwerty"), (sender, certificate, chain, sslPolicyErrors) => true);
  30.             // Create a new HTTPS client
  31.             var client = new HttpsClientEx(context, address, port);
  33.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  35.             // Perform text input
  36.             for (;;)
  37.             {
  38.                 string line = Console.ReadLine();
  39.                 if (string.IsNullOrEmpty(line))
  40.                     break;
  42.                 // Reconnect the client
  43.                 if (line == "!")
  44.                 {
  45.                     Console.Write("Client reconnecting...");
  46.                     if (client.IsConnected)
  47.                         client.ReconnectAsync();
  48.                     else
  49.                         client.ConnectAsync();
  50.                     Console.WriteLine("Done!");
  51.                     continue;
  52.                 }
  54.                 var commands = line.Split(' ');
  55.                 if (commands.Length < 2)
  56.                 {
  57.                     Console.WriteLine("HTTP method and URL must be entered!");
  58.                     continue;
  59.                 }
  61.                 if (commands[0].ToUpper() == "HEAD")
  62.                 {
  63.                     var response = client.SendHeadRequest(commands[1]).Result;
  64.                     Console.WriteLine(response);
  65.                 }
  66.                 else if (commands[0].ToUpper() == "GET")
  67.                 {
  68.                     var response = client.SendGetRequest(commands[1]).Result;
  69.                     Console.WriteLine(response);
  70.                 }
  71.                 else if (commands[0].ToUpper() == "POST")
  72.                 {
  73.                     if (commands.Length < 3)
  74.                     {
  75.                         Console.WriteLine("HTTP method, URL and body must be entered!");
  76.                         continue;
  77.                     }
  79.                     var response = client.SendPostRequest(commands[1], commands[2]).Result;
  80.                     Console.WriteLine(response);
  81.                 }
  82.                 else if (commands[0].ToUpper() == "PUT")
  83.                 {
  84.                     if (commands.Length < 3)
  85.                     {
  86.                         Console.WriteLine("HTTP method, URL and body must be entered!");
  87.                         continue;
  88.                     }
  90.                     var response = client.SendPutRequest(commands[1], commands[2]).Result;
  91.                     Console.WriteLine(response);
  92.                 }
  93.                 else if (commands[0].ToUpper() == "DELETE")
  94.                 {
  95.                     var response = client.SendDeleteRequest(commands[1]).Result;
  96.                     Console.WriteLine(response);
  97.                 }
  98.                 else if (commands[0].ToUpper() == "OPTIONS")
  99.                 {
  100.                     var response = client.SendOptionsRequest(commands[1]).Result;
  101.                     Console.WriteLine(response);
  102.                 }
  103.                 else if (commands[0].ToUpper() == "TRACE")
  104.                 {
  105.                     var response = client.SendTraceRequest(commands[1]).Result;
  106.                     Console.WriteLine(response);
  107.                 }
  108.                 else
  109.                     Console.WriteLine("Unknown HTTP method");
  110.             }
  112.             // Disconnect the client
  113.             Console.Write("Client disconnecting...");
  114.             client.Disconnect();
  115.             Console.WriteLine("Done!");
  116.         }
  117.     }
  118. }

Example: WebSocket chat server

Here comes the example of the WebSocket chat server. It handles multiple
WebSocket client sessions and multicast received message from any session
to all ones. Also it is possible to send admin message directly from the
server.

Use the following link to open WebSocket chat server example: http://localhost:8080/chat/index.html

ws-chat

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using NetCoreServer;
  7. namespace WsChatServer
  8. {
  9.     class ChatSession : WsSession
  10.     {
  11.         public ChatSession(WsServer server) : base(server) {}
  13.         public override void OnWsConnected(HttpRequest request)
  14.         {
  15.             Console.WriteLine($"Chat WebSocket session with Id {Id} connected!");
  17.             // Send invite message
  18.             string message = "Hello from WebSocket chat! Please send a message or '!' to disconnect the client!";
  19.             SendTextAsync(message);
  20.         }
  22.         public override void OnWsDisconnected()
  23.         {
  24.             Console.WriteLine($"Chat WebSocket session with Id {Id} disconnected!");
  25.         }
  27.         public override void OnWsReceived(byte[] buffer, long offset, long size)
  28.         {
  29.             string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
  30.             Console.WriteLine("Incoming: " + message);
  32.             // Multicast message to all connected sessions
  33.             ((WsServer)Server).MulticastText(message);
  35.             // If the buffer starts with '!' the disconnect the current session
  36.             if (message == "!")
  37.                 Close(1000);
  38.         }
  40.         protected override void OnError(SocketError error)
  41.         {
  42.             Console.WriteLine($"Chat WebSocket session caught an error with code {error}");
  43.         }
  44.     }
  46.     class ChatServer : WsServer
  47.     {
  48.         public ChatServer(IPAddress address, int port) : base(address, port) {}
  50.         protected override TcpSession CreateSession() { return new ChatSession(this); }
  52.         protected override void OnError(SocketError error)
  53.         {
  54.             Console.WriteLine($"Chat WebSocket server caught an error with code {error}");
  55.         }
  56.     }
  58.     class Program
  59.     {
  60.         static void Main(string[] args)
  61.         {
  62.             // WebSocket server port
  63.             int port = 8080;
  64.             if (args.Length > 0)
  65.                 port = int.Parse(args[0]);
  66.             // WebSocket server content path
  67.             string www = "../../../../../www/ws";
  68.             if (args.Length > 1)
  69.                 www = args[1];
  71.             Console.WriteLine($"WebSocket server port: {port}");
  72.             Console.WriteLine($"WebSocket server static content path: {www}");
  73.             Console.WriteLine($"WebSocket server website: http://localhost:{port}/chat/index.html");
  75.             Console.WriteLine();
  77.             // Create a new WebSocket server
  78.             var server = new ChatServer(IPAddress.Any, port);
  79.             server.AddStaticContent(www, "/chat");
  81.             // Start the server
  82.             Console.Write("Server starting...");
  83.             server.Start();
  84.             Console.WriteLine("Done!");
  86.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  88.             // Perform text input
  89.             for (;;)
  90.             {
  91.                 string line = Console.ReadLine();
  92.                 if (string.IsNullOrEmpty(line))
  93.                     break;
  95.                 // Restart the server
  96.                 if (line == "!")
  97.                 {
  98.                     Console.Write("Server restarting...");
  99.                     server.Restart();
  100.                     Console.WriteLine("Done!");
  101.                 }
  103.                 // Multicast admin message to all sessions
  104.                 line = "(admin) " + line;
  105.                 server.MulticastText(line);
  106.             }
  108.             // Stop the server
  109.             Console.Write("Server stopping...");
  110.             server.Stop();
  111.             Console.WriteLine("Done!");
  112.         }
  113.     }
  114. }

Example: WebSocket chat client

Here comes the example of the WebSocket chat client. It connects to the
WebSocket chat server and allows to send message to it and receive new
messages.

  1. using System;
  2. using System.Net.Sockets;
  3. using System.Text;
  4. using System.Threading;
  5. using NetCoreServer;
  7. namespace WsChatClient
  8. {
  9.     class ChatClient : WsClient
  10.     {
  11.         public ChatClient(string address, int port) : base(address, port) {}
  13.         public void DisconnectAndStop()
  14.         {
  15.             _stop = true;
  16.             CloseAsync(1000);
  17.             while (IsConnected)
  18.                 Thread.Yield();
  19.         }
  21.         public override void OnWsConnecting(HttpRequest request)
  22.         {
  23.             request.SetBegin("GET", "/");
  24.             request.SetHeader("Host", "localhost");
  25.             request.SetHeader("Origin", "http://localhost");
  26.             request.SetHeader("Upgrade", "websocket");
  27.             request.SetHeader("Connection", "Upgrade");
  28.             request.SetHeader("Sec-WebSocket-Key", Convert.ToBase64String(WsNonce));
  29.             request.SetHeader("Sec-WebSocket-Protocol", "chat, superchat");
  30.             request.SetHeader("Sec-WebSocket-Version", "13");
  31.             request.SetBody();
  32.         }
  34.         public override void OnWsConnected(HttpResponse response)
  35.         {
  36.             Console.WriteLine($"Chat WebSocket client connected a new session with Id {Id}");
  37.         }
  39.         public override void OnWsDisconnected()
  40.         {
  41.             Console.WriteLine($"Chat WebSocket client disconnected a session with Id {Id}");
  42.         }
  44.         public override void OnWsReceived(byte[] buffer, long offset, long size)
  45.         {
  46.             Console.WriteLine($"Incoming: {Encoding.UTF8.GetString(buffer, (int)offset, (int)size)}");
  47.         }
  49.         protected override void OnDisconnected()
  50.         {
  51.             base.OnDisconnected();
  53.             Console.WriteLine($"Chat WebSocket client disconnected a session with Id {Id}");
  55.             // Wait for a while...
  56.             Thread.Sleep(1000);
  58.             // Try to connect again
  59.             if (!_stop)
  60.                 ConnectAsync();
  61.         }
  63.         protected override void OnError(SocketError error)
  64.         {
  65.             Console.WriteLine($"Chat WebSocket client caught an error with code {error}");
  66.         }
  68.         private bool _stop;
  69.     }
  71.     class Program
  72.     {
  73.         static void Main(string[] args)
  74.         {
  75.             // WebSocket server address
  76.             string address = "127.0.0.1";
  77.             if (args.Length > 0)
  78.                 address = args[0];
  80.             // WebSocket server port
  81.             int port = 8080;
  82.             if (args.Length > 1)
  83.                 port = int.Parse(args[1]);
  85.             Console.WriteLine($"WebSocket server address: {address}");
  86.             Console.WriteLine($"WebSocket server port: {port}");
  88.             Console.WriteLine();
  90.             // Create a new TCP chat client
  91.             var client = new ChatClient(address, port);
  93.             // Connect the client
  94.             Console.Write("Client connecting...");
  95.             client.ConnectAsync();
  96.             Console.WriteLine("Done!");
  98.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  100.             // Perform text input
  101.             for (;;)
  102.             {
  103.                 string line = Console.ReadLine();
  104.                 if (string.IsNullOrEmpty(line))
  105.                     break;
  107.                 // Disconnect the client
  108.                 if (line == "!")
  109.                 {
  110.                     Console.Write("Client disconnecting...");
  111.                     client.DisconnectAsync();
  112.                     Console.WriteLine("Done!");
  113.                     continue;
  114.                 }
  116.                 // Send the entered text to the chat server
  117.                 client.SendTextAsync(line);
  118.             }
  120.             // Disconnect the client
  121.             Console.Write("Client disconnecting...");
  122.             client.DisconnectAndStop();
  123.             Console.WriteLine("Done!");
  124.         }
  125.     }
  126. }

Example: WebSocket secure chat server

Here comes the example of the WebSocket secure chat server. It handles
multiple WebSocket secure client sessions and multicast received message
from any session to all ones. Also it is possible to send admin message
directly from the server.

This example is very similar to the WebSocket one except the code that
prepares WebSocket secure context and handshake handler.

Use the following link to open WebSocket secure chat server example: https://localhost:8443/chat/index.html

wss-chat

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Security.Authentication;
  5. using System.Security.Cryptography.X509Certificates;
  6. using System.Text;
  7. using NetCoreServer;
  9. namespace WssChatServer
  10. {
  11.     class ChatSession : WssSession
  12.     {
  13.         public ChatSession(WssServer server) : base(server) {}
  15.         public override void OnWsConnected(HttpRequest request)
  16.         {
  17.             Console.WriteLine($"Chat WebSocket session with Id {Id} connected!");
  19.             // Send invite message
  20.             string message = "Hello from WebSocket chat! Please send a message or '!' to disconnect the client!";
  21.             SendTextAsync(message);
  22.         }
  24.         public override void OnWsDisconnected()
  25.         {
  26.             Console.WriteLine($"Chat WebSocket session with Id {Id} disconnected!");
  27.         }
  29.         public override void OnWsReceived(byte[] buffer, long offset, long size)
  30.         {
  31.             string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
  32.             Console.WriteLine("Incoming: " + message);
  34.             // Multicast message to all connected sessions
  35.             ((WssServer)Server).MulticastText(message);
  37.             // If the buffer starts with '!' the disconnect the current session
  38.             if (message == "!")
  39.                 Close(1000);
  40.         }
  42.         protected override void OnError(SocketError error)
  43.         {
  44.             Console.WriteLine($"Chat WebSocket session caught an error with code {error}");
  45.         }
  46.     }
  48.     class ChatServer : WssServer
  49.     {
  50.         public ChatServer(SslContext context, IPAddress address, int port) : base(context, address, port) {}
  52.         protected override SslSession CreateSession() { return new ChatSession(this); }
  54.         protected override void OnError(SocketError error)
  55.         {
  56.             Console.WriteLine($"Chat WebSocket server caught an error with code {error}");
  57.         }
  58.     }
  60.     class Program
  61.     {
  62.         static void Main(string[] args)
  63.         {
  64.             // WebSocket server port
  65.             int port = 8443;
  66.             if (args.Length > 0)
  67.                 port = int.Parse(args[0]);
  68.             // WebSocket server content path
  69.             string www = "../../../../../www/wss";
  70.             if (args.Length > 1)
  71.                 www = args[1];
  73.             Console.WriteLine($"WebSocket server port: {port}");
  74.             Console.WriteLine($"WebSocket server static content path: {www}");
  75.             Console.WriteLine($"WebSocket server website: https://localhost:{port}/chat/index.html");
  77.             Console.WriteLine();
  79.             // Create and prepare a new SSL server context
  80.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("server.pfx", "qwerty"));
  82.             // Create a new WebSocket server
  83.             var server = new ChatServer(context, IPAddress.Any, port);
  84.             server.AddStaticContent(www, "/chat");
  86.             // Start the server
  87.             Console.Write("Server starting...");
  88.             server.Start();
  89.             Console.WriteLine("Done!");
  91.             Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");
  93.             // Perform text input
  94.             for (;;)
  95.             {
  96.                 string line = Console.ReadLine();
  97.                 if (string.IsNullOrEmpty(line))
  98.                     break;
  100.                 // Restart the server
  101.                 if (line == "!")
  102.                 {
  103.                     Console.Write("Server restarting...");
  104.                     server.Restart();
  105.                     Console.WriteLine("Done!");
  106.                 }
  108.                 // Multicast admin message to all sessions
  109.                 line = "(admin) " + line;
  110.                 server.MulticastText(line);
  111.             }
  113.             // Stop the server
  114.             Console.Write("Server stopping...");
  115.             server.Stop();
  116.             Console.WriteLine("Done!");
  117.         }
  118.     }
  119. }

Example: WebSocket secure chat client

Here comes the example of the WebSocket secure chat client. It connects to
the WebSocket secure chat server and allows to send message to it and receive
new messages.

This example is very similar to the WebSocket one except the code that
prepares WebSocket secure context and handshake handler.

  1. using System;
  2. using System.Net.Sockets;
  3. using System.Security.Authentication;
  4. using System.Security.Cryptography.X509Certificates;
  5. using System.Text;
  6. using System.Threading;
  7. using NetCoreServer;
  9. namespace WssChatClient
  10. {
  11.     class ChatClient : WssClient
  12.     {
  13.         public ChatClient(SslContext context, string address, int port) : base(context, address, port) {}
  15.         public void DisconnectAndStop()
  16.         {
  17.             _stop = true;
  18.             CloseAsync(1000);
  19.             while (IsConnected)
  20.                 Thread.Yield();
  21.         }
  23.         public override void OnWsConnecting(HttpRequest request)
  24.         {
  25.             request.SetBegin("GET", "/");
  26.             request.SetHeader("Host", "localhost");
  27.             request.SetHeader("Origin", "http://localhost");
  28.             request.SetHeader("Upgrade", "websocket");
  29.             request.SetHeader("Connection", "Upgrade");
  30.             request.SetHeader("Sec-WebSocket-Key", Convert.ToBase64String(WsNonce));
  31.             request.SetHeader("Sec-WebSocket-Protocol", "chat, superchat");
  32.             request.SetHeader("Sec-WebSocket-Version", "13");
  33.             request.SetBody();
  34.         }
  36.         public override void OnWsConnected(HttpResponse response)
  37.         {
  38.             Console.WriteLine($"Chat WebSocket client connected a new session with Id {Id}");
  39.         }
  41.         public override void OnWsDisconnected()
  42.         {
  43.             Console.WriteLine($"Chat WebSocket client disconnected a session with Id {Id}");
  44.         }
  46.         public override void OnWsReceived(byte[] buffer, long offset, long size)
  47.         {
  48.             Console.WriteLine($"Incoming: {Encoding.UTF8.GetString(buffer, (int)offset, (int)size)}");
  49.         }
  51.         protected override void OnDisconnected()
  52.         {
  53.             base.OnDisconnected();
  55.             Console.WriteLine($"Chat WebSocket client disconnected a session with Id {Id}");
  57.             // Wait for a while...
  58.             Thread.Sleep(1000);
  60.             // Try to connect again
  61.             if (!_stop)
  62.                 ConnectAsync();
  63.         }
  65.         protected override void OnError(SocketError error)
  66.         {
  67.             Console.WriteLine($"Chat WebSocket client caught an error with code {error}");
  68.         }
  70.         private bool _stop;
  71.     }
  73.     class Program
  74.     {
  75.         static void Main(string[] args)
  76.         {
  77.             // WebSocket server address
  78.             string address = "127.0.0.1";
  79.             if (args.Length > 0)
  80.                 address = args[0];
  82.             // WebSocket server port
  83.             int port = 8443;
  84.             if (args.Length > 1)
  85.                 port = int.Parse(args[1]);
  87.             Console.WriteLine($"WebSocket server address: {address}");
  88.             Console.WriteLine($"WebSocket server port: {port}");
  90.             Console.WriteLine();
  92.             // Create and prepare a new SSL client context
  93.             var context = new SslContext(SslProtocols.Tls12, new X509Certificate2("client.pfx", "qwerty"), (sender, certificate, chain, sslPolicyErrors) => true);
  95.             // Create a new TCP chat client
  96.             var client = new ChatClient(context, address, port);
  98.             // Connect the client
  99.             Console.Write("Client connecting...");
  100.             client.ConnectAsync();
  101.             Console.WriteLine("Done!");
  103.             Console.WriteLine("Press Enter to stop the client or '!' to reconnect the client...");
  105.             // Perform text input
  106.             for (;;)
  107.             {
  108.                 string line = Console.ReadLine();
  109.                 if (string.IsNullOrEmpty(line))
  110.                     break;
  112.                 // Reconnect the client
  113.                 if (line == "!")
  114.                 {
  115.                     Console.Write("Client reconnecting...");
  116.                     if (client.IsConnected)
  117.                         client.ReconnectAsync();
  118.                     else
  119.                         client.ConnectAsync();
  120.                     Console.WriteLine("Done!");
  121.                     continue;
  122.                 }
  124.                 // Send the entered text to the chat server
  125.                 client.SendTextAsync(line);
  126.             }
  128.             // Disconnect the client
  129.             Console.Write("Client disconnecting...");
  130.             client.DisconnectAndStop();
  131.             Console.WriteLine("Done!");
  132.         }
  133.     }
  134. }

Performance

Here comes several communication scenarios with timing measurements.

Benchmark environment is the following:

  1. CPU architecutre: Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz
  2. CPU logical cores: 8
  3. CPU physical cores: 4
  4. CPU clock speed: 3.998 GHz
  5. CPU Hyper-Threading: enabled
  6. RAM total: 31.962 GiB
  7. RAM free: 24.011 GiB
  9. OS version: Microsoft Windows 8 Enterprise Edition (build 9200), 64-bit
  10. OS bits: 64-bit
  11. Process bits: 64-bit
  12. Process configuaraion: release

Benchmark: Round-Trip

Round-trip

This scenario sends lots of messages from several clients to a server.
The server responses to each message and resend the similar response to
the client. The benchmark measures total round-trip time to send all
messages and receive all responses, messages & data throughput, count
of errors.

TCP echo server

  1. Server address: 127.0.0.1
  2. Server port: 1111
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.024 s
  11. Total data: 2.831 GiB
  12. Total messages: 94369133
  13. Data throughput: 287.299 MiB/s
  14. Message latency: 106 ns
  15. Message throughput: 9413997 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 1111
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.189 s
  11. Total data: 1.794 GiB
  12. Total messages: 59585544
  13. Data throughput: 178.463 MiB/s
  14. Message latency: 171 ns
  15. Message throughput: 5847523 msg/s

SSL echo server

  1. Server address: 127.0.0.1
  2. Server port: 2222
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 2.645 s
  11. Total data: 373.329 MiB
  12. Total messages: 12233021
  13. Data throughput: 141.095 MiB/s
  14. Message latency: 216 ns
  15. Message throughput: 4623352 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 2222
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.060 s
  11. Total data: 1.472 GiB
  12. Total messages: 49029133
  13. Data throughput: 148.741 MiB/s
  14. Message latency: 205 ns
  15. Message throughput: 4873398 msg/s

UDP echo server

  1. Server address: 127.0.0.1
  2. Server port: 3333
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.032 s
  11. Total data: 33.994 MiB
  12. Total messages: 1113182
  13. Data throughput: 3.395 MiB/s
  14. Message latency: 9.012 mcs
  15. Message throughput: 110960 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 3333
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.635 s
  11. Total data: 20.355 MiB
  12. Total messages: 666791
  13. Data throughput: 1.934 MiB/s
  14. Message latency: 15.950 mcs
  15. Message throughput: 62693 msg/s

Unix Domain Socket echo server

  1. Server Unix Domain Socket path: C:\Users\chronoxor\AppData\Local\Temp\echo.sock
  2. Working clients: 1
  3. Working messages: 1000
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.016 s
  10. Total data: 208.657 MiB
  11. Total messages: 6836769
  12. Data throughput: 20.850 MiB/s
  13. Message latency: 1.465 mcs
  14. Message throughput: 682575 msg/s
  1. Server Unix Domain Socket path: C:\Users\chronoxor\AppData\Local\Temp\echo.sock
  2. Working clients: 100
  3. Working messages: 1000
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 12.253 s
  10. Total data: 602.320 MiB
  11. Total messages: 19736578
  12. Data throughput: 49.157 MiB/s
  13. Message latency: 620 ns
  14. Message throughput: 1610666 msg/s

Simple protocol server

  1. Server address: 127.0.0.1
  2. Server port: 4444
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.015 s
  11. Total data: 100.568 MiB
  12. Total messages: 3294993
  13. Data throughput: 10.040 MiB/s
  14. Message latency: 3.039 mcs
  15. Message throughput: 328978 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 4444
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 12.530 s
  11. Total data: 207.994 MiB
  12. Total messages: 6814785
  13. Data throughput: 16.611 MiB/s
  14. Message latency: 1.838 mcs
  15. Message throughput: 543858 msg/s

WebSocket echo server

  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 3.037 s
  11. Total data: 105.499 MiB
  12. Total messages: 3456618
  13. Data throughput: 34.742 MiB/s
  14. Message latency: 878 ns
  15. Message throughput: 1137864 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.078 s
  11. Total data: 426.803 MiB
  12. Total messages: 13984888
  13. Data throughput: 42.353 MiB/s
  14. Message latency: 720 ns
  15. Message throughput: 1387555 msg/s

WebSocket secure echo server

  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 1
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.030 s
  11. Total data: 198.103 MiB
  12. Total messages: 6491390
  13. Data throughput: 19.767 MiB/s
  14. Message latency: 1.545 mcs
  15. Message throughput: 647153 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 100
  4. Working messages: 1000
  5. Message size: 32
  6. Seconds to benchmarking: 10
  8. Errors: 0
  10. Total time: 10.112 s
  11. Total data: 405.286 MiB
  12. Total messages: 13280221
  13. Data throughput: 40.078 MiB/s
  14. Message latency: 761 ns
  15. Message throughput: 1313228 msg/s

Benchmark: Multicast

Multicast

In this scenario server multicasts messages to all connected clients.
The benchmark counts total messages received by all clients for all
the working time and measures messages & data throughput, count
of errors.

TCP multicast server

  1. Server address: 127.0.0.1
  2. Server port: 1111
  3. Working clients: 1
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.022 s
  10. Total data: 407.023 MiB
  11. Total messages: 13337326
  12. Data throughput: 40.625 MiB/s
  13. Message latency: 751 ns
  14. Message throughput: 1330734 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 1111
  3. Working clients: 100
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.112 s
  10. Total data: 421.348 MiB
  11. Total messages: 13806493
  12. Data throughput: 41.681 MiB/s
  13. Message latency: 732 ns
  14. Message throughput: 1365280 msg/s

SSL multicast server

  1. Server address: 127.0.0.1
  2. Server port: 2222
  3. Working clients: 1
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.024 s
  10. Total data: 325.225 MiB
  11. Total messages: 10656801
  12. Data throughput: 32.453 MiB/s
  13. Message latency: 940 ns
  14. Message throughput: 1063075 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 2222
  3. Working clients: 100
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.144 s
  10. Total data: 343.460 MiB
  11. Total messages: 11254173
  12. Data throughput: 33.876 MiB/s
  13. Message latency: 901 ns
  14. Message throughput: 1109393 msg/s

UDP multicast server

  1. Server address: 239.255.0.1
  2. Server port: 3333
  3. Working clients: 1
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.026 s
  10. Total data: 13.225 MiB
  11. Total messages: 433202
  12. Data throughput: 1.326 MiB/s
  13. Message latency: 23.145 mcs
  14. Message throughput: 43205 msg/s
  1. Server address: 239.255.0.1
  2. Server port: 3333
  3. Working clients: 100
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.035 s
  10. Total data: 28.684 MiB
  11. Total messages: 939408
  12. Data throughput: 2.877 MiB/s
  13. Message latency: 10.682 mcs
  14. Message throughput: 93606 msg/s

Unix Domain Socket multicast server

  1. Server Unix Domain Socket path: C:\Users\chronoxor\AppData\Local\Temp\multicast.sock
  2. Working clients: 1
  3. Message size: 32
  4. Seconds to benchmarking: 10
  6. Errors: 0
  8. Total time: 10.015 s
  9. Total data: 204.127 MiB
  10. Total messages: 6688763
  11. Data throughput: 20.390 MiB/s
  12. Message latency: 1.497 mcs
  13. Message throughput: 667869 msg/s
  1. Server Unix Domain Socket path: C:\Users\chronoxor\AppData\Local\Temp\multicast.sock
  2. Working clients: 100
  3. Message size: 32
  4. Seconds to benchmarking: 10
  6. Errors: 0
  8. Total time: 10.033 s
  9. Total data: 124.463 MiB
  10. Total messages: 4078051
  11. Data throughput: 12.413 MiB/s
  12. Message latency: 2.460 mcs
  13. Message throughput: 406451 msg/s

WebSocket multicast server

  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 1
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.048 s
  10. Total data: 183.108 MiB
  11. Total messages: 6000000
  12. Data throughput: 18.228 MiB/s
  13. Message latency: 1.674 mcs
  14. Message throughput: 597121 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 100
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.227 s
  10. Total data: 125.957 MiB
  11. Total messages: 4126627
  12. Data throughput: 12.320 MiB/s
  13. Message latency: 2.478 mcs
  14. Message throughput: 403466 msg/s

WebSocket secure multicast server

  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 1
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.034 s
  10. Total data: 184.159 MiB
  11. Total messages: 6034421
  12. Data throughput: 18.359 MiB/s
  13. Message latency: 1.662 mcs
  14. Message throughput: 601338 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 100
  4. Message size: 32
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.171 s
  10. Total data: 315.306 MiB
  11. Total messages: 10331721
  12. Data throughput: 30.1022 MiB/s
  13. Message latency: 984 ns
  14. Message throughput: 1015763 msg/s

Benchmark: Web Server

HTTP Trace server

  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 1
  4. Working messages: 1
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.023 s
  10. Total data: 10.987 MiB
  11. Total messages: 108465
  12. Data throughput: 1.096 MiB/s
  13. Message latency: 92.414 mcs
  14. Message throughput: 10820 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8080
  3. Working clients: 100
  4. Working messages: 1
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 10.085 s
  10. Total data: 40.382 MiB
  11. Total messages: 401472
  12. Data throughput: 4.003 MiB/s
  13. Message latency: 25.120 mcs
  14. Message throughput: 39807 msg/s

HTTPS Trace server

  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 1
  4. Working messages: 1
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 595.214 ms
  10. Total data: 627.842 KiB
  11. Total messages: 6065
  12. Data throughput: 1.030 MiB/s
  13. Message latency: 98.139 mcs
  14. Message throughput: 10189 msg/s
  1. Server address: 127.0.0.1
  2. Server port: 8443
  3. Working clients: 100
  4. Working messages: 1
  5. Seconds to benchmarking: 10
  7. Errors: 0
  9. Total time: 3.548 s
  10. Total data: 17.948 MiB
  11. Total messages: 179111
  12. Data throughput: 5.052 MiB/s
  13. Message latency: 19.813 mcs
  14. Message throughput: 50471 msg/s

OpenSSL certificates

In order to create OpenSSL based server and client you should prepare a set of
SSL certificates.

Production

Depending on your project, you may need to purchase a traditional SSL
certificate signed by a Certificate Authority. If you, for instance,
want some else’s web browser to talk to your WebSocket project, you’ll
need a traditional SSL certificate.

Development

The commands below entered in the order they are listed will generate a
self-signed certificate for development or testing purposes.

Certificate Authority

  • Create CA private key

    1. openssl genrsa -passout pass:qwerty -out ca-secret.key 4096

  • Remove passphrase

    1. openssl rsa -passin pass:qwerty -in ca-secret.key -out ca.key

  • Create CA self-signed certificate

    1. openssl req -new -x509 -days 3650 -subj '/C=BY/ST=Belarus/L=Minsk/O=Example root CA/OU=Example CA unit/CN=example.com' -key ca.key -out ca.crt

  • Convert CA self-signed certificate to PFX

    1. openssl pkcs12 -export -passout pass:qwerty -inkey ca.key -in ca.crt -out ca.pfx

  • Convert CA self-signed certificate to PEM

    1. openssl pkcs12 -passin pass:qwerty -passout pass:qwerty -in ca.pfx -out ca.pem

SSL Server certificate

  • Create private key for the server

    1. openssl genrsa -passout pass:qwerty -out server-secret.key 4096

  • Remove passphrase

    1. openssl rsa -passin pass:qwerty -in server-secret.key -out server.key

  • Create CSR for the server

    1. openssl req -new -subj '/C=BY/ST=Belarus/L=Minsk/O=Example server/OU=Example server unit/CN=server.example.com' -key server.key -out server.csr

  • Create certificate for the server

    1. openssl x509 -req -days 3650 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt

  • Convert the server certificate to PFX

    1. openssl pkcs12 -export -passout pass:qwerty -inkey server.key -in server.crt -out server.pfx

  • Convert the server certificate to PEM

    1. openssl pkcs12 -passin pass:qwerty -passout pass:qwerty -in server.pfx -out server.pem

SSL Client certificate

  • Create private key for the client

    1. openssl genrsa -passout pass:qwerty -out client-secret.key 4096

  • Remove passphrase

    1. openssl rsa -passin pass:qwerty -in client-secret.key -out client.key

  • Create CSR for the client

    1. openssl req -new -subj '/C=BY/ST=Belarus/L=Minsk/O=Example client/OU=Example client unit/CN=client.example.com' -key client.key -out client.csr

  • Create the client certificate

    1. openssl x509 -req -days 3650 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out client.crt

  • Convert the client certificate to PFX

    1. openssl pkcs12 -export -passout pass:qwerty -inkey client.key -in client.crt -out client.pfx

  • Convert the client certificate to PEM

    1. openssl pkcs12 -passin pass:qwerty -passout pass:qwerty -in client.pfx -out client.pem

Diffie-Hellman key exchange

  • Create DH parameters
    1. openssl dhparam -out dh4096.pem 4096