Question

Once again I’m receiving structs via UDP from a C++ programm,
Now I ported the structs to C#, Example:

[Serializable]
struct sample
{
public int in;
public byte[] arr;
public int[] arr2;
public float fl;
}

Ok so how does the Deserializer know when one array ends and the other begins?
Can specify somehow how big the array is?
I don’t want to use fixed, since this makes my code unsafe, and I also can’t use a Constructor since structs are not allowed to contain constructors without parameters.

Any suggestions?

//edit:

the arrays are known to be 32 and 4 long.
the problem is that I don’t know how to pass this information to the deserialiser

then sender is C++ an works like this:

char* pr = &sample;
int i=0;
while (i<sizeof(sample))
{
 udp.send(*(pr+i))
 i++;
}

Answer 1

Now that you have told us that the lengths are of pre-defined length, then the following statement becomes clearer:

I don’t know how to pass this information to the deserialiser

In fact, it becomes moot. There is no pre-defined serializer that is going to help you here. You have two options:

A: write your own serializer, and process the data now that you know the format – perhaps using BinaryReader:

using(var reader = new BinaryReader(source)) {

    int in = reader.ReadInt32();
    byte[] arr = reader.ReadBytes(32);
    int[] arr2 = new int[4];
    for(int i = 0 ; i < 4 ; i++) arr2[i] = reader.ReadInt32();
    float fl = reader.ReadSingle();

    var obj = /* something involving ^^^ */
}

B: buffer 56 bytes, and use really nasty unsafe / fixed / pointer-banging code

I strongly suggest the first. In particular, this will also allow you to address endianness if required.

IN THE NAME OF EVERYTHING SACRED TO YOU, DO NOT DO THIS:

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
unsafe struct sample
{
    [FieldOffset(0)] public int @in;
    [FieldOffset(4)] public fixed byte arr[32];
    [FieldOffset(36)] public fixed int arr2[4];
    [FieldOffset(52)] public float fl;    
}

static class Program
{
    unsafe static void Main()
    {
        byte[] buffer = new byte[56];
        new Random().NextBytes(buffer); // some data...

        sample result;
        fixed(byte* tmp = buffer)
        {
            sample* ptr = (sample*) tmp;
            result = ptr[0];
        }

        Console.WriteLine(result.@in);
        Console.WriteLine(result.fl);
    }    
}

For larger buffers, you can treat ptr as an unsafe array of multiple sample, accessed by index:

int @in = ptr[i].@in;

(etc)

But honestly… there are so many things “evil” with that, I honestly don’t know where to begin… just… unless you know absolutely what every line in there is doing, have done it before, and understand all the traps… DON’T EVEN THINK ABOUT IT