C# - Websocket - Sending Message Back To Client

@vtortola Thank you for posting the links and explanation - I spent a bunch of time studying that and an open source code base (to write my own essentially) and I distilled it down to this for sending a message from the server to the client.

The key, for me, was realizing a couple of things:

First, understand the header. GetHeader() takes care of whether or not its the final frame and whether or not the opcode is set to text of continuation frame. The link @vtortola posted explains it, but I had to really stare at it before I saw the bits:

This post actually explains it decently, but you have to take time and study it - take note of how the FIN and opcode bits match GetHeader()'s job:

• Client: FIN=1, opcode=0x1, msg="hello" <-- this is a single message, length <= 125
• Server: (process complete message immediately) Hi.
• Client: FIN=0, opcode=0x1, msg="and a" <-- begin multi-frame message, length > 125
• Server: (listening, new message containing text started)
• Client: FIN=0, opcode=0x0, msg="happy new" <-- continue multi-frame message
• Server: (listening, payload concatenated to previous message)
• Client: FIN=1, opcode=0x0, msg="year!" <-- end multi-frame message
• Server: (process complete message) Happy new year to you too!

Next, understand what you're sending when you call stream.Write() - bytes[], index, LENGTH OF BYTES YOU'RE SENDING ;)

NOTE: My intent was to send JSON formatted strings to and from the web client, so my opcode is set for text (and my example here is based on the assumption you're wanting to send string data), but you can send other types as well.

SendMessageToClient() basically splits the message into 125 chunks and creates a que to be pulled from. Based on where we're at in the que, the header is created with the proper flags for FIN and opcode. Finally, with the header ready, backfill the rest of the header with the actual length of the chunk of string (<= 125). Then write the header to the stream after converting it to a byte array.

At this point, your header is created properly (FIN, rsv1,2,3 set properly, opcode and mask as well as the size of the payload). Now send it.

public void SendMessageToClient(TcpClient client, string msg)
{
    NetworkStream stream = client.GetStream();
    Queue<string> que = new Queue<string>(msg.SplitInGroups(125));
    int len = que.Count;

    while (que.Count > 0)
    {
        var header = GetHeader(
            que.Count > 1 ? false : true,
            que.Count == len ? false : true
        );

        byte[] list = Encoding.UTF8.GetBytes(que.Dequeue());
        header = (header << 7) + list.Length;
        stream.Write(IntToByteArray((ushort)header), 0, 2);
        stream.Write(list, 0, list.Length);
    }            
}


protected int GetHeader(bool finalFrame, bool contFrame)
{
    int header = finalFrame ? 1 : 0;//fin: 0 = more frames, 1 = final frame
    header = (header << 1) + 0;//rsv1
    header = (header << 1) + 0;//rsv2
    header = (header << 1) + 0;//rsv3
    header = (header << 4) + (contFrame ? 0 : 1);//opcode : 0 = continuation frame, 1 = text
    header = (header << 1) + 0;//mask: server -> client = no mask

    return header;
}


protected byte[] IntToByteArray(ushort value)
{
    var ary = BitConverter.GetBytes(value);
    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(ary);
    }

    return ary;
}

/// ================= [ extension class ]==============>

public static class XLExtensions
{
    public static IEnumerable<string> SplitInGroups(this string original, int size)
    {
        var p = 0;
        var l = original.Length;
        while (l - p > size)
        {
            yield return original.Substring(p, size);
            p += size;
        }
        yield return original.Substring(p);
    }
}

Along with the post above, I studied websocket-sharp's code base. I literally wanted to learn how to do this and write my own server/client and was able to do so studying that code base as well as a great starting point here for creating a basic c# WebSocket server.

Finally, I thank God for the patience to read through all of this ;)

Here is how to encode the message for length < 125 AND for 126 and less then 65535, Just pass the string to the method, and it will return array of byte[]:

    private byte[] encodeMessage(string msg)
    {
        int msgLength = msg.Length;
        byte[] msgEncoded = new byte[msgLength + 5];
        int indexAt = 0;

        msgEncoded[0] = 0x81;
        indexAt++;

        if (msgLength <= 125)
        {
            msgEncoded[1] = (byte)msgLength;
            indexAt++;
        } else if (msgLength >= 126 && msgLength <= 65535)
        {
            msgEncoded[1] = 126;
            msgEncoded[2] = (byte)((byte)msgLength >> 8);
            msgEncoded[3] = (byte)msgLength;
            indexAt += 3;
        }

        for (int i = 0; i < msgLength; i++)
        {
            msgEncoded[indexAt + i] = (byte)msg[i];
        }
        return msgEncoded;
    }