Ensuring the client is connected and KeepAliveInterval

[NickThissen]

Hello,

I'm using your websocket implementation for a very simple messaging bus between two applications running on the same computer. The server application simply listens for a message, and one or more clients can connect to send messages. Both the server and client applications can stop and start "at will", so I have to handle the cases where e.g. the server keeps running but the client stops and starts, or vice versa the client keeps running but the server application stops and later starts again.

Right now I implemented the following logic which seems to work well:

• Whenever the client application is instructed to send a message, it first checks if the WatsonWsClient is initialized and connected. If not initialized yet, I create a new instance and start it. If already connected, I just continue.
• When the client detects the server disconnected (ServerDisconnected event), I stop the client and dispose it, and set it back to null. The next time the application is instructed to send a new message, the client is null so a new instance is created.

Question 1: Is this a reasonable approach? I am not worried about performance, the messages are not sending multiple times per second, it's just an occassional single message and it does not matter if there is even half a second delay before it reaches the server.

Question 2: How does the client KeepAliveInterval come into this? I set it to 10 seconds and I was expecting the client to disconnect itself after no activity for 10 seconds, after which I should also make sure the client is disposed properly and re-created next time. However, nothing seems to happen at all. What does KeepAliveInterval actually do?

Thanks!

For some details, before every "send message" I ensure the connection is available like this:

        private async Task<bool> EnsureConnection()
        {
            // First connection?
            if (_client == null)
            {
                Debug.WriteLine("Client was null, creating new client.");
                CreateClient();
            }
            if (_client == null)
            {
                Debug.WriteLine("Client was still null, stopping.");
                return false;
            }

            // Check if connected
            if (_client.Connected)
            {
                Debug.WriteLine("Client already connected: OK.");
                return true;
            }
               
            // Connect
            Debug.WriteLine("Client not yet connected, try starting.");
            await _client.StartWithTimeoutAsync(1);
            return _client.Connected;
        }

[jchristn]

Hi @NickThissen thanks for your note.

Nothing wrong at all with the way you've written the code for question #1.

On your second question re: KeepAliveInterval, this is a property that merely passes through to the underlying operating system TCP keepalive capabilities. In general, I don't advise using them, because their operation is fairly opaque and most people have mixed results. IMO they really only solve one specific use case: detecting a disconnection due to a cable being unplugged or an adapter suddenly going offline. If your message frequency is low, I wouldn't bother with keepalives.