Load structure from a byte[] byffer

• Download source files - 9.06 KB

Introduction

I have looked for unsafe code using structures, but unfortunately, I couldn't find any. At last, I did by myself a little example. This is the work for fast loading a byte buffer into a structure. Down on the message board, I got an suggestion for a different way. I have created an example for a second way too.

Background

I am trying to read a byte file with structured records. The only way to parse data is the structure size. I looked for samples on the internet, and I couldn't find any even here in the CodeProject. I put a lot of effort in different ways unsuccessfully. From my point of view, the following is a good solution. After Amir's remark, I have added safe pointers for the same job. Thanks Amir.

Using the Code

The code is very simple, and I don't think you would need further help. Just open the archive and use Debug mode. This is a four byte array filled with predefined values. In the end, you would get all the values from the buffer in the structure. You can run the example too, and in the end, press a key to exit from the command prompt

The first part of the code is a demo project for fast loading into a data structure. This part uses unsafe pointers for fast data load into a structure. The second part below is a short description of a slower method and uses safe pointers to do the same task.

byte* n = (byte*)&rtg;

byte[] y = new byte[] { 17, 34, 51, 68 };

//Gets addres of y byte array
fixed (byte* g = y)
{
   byte* a = n;
   byte* b = g;

   //Loads y array into rtg (Rect) structure
   for (int i = 0; i < y.Length; i++)
   {
       *a = *b;
       a++; b++;
   }
}

Safe pointers use the Marshal class to map pointers and structures.

//Allocate amount of memoty
IntPtr safePrt = Marshal.AllocCoTaskMem(Marshal.SizeOf(rtg));

//Copy y byte buffer into memmory allocated
Marshal.Copy(y, 0, safePrt, y.Length);

//Map structure to pointer
rtg  = (Rect) Marshal.PtrToStructure(safePrt, typeof(Rect));

Using direct type casting

I got a good example from Lukas, and I think this is the fastest one. When I started this example, it was just for loading binary structures. This third example shows direct unsafe MEM <-> MEM copy. The key advantage is minimal code to write and fast execution.

// cast the byte pointer to Rect pointer
Rect* pRect = (Rect*)g;

// assign the pointer address to the rtg variable declared outside
rtg = *pRect;

// it can be even done in one line like this:
// rtg = *((Rect*)g);

History

• Demo project V3.0: Current - added direct type casting.
• Demo project V2.0.
• Demo project V1.0.

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)