Packing udp packet of arbitrary number of coordinates

Question

So I am getting a variable number of coordinates (latitude and longitude). I want to pack these coordinates in a straight forward way that can be easily sent via UDP and unpacked. How can I go about this with C#?

I'm assuming I declare a struct and then use the built in marshalling to get a byte array to send. How does one do this when there is a variable number of points involved?

Most of my programming experience has been in Python, but I need this to be done in C#, which I have limited experience with.

edit: I'll add some code I was testing out, since I feel like no one responds to just text.

namespace ConsoleApplication1
{
    class Testing
    {
        static void Main(string[] args)
        {
            // Console.WriteLine("Starting");

            // string text = "Hello";
            // byte[] data = Encoding.ASCII.GetBytes(text);

            StartPacket test = new StartPacket();
            test.len = 3;
            List<double> points = new List<double>();
            points.Add(3.14);
            points.Add(5);
            points.Add(-1023.1231311);
            test.points = points;

            byte[] data = StructureToByteArray(test);

            SendUdp(65456, "192.168.20.100", data);

       }

        static void SendUdp(int srcPort, string dstIp, byte[] data)
        {
            Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram,
                                     ProtocolType.Udp);
            IPAddress dst = IPAddress.Parse(dstIp);
            IPEndPoint endPoint = new IPEndPoint(dst, srcPort);

            sock.SendTo(data, endPoint);
        }

        public struct StartPacket
        {
            public uint len;
            public List<double> points;
        }

        public static byte[] StructureToByteArray(object obj)
        {
            int len = Marshal.SizeOf(obj);
            byte[] arr = new byte[len];

            IntPtr ptr = Marshal.AllocHGlobal(len);
            Marshal.StructureToPtr(obj, ptr, true);
            Marshal.Copy(ptr, arr, 0, len);
            Marshal.FreeHGlobal(ptr);
            return arr;
        }
    }
}

This code fails with: Type 'ConsoleApplication1.Testing+StartPacket' cannot be marshaled as an unmanaged structure; no meaningful size or offset can be computed.

Answer 1

This seems more like a serialization/deserialization task. The simplest approach is to mark the class with Serializable then use the BinaryFormatter like this:

public class Program
{
    public static void Main(string[] args)
    {
        var startPacket = new StartPacket();
        startPacket.len = 3;
        startPacket.points = new List<double>() { 3.14, 5, -1023.1231311 };

        // serialize into a byte array for Socket.SendTo()
        var formatter = new BinaryFormatter();
        var ms = new MemoryStream();
        formatter.Serialize(ms, startPacket);
        var bytes = ms.ToArray();

        // assuming we received bytes[] from a socket, deserialize into StartPacket object
        ms = new MemoryStream(bytes);
        formatter = new BinaryFormatter();
        startPacket = (StartPacket)formatter.Deserialize(ms);
    }
}

[Serializable()]
public struct StartPacket
{
    public uint len;
    public List<double> points;
}

However, this is not very efficient memory-wise--this example generates a 524-byte serialized StartPacket, probably due to the fact that the List<> will have a capacity of more than 3 doubles. Making points an array with the specific size only gets us down to 211 bytes. Without looking into it, I'd guess that there's a lot of overhead in the serialized version of the struct (like the names and types of variables, etc). However, if you're not too concerned about the size of the packet, then this might work for you.

If you want something more efficient, then you can add methods to StartPacket like so:

public class Program
{
    public static void Main(string[] args)
    {
        var startPacket = new StartPacket();
        startPacket.len = 3;
        startPacket.points = new List<double> { 3.14, 5, -1023.1231311 };

        // create an array to send through the socket
        var arr = startPacket.ToArray();

        // create a StartPacket from an array we received from a socket
        var newStartPacket = StartPacket.FromArray(arr);
    }
}

public struct StartPacket
{
    public uint len;
    public List<double> points;

    public byte[] ToArray()
    {
        var arr = BitConverter.GetBytes(len);

        foreach (var point in points)
        {
            arr = arr.Concat(BitConverter.GetBytes(point)).ToArray();
        }

        return arr;
    }

    public static StartPacket FromArray(byte[] array)
    {
        var sp = new StartPacket();
        sp.len = BitConverter.ToUInt32(array, 0);
        sp.points = new List<double>();

        for (int i = 0; i < sp.len; i++)
        {
            sp.points.Add(BitConverter.ToDouble(array, 4 + i * 8));
        }

        return sp;
    }
}

Note that neither of these account for the endianness of the system. Hope this helps.