SimpleTcp provides simple methods for creating your own TCP-based sockets application, enabling easy integration of connection management, sending, and receiving data.

• If you need integrated framing, please use WatsonTcp (https://github.com/jchristn/WatsonTcp)
• If you need discrete control over the number of bytes read from or written to a socket, please use CavemanTcp (https://github.com/jchristn/CavemanTcp)

• Breaking changes
• Retarget to include .NET Core (includes previous targeting to .NET Standard and .NET Framework)
• Consolidated settings and event classes
• Added support for TCP keepalives

Need help or have feedback? Please file an issue here!

using SimpleTcp;

void Main(string[] args)
{
	// instantiate
	SimpleTcpServer server = new TcpServer("127.0.0.1", 9000, false, null, null);

	// set events
	server.Events.ClientConnected += ClientConnected;
	server.Events.ClientDisconnected += ClientDisconnected;
	server.Events.DataReceived += DataReceived;

	// let's go!
	server.Start();

	// once a client has connected...
	server.Send("[ClientIp:Port]", Encoding.UTF8.GetString("Hello, world!"));
	Console.ReadKey();
}

static void ClientConnected(object sender, ClientConnectedEventArgs e)
{
    Console.WriteLine("[" + e.IpPort + "] client connected");
}

static void ClientDisconnected(object sender, ClientDisconnectedEventArgs e)
{
    Console.WriteLine("[" + e.IpPort + "] client disconnected: " + e.Reason.ToString());
}

static void DataReceived(object sender, DataReceivedFromClientEventArgs e)
{
    Console.WriteLine("[" + e.IpPort + "]: " + Encoding.UTF8.GetString(e.Data));
}

using SimpleTcp;

void Main(string[] args)
{
	// instantiate
	SimpleTcpClient client = new TcpClient("127.0.0.1", 9000, false, null, null);

	// set events
	client.Events.Connected += Connected;
	client.Events.Disconnected += Disconnected;
	client.Events.DataReceived += DataReceived;

	// let's go!
	client.Connect();

	// once connected to the server...
	client.Send(Encoding.UTF8.GetBytes("Hello, world!"));
	Console.ReadKey();
}

static void Connected(object sender, EventArgs e)
{
    Console.WriteLine("*** Server connected");
}

static void Disconnected(object sender, EventArgs e)
{
    Console.WriteLine("*** Server disconnected"); 
}

static void DataReceived(object sender, DataReceivedFromServerEventArgs e)
{
    Console.WriteLine("[" + _ServerIp + ":" + _ServerPort + "] " + Encoding.UTF8.GetString(e.Data));
}

Both TcpClient and TcpServer have settable values for:

• Logger - method to invoke to send log messages from either TcpClient or TcpServer
• Settings.MutuallyAuthenticate - only used if SSL is enabled, demands that both client and server mutually authenticate
• Settings.AcceptInvalidCertificates - accept and allow certificates that are invalid or cannot be validated

TcpServer also has:

• Settings.IdleClientTimeoutSeconds - automatically disconnect a client if data is not received within the specified number of seconds

Additionally, both TcpClient and TcpServer offer a statistics object under SimpleTcpClient.Statistics and SimpleTcpServer.Statistics. These values (other than start time and uptime) can be reset using the Statistics.Reset() API.

A certificate named simpletcp.pfx is provided for simple testing. It should not expire for a really long time. It's a self-signed certificate and you should NOT use it in production. Its export password is simpletcp.

The project TcpTest (https://github.com/jchristn/TcpTest) was built specifically to provide a reference for SimpleTcp to handle a variety of disconnection scenarios. The disconnection tests for which SimpleTcp is evaluated include:

Additionally, as of v2.1.0, support for TCP keepalives has been added to SimpleTcp, primarily to address the issue of a network interface being shut down, the cable unplugged, or the media otherwise becoming unavailable. It is important to note that keepalives are supported in .NET Core and .NET Framework, but NOT .NET Standard. As of this release, .NET Standard provides no facilities for TCP keepalives.

TCP keepalives are enabled by default.

server.Keepalive.EnableTcpKeepAlives = true;
server.Keepalive.TcpKeepAliveInterval = 5;      // seconds to wait before sending subsequent keepalive
server.Keepalive.TcpKeepAliveTime = 5;          // seconds to wait before sending a keepalive
server.Keepalive.TcpKeepAliveRetryCount = 5;    // number of failed keepalive probes before terminating connection

Some important notes about TCP keepalives:

• Keepalives only work in .NET Core and .NET Framework
• Keepalives can be enabled on either client or server, but generally only work on server (being investigated)
• Keepalive.TcpKeepAliveRetryCount is only applicable to .NET Core; for .NET Framework, this value is forced to 10

.NET Core is the preferred environment for cross-platform deployment on Windows, Linux, and Mac. For those that use Mono, SimpleTcp should work well in Mono environments. It is recommended that you execute the containing EXE using --server and after using the Mono Ahead-of-Time Compiler (AOT).

mono --aot=nrgctx-trampolines=8096,nimt-trampolines=8096,ntrampolines=4048 --server myapp.exe
mono --server myapp.exe

Please refer to CHANGELOG.md.