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
– KPexEA, Commented Sep 17, 2008 at 1: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
– Pat, Commented Mar 19, 2010 at 19:26

15ee8f99-57ff-4f92-890c-b56153 · Accepted Answer · 2018-08-30 14:44:24Z

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<T>(byte[], int)' cannot be inferred from the usage. Try specifying the type arguments explicitly. (I added int index of byte array) to it.
Will leak memory in the presence of exceptions. See: stackoverflow.com/a/41836532/184528 for a safer version.
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<T>(handle.AddrOfPinnedObject());

Community · Accepted Answer · 2017-05-23 12:02:39Z

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, 2017 at 12:02

CommunityBot

11 silver badge

answered Jan 24, 2017 at 18:40

cdiggins

18.3k7 gold badges111 silver badges107 bronze badges

1 Comment

cdiggins Over a year ago

@Ben-Collins The accepted answer was edited after I added my answer.

Tim Ring · Accepted Answer · 2009-12-03 09:34:03Z

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 3, 2009 at 9:34

answered Aug 31, 2008 at 10:03

Tim Ring

1,8271 gold badge20 silver badges27 bronze badges

1 Comment

Chris L Over a year ago

"Visual C++ packs on 8 byte boundaries by default." This solved my issue, thanks a lot!

Richard J. Ross III · Accepted Answer · 2012-02-01 15:09:02Z

4

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

edited Feb 1, 2012 at 15:09

Richard J. Ross III

55.7k25 gold badges139 silver badges205 bronze badges

answered Dec 11, 2011 at 11:46

Dushyant

411 bronze badge

Comments

Mufaka · Accepted Answer · 2008-08-05 21:24:27Z

-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 5, 2008 at 21:24

Mufaka

721 bronze badge

Collectives™ on Stack Overflow

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

5 Answers 5

3 Comments

1 Comment

1 Comment

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

3 Comments

1 Comment

1 Comment

Comments

Comments

Linked

Related