zeromq / netmq

A 100% native C# implementation of ZeroMQ for .NET

NetMQ is a 100% native C# port of the lightweight messaging library ZeroMQ.

NetMQ extends the standard socket interfaces with features traditionally provided by specialised messaging middleware products. NetMQ sockets provide an abstraction of asynchronous message queues, multiple messaging patterns, message filtering (subscriptions), seamless access to multiple transport protocols, and more.

Installation

You can download NetMQ via NuGet.

Versions

Currently two versions are maintained Version 3 which is the stable version of NetMQ and version 4, version 4 is same as version 3 without obsolete code. You can find both version on Nuget, for more information read the Migrating-to-v4.

This repository is for version 4, for version 3 go to: https://github.com/NetMQ/NetMQ3-x.

Using / Documentation

Before using NetMQ, make sure to read the ZeroMQ Guide.

The NetMQ documentation can be found at netmq.readthedocs.org. Thanks to Sacha Barber who agreed to do the documentation.

You can find NetMQ samples contributed by various users here: https://github.com/NetMQ/Samples

There are also a few blog posts available, which you can read about here:

• Somdoron's blog
• Hello World
• The Socket Types
• Socket Options/Identity and SendMore
• Multiple Socket Polling
• Sending From Multiple Sockets
• Divide And Conquer

Here is a simple example:

using (var server = new ResponseSocket("@tcp://localhost:5556")) // bind
using (var client = new RequestSocket(">tcp://localhost:5556"))  // connect
{
    // Send a message from the client socket
    client.SendFrame("Hello");

    // Receive the message from the server socket
    string m1 = server.ReceiveFrameString();
    Console.WriteLine("From Client: {0}", m1);

    // Send a response back from the server
    server.SendFrame("Hi Back");

    // Receive the response from the client socket
    string m2 = client.ReceiveFrameString();
    Console.WriteLine("From Server: {0}", m2);
}

Contributing

We need help, so if you have good knowledge of C# and ZeroMQ just grab one of the issues and add a pull request. We are using C4.1 process, so make sure you read this before.

Regarding coding standards, we are using C# coding styles, to be a little more specific: we are using camelCase for variables and fields (with m_ prefix for instance members and s_ for static fields) and PascalCase for methods, classes and constants. Make sure you are using 'Insert Spaces' and 4 for tab and indent size.

You can also help us by:

• Joining our mailing list and be an active member
• Writing tutorials in the github wiki
• Writing about the project in your blog (and add a pull request with a link to your blog at the bottom of this page)

Consulting and Support

Name	Email	Website	Info
Doron Somech	[email protected]	http://somdoron.com	Founder and maintainer of NetMQ, expertise in Fintech and high performance scalable systems.

If you are providing support and consulting for NetMQ please make a pull request and add yourself to the list.

Important note on backward compatibility

Since version 3.3.07 NetMQ changed the number serialization from Little Endian to Big Endian to be compatible with ZeroMQ. Any NetMQ version prior to 3.3.0.7 is not compatible with the new version. To support older versions you can set Endian option on a NetMQ socket to Little Endian, however doing so will make it incompatible with ZeroMQ.

We recommend to update to the latest version and use Big Endian which is now the default behavior.

Mailing list

You can join our mailing list here.

Who owns NetMQ?

NetMQ is owned by all its authors and contributors. This is an open source project licensed under the LGPLv3. To contribute to NetMQ please read the C4.1 process, it's what we use. There are open issues in the issues tab that still need to be taken care of, feel free to pick one up and submit a patch to the project.

Build Server

YouTrack by JetBrains - keyboard-centric bug tracker

netmq's Issues

Add remove to the high level poller

remove current pinvoke method and replace with .net native

there around 8 calls to pinvoke, most of them can be replaced and some of them can be removed because it's not important enough.

NetMQ.zmq.Utils.Realloc broken!

The method NetMQ.zmq.Utils.Realloc() uses Buffer.BlockCopy, which is invalid if the type of the array is not a primitive type. This throws an unhandled exception in NetMQ.zmq.Trie.realloc() when it is called in NetMQ.zmq.Trie.Add. This prevents subscription sockets from working. See Buffer.BlockCopy documentation here: http://msdn.microsoft.com/en-us/library/system.buffer.blockcopy.aspx

Add timer feature to the high level poller

PGM

pgm is still not supported, there are actually two ways to implement that, microsoft implement pgm as part of msmq. we can also use the original openpgm that zeromq is using and that way it will compatible with zeromq pgm.

you can check out at this project how to use pgm with .net
http://code.google.com/p/emcaster/

IPv6

IPv6 is not tested and there are probably some bugs...

What is the purpose of Thread.Sleep within ZMQ.Poll ?

In module ZMQ.cs, method Poll(PollItem[], int, int), I'm a bit confused by the purpose of Thread.Sleep here, as it would seem to accomplish nothing other than to delay the method from returning. Below is the code..

    public static int Poll(PollItem[] items, int itemsCount, int timeout)
    {
        if (items == null)
        {
            throw NetMQException.Create(ErrorCode.EFAULT);
        }
        if (itemsCount == 0)
        {
            if (timeout <= 0)
                return 0;
            // What's this?
            Thread.Sleep(timeout);
            return 0;
        }

I'm tinkering with the code trying to see how hard it would be to make it work with the version of .NET provided with Windows Store apps, and Sleep is a not available. The solution generally is to use ThreadPoolTimer, but this wouldn't seem to be needed here. Does anyone know -- is it necessary to have it wait for the timeout period, even if itemsCount is zero?

Btw, does anyone share my disappointment with how much the API is changed or limited compared to regular .NET ? I wonder - how much demand is there for compatibility with Windows Store and Windows Phone 8 ? This is clearly a substantial amount of work.

Please sign the NetMQ.dll with a Strong Name

Please sign the NetMQ.dll with a Strong Name. I'm downloading it via NuGet.

Can Poller implements interface IDispose?

IMHO, class Poller should implements interface IDispose like clrzmq did.

A class that implemented interface IDispose is a convenience way to stop the internal running loop automatically when it gets disposed.

Queueing examples

Are there any examples of publisher sockets publishing and then a subscriber connecting after a delay and then dequeuing those messages. I tried setting pubSocket.Options.SendBuffer but the messages are lost.

What am I missing?

Port test from original project

i think it will best to use nunit.

NetMQMonitor sample

I suppose this class is responsible for socket_connected, socket_disconnected, v.s. events. Is there any sample code about how to use this in a PUB/SUB model? (I'm looking for subscriber connected, disconnected events)

io completion ports - open discussion

a discussion about how to implement io completion ports.

in my opinion there are 3 ways to implement the io completion ports, each one with cons and pros:

1. not using dedicated thread to zeromq, all the poller work will be done on the callback (completed events) which is a thread pool thread. this solution is pure .net, the disadvantage is that because this is done on multiple threads and each operation can happen on different thread we have to do some synchronization on shared resource (like the list of fds).
2. dedicated thread with queue (or ring buffer), the completed events will just queue the result to the queue and thread will take care of calling the inevent and outevent methods. advantage - very similar to current implantation of zeromq and no synchronization needed. disadvantage - queue can be slow, ring buffer is expensive in cpu (if you using busy wait or spin wait), higher latency if there no messages for long time.
3. using native io completion ports, probably best in performance, no synchronization. similar to the current implementation of zeromq. disadvantage - alot of pinvoke and not friendly to mono.

what is your opinion?

Req to Router Bug

ReceiveMessage on Router throws an exception.

Received messages via push/pull are empty

Bug

Received messages via push/pull are empty. Both the Size property as well as the length of the Data byte[] property are 0.

Steps to reproduce

• get the performance test from #24
• compile the solution
• run the following: local_thr.exe tcp://127.0.0.1:4711 300 1000
• run the following: remote_thr.exe tcp://127.0.0.1:4711 300 1000

NetMQScheduler

I will be very nice to have scheduler which schedule tasks on NetMQ inproc socket.

Instead of creating inproc protocol to communicate between threads we would be able to run methods on the inproc socket just like TPL does.

Calling NetMQ.Proxy.Start() will throw a NullReferenceException

NetMQ.Proxy can't be started at all because ZMQ.Poll throws a null ref when called with an infinite timeout. The null ref is on the stopwatch which is used to compute the current timeout but it was never instanciated in this case.

StackTrace:

   at NetMQ.zmq.ZMQ.Poll(PollItem[] items, Int32 itemsCount, Int32 timeout) in d:\repo\netmq\src\NetMQ\zmq\ZMQ.cs:line 472
   at NetMQ.zmq.ZMQ.Poll(PollItem[] items, Int32 timeout) in d:\repo\netmq\src\NetMQ\zmq\ZMQ.cs:line 402
   at NetMQ.zmq.Proxy.CreateProxy(SocketBase frontend, SocketBase backend, SocketBase capture) in d:\repo\netmq\src\NetMQ\zmq\Proxy.cs:line 46
   at NetMQ.zmq.ZMQ.Proxy(SocketBase frontend_, SocketBase backend_, SocketBase control_) in d:\repo\netmq\src\NetMQ\zmq\ZMQ.cs:line 387
   at NetMQ.Proxy.Start() in d:\repo\netmq\src\NetMQ\Proxy.cs:line 30
   at System.Threading.Tasks.Task.InnerInvoke()
   at System.Threading.Tasks.Task.Execute()

High level implementation - open discussion

• Implement all sockets type
• Document the methods
• Poller - Poller will be able to listen for messages, handle proxies and raise montirong event on a thread
• MonitoringSocket
• Proxy
• Devices

Make the API unit-test friendly

In order to allow unit test the code that uses ZeroMQ the interfaces for key classes (context, socket) should be defined, so that client code could use the functionality using interface references only.

ZeroMQ 3.2.3, ZMTP 3.0 and Stable version

It's more of a discussion then an issue...

Recently new version of zeromq was released, the version (3.2.3) contains only bug fixes, do you think we should go over all the relevant commits on the 3.2.3 version and add them as issues to netmq tracker?

Do you think the current trunk is stable? at my work we are using NetMQ but not yet in production...

ZeroMQ is going towards ZMTP 3.0 with some exciting features like encryption, authentication and resource sharing... what are your thoughts? when should we start importing those features?

Socket Identity not honored when using InProc

I've not tested this thoroughly just yet, but it seams that when using the InProc transport, the connecting socket's identity is ignored for Router sockets.

Both setting the identity before or after connecting exhibits the same behavior.

Call for maintainers

If you'd like to help click that lovely green "Merge Pull Request" button, and get eternal karma, add a comment confirming that you've read and understand the C4 process at http://rfc.zeromq.org/spec:16.

Proxy from original project is not yet implemented

it's actually mark as not compile in the current solution.

it's also need to be ported from the original project.

Socket classes need Subscribe/Unsubscribe methods, but they throw an exception

For example, watching the ResponseSocket class.
This class needs to override Subscribe/Unsubscribe methods. These features are for Subscriber sockets and not for every kind of socket, are you agree?
So could be better not implement these methods only to throw an exception.

Error handling - request for opinion

I would like to hear your opinion, should we use the same error handling as the original project (error codes) or throw exceptions every time the original code set an error code. their are pros and cons to both ways.

Error code - easier to port code from the original code.
Exceptions - the native .net way.

What do you think we should do?

Code Comments

For public methods/properties/events we should resort to the .net documenting convention of :

///

/// The comment
///

/// Use for something
/// The return is blah

Private methods don't need to be documented this way. Private fields/properties/events can be commented as with simple comments.

Just a suggestion.

Thoughts?

Proxy throws when Context is disposed

NetMQ.Proxy cannot exit cleanly when the Context is disposed because its sockets wil throw TerminatingExceptions. It can be seen by running the unit test TestProxySendAndReceive under the debugger.

Too many exceptions being thrown in FQ::RecvPipe

        //  No message is available. Initialise the output parameter
        //  to be a 0-byte message.
        throw AgainException.Create();

The sole purpose seems to be: (Router::XHasIn())

        try
        {
            m_prefetchedMsg = m_fq.RecvPipe(pipe);
        }
        catch (NetMQException ex)
        {
            return false;
        }

used in Router.cs. Won't it be faster/cheaper to just return -1 (or some other predefined constant to indicate false?

https://github.com/zeromq/libzmq/blob/master/src/fq.cpp
https://github.com/zeromq/libzmq/blob/master/src/router.cpp

Closing the socket and terminating the Context blocks indefinitely

Context

I was playing with the ConsoleApplication1 and notices that neither the context nor the sockets are properly closed/disposed.

Knowing the strange closing semantics and pedantic behavior of the original libzmq terminate, I tried out properly closing a socket and the context.

Bug

Closing the sockets and terminating the context doesn't work - it blocks indefinitely (even after setting the linger option).

Steps to reproduce

• create a Context
• create a Socket
• use the socket
• call Close on the socket
• call Terminate on the context

Final thought

I don't think that the closing semantics of the zeromq are that good. Actually I find they are pretty bad, resulting in complicated posts like this: http://www.zeromq.org/whitepapers:0mq-termination and some stackoverflow questions on the topic.

I think, taking advantage of .Net's IDisposable pattern can solve some of the issues and feels more natural for developers.

Test the library with libzmq v3.2

Can this be made to build/operate with a Windows Store app?

I see that there is a lot of incompatibilities within this code, with the API that's available for a Windows Store app, or to take advantage of the Windows 8 / Server 2012 platforms. Is this something that anyone has plans to tend to, or does anyone else have an immediate need to use NetMQ on this platform? Or, is there any specific reason that it would not be appropo for the Win8 or WinRT platform?

Create lazy ReceiveAll implementation

Current ReceiveAll and ReceiveAllString methods receive all messages before returning control to caller.

In order to receive all messages in a lazy manner I suggest to define the IEnumerable<byte[]> ReceiveMessages(this NetMQSocket socket) extension method for NetMQSocket class (or something like IReceiveSocket interface if #63 is taken into account) that does yield return for each message received.

Additionally we should define IEnumerable<string> ReceiveStringMessages(this NetMQSocket socket) to encapsulate conversion to string.

Existing IList<byte[]> ReceiveAll() and IList<string> ReceiveAllString() can be refactored as (obsolete) extension methods that use new ReceiveMessages and ReceiveStringMessages like this:

[Obsolete]
public static IList<byte[]> ReceiveAll(this NetMQSocket socket)
{
    return socket.ReceiveMessages().ToList();
}
[Obsolete]
public static IList<string> ReceiveAllString(this NetMQSocket socket)
{
    return socket.ReceiveStringMessages().ToList();
}

NuGet packages

This project should be available on NuGet once it is close to being releasable. There will probably be at least two packages:

• netmq (core project)
• netmq.clrzmq (clrzmq compatibility layer)

More might come up as the solution progresses.

PGM Tests not always passing

I noticed the followings while trying to reproduce some strange behaviours:

• The tests involving PGM Sockets only work when the VisualStudio (or the NunitTestrunner) has administrator rights.
• The test Sending1000Messages takes forever and won't finish. A background worker sits waiting on the NetMQ.zmq.Signaler.WaitEvent(int timeout) method while 998 messages have been sent. Specifically the thread waits on (return m_r.Poll(timeout * 1000, SelectMode.SelectRead);. timeout variable has a value of -1.

I will try to find out more but I am also curious if it is only happening on my machine.

Interoperability: Exception in PollerBase.ExecuteTimers upon message reception

Context

After implementing the performance tests, I was curious how big the latency of netmq is compared to that of the original libzmq (actually, not bad).
After playing around with the original performance tests of zeromq 2.2.0 (downloaded from http://www.zeromq.org/distro:microsoft-windows).

I tried to run the local_lat.exe from zeromq and the remote_lat.exe from netmq and discovered that the implementations do not work together.

Bug

Running the local_lat.exe of zeromq (2.2.0) and remote_lat.exe from netmq results in the following exception on the remote_lat.exe:

Unhandled Exception: System.InvalidOperationException: Collection was modified after the enumerator was instantiated.   at System.Collections.Generic.SortedList`2.SortedListKeyEnumerator.MoveNext()   at NetMQ.zmq.PollerBase.ExecuteTimers() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\PollerBase.cs:line 136   at NetMQ.zmq.Poller.Loop() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\Poller.cs:line 162   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)   at System.Threading.ThreadHelper.ThreadStart()

Steps to reproduce

• compile netmq
• download and install zeromq 2.2.0
• run local_lat.exe from zeromq (e.g.: local_lat.exe tcp://127.0.0.1:5656 10 100)
• run remote_lat.exe from netmq (e.g.: remote_lat.exe tcp://127.0.0.1:5656 10 100)

The number of messages and size of the message doesn't matter: It seems that as soon as the local_lat responds to the received Message the remote_lat receives something and throws the exception.

Missing interfaces

U are using ReSharper... So maybe u could refactor some classes and extract some interfaces to be able to simplify writing unit tests using a mocking framework instead of always writing integration tests.

Really cool would be all classes which are using private constructors only (like the NetMQContext class).

Temporarily i am using adapters realizing fake interfaces to solve that problem... But please...

Thx & Greetz
Matthias Geller

Create new samples according to ZeroMQ guide

Reading the ZeroMQ guide, many topics have examples of code implemented using clrzmq and someone hasn't a C# implementation.

PowerCollections Removal

I'm not quite sure why the project is using PowerCollections. There are two classes used from this assembly: Deque and MultiDictionary<Key, Value>.

Couldn't we replace these with simply Stack to replace Deque and a Lookup<TKey, TElement> for MultiDictionary<Key, Value>. I believe they provide exactly the same functionalities as those provided by PowerCollections.

Thoughts?

Binding a Subscriber socket will not receive from connecting Publishers

Here is a simple test case to reproduce the issue. I've tried many combinations of sleep before connecting, binding etc, like:

• bind, sleep, subscribe, sleep, connect
• bind, subscribe, sleep, connect
• subscribe, bind, sleep, connect
  and no combination seams to work.

[Test]
        public void BindingSubscribeSocketsFails() {
            using (NetMQContext contex = NetMQContext.Create()) {
                var sub = contex.CreateSubscriberSocket();
                sub.Bind("tcp://127.0.0.1:5002");

                using (var pub = contex.CreatePublisherSocket()) {
                    pub.Connect("tcp://127.0.0.1:5002");
                    pub.Options.DelayAttachOnConnect = false;

                    // let the subscrbier connect to the publisher before sending a message
                    Thread.Sleep(500);
                    sub.Subscribe("");
                    Thread.Sleep(500);

                    pub.Send("Hello");

                    bool more;

                    string m = sub.ReceiveString(out more);

                    Assert.AreEqual("Hello", m);
                    Assert.False(more);
                }

                sub.Dispose();
            }
        }

.NET 3.5 compatibility

I write games using Unity 3D.

Unity 3D uses mono to run managed code, while the engine itself is written in another language.
This means all extra programming happens using mono. Unfortunatly, it's a rather outdated version of mono that doesn't have any of the features of .NET 4.0.

NetMQ refuses to run on it, is it possible to fix this ?

(I could possibly do this myself with some guidance on how to do this)

System.IndexOutOfRangeException using Push sockets

Context:

I tried porting the libzmq performance tests since the netmq readme (https://github.com/zeromq/netmq#netmq) suggested these are missing and I were curious and wanted to help you guys).

I created the throughput test along the lines to the original libzmq version. If you want I can create a pull request from that commit: https://github.com/tobi-tobsen/netmq/tree/perf_throughput

Bug:

When running the tests I getting the following exception on the push-side (remote_thr):

Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.   at NetMQ.zmq.ByteArraySegment.set_Item(Int32 i, Byte value) in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\ByteArraySegment.cs:line 110   at NetMQ.zmq.V1Encoder.MessageReady() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\V1Encoder.cs:line 83   at NetMQ.zmq.V1Encoder.Next() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\V1Encoder.cs:line 36   at NetMQ.zmq.EncoderBase.GetData(ByteArraySegment& data, Int32& size) in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\EncoderBase.cs:line 87   at NetMQ.zmq.StreamEngine.OutEvent() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\StreamEngine.cs:line 267   at NetMQ.zmq.IOObject.OutEvent() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\IOObject.cs:line 96   at NetMQ.zmq.Poller.Loop() in C:\Users\tobsen\Documents\GitHub\netmq\src\NetMQ\zmq\Poller.cs:line 195   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)   at System.Threading.ThreadHelper.ThreadStart()

Steps to reproduce:

• get tobi-tobsen@6fef662
• compile the solution
• run the following: local_thr.exe tcp://127.0.0.1:4711 300 1000
• run the following: remote_thr.exe tcp://127.0.0.1:4711 300 1000

License problem

Hey guys,

Your choice of the LGPLv3 means that the code can not be used on embedded environments like iOS, PlayStation Mobile or systems like the Xbox or PS3 due to the LGPL incompatibility with the terms imposed by the various walled-garden agreements (perhaps even Android, but I have not read those terms in detail).

In an ideal world, you could use the Apache2 or MIT X11 license for the code, which would allow the code to be used on those environments (Mono's class libraries were originally MIT X11, we incorporated MS-PL (which is basically Apache2) and later switched new work to Apache2.

If you are not willing to make that change for general distribution, you might want to consider giving rights to someone in the team to be able to relicense this for proprietary use on those platforms, so that if in the future a really strong need emerges for you guys to support a given platform, you have the choice to do it.

This could even be the beginning of dual-licensing the code. While I can not guarantee that it will be a booming business, it is an option to keep around.

Miguel

Remove the (out bool more) from all receive methods and use More property on the socket?

I have to admin that it is very annoying, i want to remove it from all receive methods and move the property to the options class.

what do you think?

change the zmq project to NetMQ.zmq

thoughts?

Also all the classes should be internal on the project except the ZMQ static class, SocketBase and the enums.

Reduce the number of overloads on IOutgoingSocket and NetMQSocket

The IOutgoingSocket interface and NetMQSocket class will be much cleaner if they contain the most functional method declarations only.

I suggest to move most of the overloaded methods on NetMQSocket class to a separate extension methods class, leaving the following ones:

• void Send(byte[] data, int length, SendReceiveOptions options) (all SendMore and SendMessage methods can be declared as extension methods)
• byte[] Receive(SendReceiveOptions options, out bool hasMore) (all ReceiveString overloads can be declared as extension methods)
• void Monitor(string endpoint, SocketEvent events) (Monitor(string endpoint) to be moved as extension method)

This change does not require changes to the application code that uses the library, but will require recompilation of it.

I'll create a pull request if this suggestion is accepted

support clrzmq api

it will be easier to transition to netmq if the project support the current clrzmq api

Spelling issues in the readme.md

Although I am also not a native speaker, I stumbled upon some minor spelling mistakes and I tried to improve the readme.

Maybe some native speaker can even improve it further. I think this is important to get right since it is the front page of the project.

Will attach pull request in a minute...

Collection was modified; in pollerbase

in pollerbase line 147 removing timer element while iterating the timers.

reproduce: try to run the remote_thr without the local_thr.

Unhandled Exception: System.InvalidOperationException: Collection was modified;
enumeration operation may not execute.
at System.ThrowHelper.ThrowInvalidOperationException(ExceptionResource resour
ce)
at System.Collections.Generic.List1.Enumerator.MoveNextRare() at System.Collections.Generic.List1.Enumerator.MoveNext()
at NetMQ.zmq.PollerBase.ExecuteTimers() in C:\netmq\src\NetMQ\zmq\PollerBase.
cs:line 144
at NetMQ.zmq.Poller.Loop() in C:\netmq\src\NetMQ\zmq\Poller.cs:line 162
at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, C
ontextCallback callback, Object state, Boolean ignoreSyncCtx)
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, C
ontextCallback callback, Object state)
at System.Threading.ThreadHelper.ThreadStart()

TCP Keep alive

the tcp keep alive is still not developed and it's support on windows.

Support mono

if you have experience with mono and want to make the project support mono you are more than welcome.