Reading a C/C++ data structure in C# from a byte array

Question

What would be the best way to fill a C# struct from a byte[] array where the data was from a C/C++ struct? The C struct would look something like this (my C is very rusty):

typedef OldStuff {
    CHAR Name[8];
    UInt32 User;
    CHAR Location[8];
    UInt32 TimeStamp;
    UInt32 Sequence;
    CHAR Tracking[16];
    CHAR Filler[12];
}

And would fill something like this:

[StructLayout(LayoutKind.Explicit, Size = 56, Pack = 1)]
public struct NewStuff
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(0)]
    public string Name;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(8)]
    public uint User;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(12)]
    public string Location;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(20)]
    public uint TimeStamp;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(24)]
    public uint Sequence;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    [FieldOffset(28)]
    public string Tracking;
}

What is best way to copy OldStuff to NewStuff, if OldStuff was passed as byte[] array?

I'm currently doing something like the following, but it feels kind of clunky.

GCHandle handle;
NewStuff MyStuff;

int BufferSize = Marshal.SizeOf(typeof(NewStuff));
byte[] buff = new byte[BufferSize];

Array.Copy(SomeByteArray, 0, buff, 0, BufferSize);

handle = GCHandle.Alloc(buff, GCHandleType.Pinned);

MyStuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));

handle.Free();

Is there better way to accomplish this?

Would using the BinaryReader class offer any performance gains over pinning the memory and using Marshal.PtrStructure?

FYI, If your program runs on various machines you might need to handle little vs big endian. — KPexEA, Sep 17 '08 at 01:03
How can you handle that on the level of the struct, i.e. without having to individually reverse the bytes for each value in the struct? — Pat, Mar 19 '10 at 19:26

score 127 · Accepted Answer · edited Aug 30 '18 at 14:44

From what I can see in that context, you don't need to copy SomeByteArray into a buffer. You simply need to get the handle from SomeByteArray, pin it, copy the IntPtr data using PtrToStructure and then release. No need for a copy.

That would be:

NewStuff ByteArrayToNewStuff(byte[] bytes)
{
    GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try
    {
        NewStuff stuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));
    }
    finally
    {
        handle.Free();
    }
    return stuff;
}

Generic version:

T ByteArrayToStructure<T>(byte[] bytes) where T: struct 
{
    T stuff;
    GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try
    {
        stuff = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
    }
    finally
    {
        handle.Free();
    }
    return stuff;
}

Simpler version (requires unsafe switch):

unsafe T ByteArrayToStructure<T>(byte[] bytes) where T : struct
{
    fixed (byte* ptr = &bytes[0])
    {
        return (T)Marshal.PtrToStructure((IntPtr)ptr, typeof(T));
    }
}

CS0411 The type arguments for method 'ByteArrayToStructure(byte[], int)' cannot be inferred from the usage. Try specifying the type arguments explicitly. (I added int index of byte array) to it. — SSpoke, Jan 16 '16 at 19:39
Will leak memory in the presence of exceptions. See: http://stackoverflow.com/a/41836532/184528 for a safer version. — cdiggins, Jan 24 '17 at 18:42
As of 4.5.1, there's a generic version of PtrToStructure, so the second line in the generic version, above, can become: ```var stuff = Marshal.PtrToStructure(handle.AddrOfPinnedObject());``` — , May 11 '17 at 22:08

score 16 · Answer 2 · edited May 23 '17 at 12:02

16

Here is an exception safe version of the accepted answer:

public static T ByteArrayToStructure<T>(byte[] bytes) where T : struct
{
    var handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try {
        return (T) Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
    }
    finally {
        handle.Free();
    }
}

edited May 23 '17 at 12:02

Community

1
1

answered Jan 24 '17 at 18:40

cdiggins

17,602
7
105
102

4

@Ben-Collins The accepted answer was edited after I added my answer. – cdiggins Jun 13 '18 at 15:48

Tim Ring · Answer 3 · 2009-12-03T09:34:03.727

7

Watch out for packing issues. In the example you gave all fields are at the obvious offsets because everything is on 4 byte boundaries but this will not always be the case. Visual C++ packs on 8 byte boundaries by default.

edited Dec 03 '09 at 09:34

answered Aug 31 '08 at 10:03

Tim Ring

1,845
1
20
27

1

"Visual C++ packs on **8 byte** boundaries by default." This solved my issue, thanks a lot! – Chris L Apr 21 '15 at 08:07

score 4 · Answer 4 · edited Feb 01 '12 at 15:09

object ByteArrayToStructure(byte[] bytearray, object structureObj, int position)
{
    int length = Marshal.SizeOf(structureObj);
    IntPtr ptr = Marshal.AllocHGlobal(length);
    Marshal.Copy(bytearray, 0, ptr, length);
    structureObj = Marshal.PtrToStructure(Marshal.UnsafeAddrOfPinnedArrayElement(bytearray, position), structureObj.GetType());
    Marshal.FreeHGlobal(ptr);
    return structureObj;
}

Have this

score -1 · Answer 5 · answered Aug 05 '08 at 21:24

-1

If you have a byte[] you should be able to use the BinaryReader class and set values on NewStuff using the available ReadX methods.

answered Aug 05 '08 at 21:24

Mufaka

72
1

Reading a C/C++ data structure in C# from a byte array

5 Answers5

Linked

Related