C#

Bernhard Hiller wrote:

how does it differ from

string s1= "ENAME\u0005LMSPi0JSON\u00049000";
byte[] bytes=Encoding.UTF8.GetBytes(s1);
string s2 = Encoding.ASCII.GetString(bytes);

"ENAME\u0005LMSPiJSON\u00049000UUID$0b5a576d-a276-4920-a9e8-134c41133102VERS\u00057.9.2"

for (int i = 0; i < BytesReceived.Length; ++i)
{
    char x = (char)BytesReceived[i];
    Console.Write(x);
}
ENAMELMSPiJSON9000UUID$0b5a576d-a276-4920-a9e8-134c41133102VERS7.9.2

ResponseColumn ParseResponseString(string FieldName,string ResponseString)
{
    ResponseColumn rc = new ResponseColumn();

    int pos = ResponseString.IndexOf(FieldName);

    string ColumnName = ResponseString.Substring(pos,5);
    int DataLen = Convert.ToInt32(ColumnName[4]);
    pos+= 5; // this moves the pointer along the string to the value part
    string ColumnValue = ResponseString.Substring(pos,DataLen); // this reads the string starting at pos the length of DataLen

    rc.ColumnName = FieldName;
    rc.ColumnValue = ColumnValue;
    return rc;
}

public class ResponseColumn
{
    public string ColumnName {get;set;}
    public string ColumnValue{get;set;}
}

ResponseColumn rcPortNumber = ParseResponseString("JSON",ResponseString); // Gets me the port number.
ResponseColumn rcServerName = ParseResponseString("NAME",ResponseString); // Gets me the server name.
ResponseColumn rcServerVer  = ParseResponseString("VERS",ResponseString); // Gets me the server version.

ENAMEZVERSAJSON9000UUID$0b5a576d-a276-VERS-a9e8-134c41133102VERS7.9.2
       ^^^^   

private Dictionary<string,string> parseLine(line) {
	dict=New Dictionary<string,string>;
	while not at end of line
		key=readString(4)
		length=readInt(1)
		value=readString(length)
		dict[key]=value
	repeat
	return dict
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LMS
{
    public class ParseLMSResponse
    {
        private const string NAME = "ENAME";
        private const string PORT = "JSON";
        private const string UUID = "UUID";
        private const string VERS = "VERS";

        private byte[] ResponseBytes { get; set;}
        private Dictionary<string, string> KeyValuePairs { get; set; }

        // Pass the byte array to the constructor
        public ParseLMSResponse(byte[] ResponseBytes)
        {
            this.ResponseBytes = ResponseBytes;
            this.GetKeyValuePairs();
        }

        private void GetKeyValuePairs()
        {
            // Local working variables
            string keyname = "";
            string keyvalue = "";
            int i = 0;
            byte b;
            int DataLen = 0;

            KeyValuePairs = new Dictionary<string, string>();

            while (i < ResponseBytes.Length) // Process the entire array
            {
                keyname = "";
                keyvalue = "";
                b = ResponseBytes[i];

                while (b >= 65 && b <= 90) // Read while byte is an upper case value
                {
                    // This builds up the keyname byte by byte
                    keyname += Convert.ToChar(b);
                    ++i;
                    b = ResponseBytes[i];
                }

                // At the end of the keyname is the data length
                DataLen = Convert.ToInt32(b);

                ++i; // move i to the start of the value

                // Get string value from bytes
                keyvalue = Encoding.UTF8.GetString(ResponseBytes, i, DataLen);

                // Add to dictionary
                KeyValuePairs.Add(keyname, keyvalue);
                i += DataLen;
            }
        }

        public string GetHostName
        {
            get
            {
                return GetValue(NAME);
            }
        }

        public string GetUUID
        {
            get
            {
                return GetValue(UUID);
            }
        }
        public string GetVersion
        {
            get
            {
                return GetValue(VERS);
            }
        }

        public int GetPortNumber
        {
            get
            {
                return Convert.ToInt32(GetValue(PORT));
            }
        }

        private string GetValue(string Name)
        {
            string RetVal = "";
            KeyValuePairs.TryGetValue(Name, out RetVal);
            return RetVal;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace LMS {
	public class LMSResponseParser {
		private byte[] responseBytes;
		private Dictionary<string, string> dict;

		public LMSResponseParser(byte[] responseBytes) {
			this.responseBytes=responseBytes;
		}

		public string HostName {
			get {
				return getValue("ENAME");
			}
		}

		public string UUID {
			get {
				return getValue("UUID");
			}
		}
		public string Version {
			get {
				return getValue("VERS");
			}
		}

		public int PortNumber {
			get {
				return Convert.ToInt32(getValue("PORT"));
			}
		}

		private string getValue(string key) {
			try {
				if (dict==null) parse();	// lazy execution, only parse when actually needed!
				return dict[key];
			} catch (Exception exc) {
				throw new ApplicationException(
					"Error parsing LMS response '"+responseBytes+"'", exc);
			}
		}

		private void parse() {
			dict=new Dictionary<string, string>();
			for (int i = 0; i<responseBytes.Length;) {
				string key = "";
				byte b = responseBytes[i++];
				while (b>='A'&&b<='Z') {
					key+=(char)b;
					b=responseBytes[i++];
				}
				int len = b; // At the end of the keyname is the data length
				string value = Encoding.ASCII.GetString(responseBytes, i, len);
				i+=len;
				dict[key]=value;
			}
		}
	}
}

using System.Runtime.InteropServices;

		[StructLayout(LayoutKind.Explicit)]
		struct ShortsOverlayFloat {
			[FieldOffset(0)]
			public short I1;
			[FieldOffset(2)]
			public short I2;
			[FieldOffset(0)]
			public float F;
		}

		public float shortsToFloat(short i1, short i2) {
			ShortsOverlayFloat S;
			S.F=0;	// avoids warning
			S.I1=i1;
			S.I2=i2;
			return S.F;
		}

float f = shortsToFloat(9147, 17352);