BinaryTextEncoding Class

public abstract class BinaryTextEncoding

// These first two examples show how to read/write variable-length strings to/from a packet.
public void VariableLengthStrings(IDataReader receivedPacket, IDataWriter packetToSend) {
    // Reads all the bytes in 'receivedPacket' and converts it all into an ASCII string.
    var str = receivedPacket.ReadString(BinaryTextEncoding.FixedLengthASCII);

    // Writes the string "hello" into a packet ready to be sent to the peer.
    packetToSend.WriteString("hello", BinaryTextEncoding.FixedLengthASCII);
}

// Sometimes there's more data in a packet than just one string.  In which case, it may be
// necessary to specify exactly how long the string is that we're expecting to read.
public void FixedLengthStrings(IDataReader receivedPacket, ushort lengthOfString) {
    // Reads 'lengthOfString' bytes of data from 'receivedPacket' and then interprets them as Unicode (UTF-16).
    var str = receivedPacket.ReadString(BinaryTextEncoding.FixedLength(System.Text.Encoding.Unicode, lengthOfString));
}

public void NullTerminatedStrings(IDataReader receivedPacket, IDataWriter packetToSend) {
    // Reads bytes of data from 'receivedPacket' as an ASCII string until it reads the 'null' character.
    var str = receivedPacket.ReadString(BinaryTextEncoding.NullTerminatedASCII);

    // Writes the string "hello" into a packet as Unicode characters ready to be sent to the peer,
    // finishing it with a 'null' character.
    packetToSend.WriteString("hello", BinaryTextEncoding.NullTerminatedUnicode);
}

public void LengthEncodedStrings(IDataReader receivedPacket, IDataWriter packetToSend) {
    // Length encoded strings are prefixed with a binary number that states exactly how many
    // bytes belong to the string.  Most commonly, the number is itself 2-bytes (a 16-bit number),
    // and that number is itself encoded using the Big Endian format.
    var str = receivedPacket.ReadString(BinaryTextEncoding.LengthEncodedASCII2BE);

    // This example uses a 4-byte (32-bits) Little Endian number to describe the number of bytes
    // in the string.  The string is then interpretted as Unicode.
    str = receivedPacket.ReadString(BinaryTextEncoding.LengthEncoded(4, true, System.Text.Encoding.Unicode));

    // Writes the string "hello" into a packet ready to be sent to the peer.  The string is prepended with
    // two bytes 0x00, 0x05 (the length of the string).
    packetToSend.WriteString("hello", BinaryTextEncoding.LengthEncodedASCII2BE);
}

public string StringDelimitedStrings(IDataReader receivedPacket) {
    // The string to be read will start with '<<' and end with '>>'.  The string returned will have the
    // quotes ('<<' and '>>') stripped off.  Just the original string between the quotes will be returned.
    return receivedPacket.ReadString(BinaryTextEncoding.StringDelimited("<<", ">>"));
}

public string PipeDelimitedStrings(IDataReader receivedPacket) {
    // The string is terminated with a '|' character.  Effectively the protocol uses strings separated with '|'.
    return receivedPacket.ReadString(BinaryTextEncoding.StringDelimited(null, "|"));
}

public void StxEtxDelimitedStrings(IDataReader receivedPacket, IDataWriter packetToSend) {
    // The standard STX ETX encapsulated format.
    var str = receivedPacket.ReadString(BinaryTextEncoding.StxEtx);

    // Writes the string "hello" prepended with the STX character and appended with the ETX character.
    packetToSend.WriteString("hello", BinaryTextEncoding.StxEtx);
}

using System;
using System.Threading.Tasks;
using Demo3D.IO;
using Demo3D.Native;
using Demo3D.Net;
using Demo3D.Net.Protocols;
using Demo3D.Visuals;

namespace Examples.Net.StringServerExample {
    [Auto] public class Server {
        [Auto] PrintDelegate            print;
        [Auto] SimplePropertyValue<int> tcpPort;                   // The port to run the server on.
        [Auto] TextVisual               StatusDisplay;             // Requires corresponding TextVisual child visual
        [Auto] TextVisual               MessageDisplay;            // Requires corresponding TextVisual child visual

        ProtocolSocket                 serverSocket;
        ServerClient<IPacketIOService> clientSocket;
        BinaryTextEncoding             stxEtx = BinaryTextEncoding.StringDelimited("\u0002", "\u0003");

        void HandleMessage(ServerClient<IPacketIOService> clientSocket, string message) {
            print("Server: Message received \"" + message + "\"");

            if (message == "ACK") {                                // One of our requests was acknowledged.
                return;
            }

            if (MessageDisplay != null) {
                MessageDisplay.Text = "Received: \"" + message + "\"";
            }

            if (message.StartsWith("Hello")) {                     // Raise the lift, and then return "ACK".
                // ... Raise the lift here...
                print("Server: Sending message \"ACK\"");
                var buffer = stxEtx.GetBytes("ACK");               // Encode with STX/ETX.
                clientSocket.IO.Write(buffer);
            }
        }

        void ReceiveMessage(ProtocolSocket socket, object service, NotifyDataChangedEventArgs e) {
            try {
                var    args    = (PacketChangedEventArgs)e;        // A TCP server uses PacketChangedEventArgs.
                var    message = args.GetData();                   // Read from the packet.
                string str     = stxEtx.GetString(message);        // Decode STX/ETX string.

                // Handle the message.
                HandleMessage(clientSocket, str);
            }
            catch (Exception x) {
                socket.Close(x);
            }
        }

        // Disconnect the client.
        void CloseClient() {
            if (clientSocket != null) {
                clientSocket.Close();
                clientSocket.IO.DataChanged -= ReceiveMessage;
                clientSocket = null;
            }
        }

        // Close the server.
        void CloseServer() {
            if (serverSocket != null) {
                serverSocket.Close();
                serverSocket = null;
            }
        }

        // Accecpt a new client connection.
        Task ServiceClient(ServerClient<IPacketIOService> connection) {
            CloseClient();                // Close any existing client connection (this example only allows one client at a time).
            clientSocket = connection;
            clientSocket.IO.DataChanged += ReceiveMessage;
            return Task.CompletedTask;
        }

        [Auto] void OnReset(Visual sender) {
            if (clientSocket != null || serverSocket != null) {
                print("Server: Closing connection and stopping server");
                CloseServer();
                CloseClient();
            }

            if (StatusDisplay != null) {
                StatusDisplay.Text           = "Status: Closed";
                StatusDisplay.Material.Color = System.Drawing.Color.Gray;
            }

            if (MessageDisplay != null) {
                MessageDisplay.Text = "Received: ";
            }
        }

        [Auto] void OnInitialize(Visual sender) {
            CloseServer();
            CloseClient();

            // Open a server on the configured tcpPort.
            serverSocket = TcpServer.Open(tcpPort, ServiceClient);

            if (StatusDisplay != null) {
                StatusDisplay.Text           = "Status: Connected Port " + tcpPort.ToString();
                StatusDisplay.Material.Color = System.Drawing.Color.Lime;
            }
        }
    }
}

using System;
using System.Collections;
using System.Threading.Tasks;
using Demo3D.IO;
using Demo3D.Native;
using Demo3D.Net;
using Demo3D.Net.Protocols;
using Demo3D.Visuals;

namespace Examples.Net.StringClientExample {
    [Auto] public class Client {
        [Auto] IBuilder                    app;
        [Auto] PrintDelegate               print;
        [Auto] SimplePropertyValue<string> tcpAddress;               // The hostname to connect to.
        [Auto] SimplePropertyValue<int>    tcpPort;                  // The port to connect to.
        [Auto] TextVisual                  StatusDisplay;            // Requires corresponding TextVisual child visual

        Client<IPacketIOService> tcpClient;
        BinaryTextEncoding       stxEtx = BinaryTextEncoding.StringDelimited("\u0002", "\u0003");

        async Task SendMessages() {
            // Send a message to the server once a second while the model is running.
            for (int msg = 0; app.Running; msg++) {
                var str = "Hello " + msg.ToString();
                print("Client: Sending message \"" + str + "\"");

                var bytes = stxEtx.GetBytes(str);                    // Encode with STX/ETX
                await tcpClient.IO.WriteAsync(bytes);

                // Wait one second.
                await Task.Delay(1000);
            }
        }

        void HandleMessage(Client<IPacketIOService> clientSocket, string message) {
            print("Client: Message received \"" + message + "\"");

            if (message == "ACK") {                                  // One of our requests was acknowledged.
                return;
            }
        }

        void ReceiveMessage(ProtocolSocket socket, object service, NotifyDataChangedEventArgs e) {
            try {
                var    args    = (PacketChangedEventArgs)e;          // A TCP server uses PacketChangedEventArgs.
                var    message = args.GetData();                     // Read from the packet.
                string str     = stxEtx.GetString(message);          // Decode STX/ETX string.

                // Handle the message.
                HandleMessage(tcpClient, str);
            }
            catch (Exception x) {
                socket.Close(x);
            }
        }

        void CloseConnection(Exception error = null) {
            if (tcpClient != null) {
                tcpClient.Close(error);
                tcpClient.IO.DataChanged -= ReceiveMessage;
                tcpClient = null;
            }
        }

        async Task Connect() {
            try {
                // Connect to the server using the configured tcpAddress and tcpPort.
                tcpClient = await TcpClient.OpenAsync(sync: false, tcpAddress, tcpPort);
                tcpClient.IO.DataChanged += ReceiveMessage;

                if (StatusDisplay != null) {
                    StatusDisplay.Text           = "Status: Connected " + tcpAddress.Value + ":" + tcpPort.ToString();
                    StatusDisplay.Material.Color = System.Drawing.Color.Lime;
                }

                // Start sending messages to the server.
                await SendMessages();
            }
            catch (Exception e) {
                // If there's an error, close the connection and report the error.
                CloseConnection(e);
            }
        }

        [Auto] void OnReset(Visual sender) {
            CloseConnection();

            if (StatusDisplay != null) {
                StatusDisplay.Text           = "Status: Closed";
                StatusDisplay.Material.Color = System.Drawing.Color.Gray;
            }
        }

        [Auto] IEnumerable OnInitialize(Visual sender) {
            yield return Connect();
        }
    }
}