Einar wrote (long ago),
In the article you wrote on unsafe image processing, you announced a follow-up that would “cover some more unsafe scenarios, including dealing with existing structures on disk”. But then I guess something came up, and that article never surfaced (to my knowledge and loss, respectively). How about a blog post instead?
Einar’s first mistake was believing anything that I write about future columns. My track record at getting back to topics is pretty poor – so bad, in fact, that I’ve tried to stop making promises about what I’ll write about next.
Let’s look at some code from a GPS application I’ve been playing around with for quite some time. This code opens a file and reads a mess of binary structures out of it, and recreates them as real structures.
public unsafe static GpsDataset Load(string filename)
GpsDataset dataset = new GpsDataset();
FileInfo fileInfo = new FileInfo(filename);
int count = (int) (fileInfo.Length / sizeof(GpsPosition));
using (FileStream fileStream = new FileStream(filename, FileMode.Open))
BinaryReader binaryReader = new BinaryReader(fileStream);
for (int i = 0; i < count; i++)
byte buffer = binaryReader.ReadBytes(sizeof(GpsPosition));
It starts by getting the size of the file, and then computing how many items are in the file (I could have just read till end-of-file, but that seemed less elegant. Know the size ahead of time allows me to pre-allocate my positions ArrayList (not that I did that, but it *allows me to* do that…)).
Then it’s off to reading the chunks out, into a byte buffer. It would be considerably more efficient if I stuck with a stream and read the bytes into the same buffer over and over rather than re-allocated a whole buffer, but a) I haven’t gotten around to optimizing this yet b) I wrote it to be flexible, when I didn’t know what I’d be storing c) The UI operations are far slower than what I’m doing here and d) did I say it wasn’t yet optimized.
Anyway, this buffer gets passed off to the constructor for GpsPosition, which looks like this:
public unsafe struct GpsPosition
public float AltitudeAboveWGS84;
public float EstimatedPositionError;
public float EstimatedHorizontalError;
public float EstimatedVeriticalError;
public PositionFix PositionFix;
public double TimeOfWeek;
public double Latitude;
public double Longitude;
public float VelocityEast;
public float VelocityNorth;
public float VelocityUp;
public float AltitudeAboveMSL;
public short LeapSeconds;
public int WeekNumberDays;
public GpsPosition(byte data)
fixed (byte* pData = data)
this = *(GpsPosition*) pData;
The constructor simply fixes the data buffer so it’s okay to get a pointer to it, then uses a cast and pointer dereference to copy the contents of the buffer over the struct.
Note the StructLayout attribute at the beginning of the routine. In it, I set the packing to 1. By default, the runtime will give you nicely aligned structures that are more efficient to access by padding. In this case, I need the structure to match the definition from the Garmin API spec *exactly*, so I have to set packing to 1.
That’s about all there is to it. Define the structure, get a byte of the right size, and then copy the data over in a fixed block.