Read a file to a struct in c#

Question

I want to read an binary file which has an unknown numbers of structs lined up one after another.

Some Pseudo Code:

struct:
   int64 timestamp,
   byte dataBlock1[600][16]
   byte dataBlock2[600][16]

open = FileOpen(...)
while (!EOF)
   FileRead(open,&struct, sizeof(struct));
   parseStruct(struct)

How do I read a file into a struct in C#? My Struct also has an 2D Array inside, but unsafe struct/fixed arrays are only one dimensional. I could make a [X * Y] on dimensional array, but this feels rubbish.

Answer 1

It should be:

public class Block
{
    public long Timestamp { get; set; }
    public byte[][] DataBlock1 { get; set; } = new byte[600][];
    public byte[][] DataBlock2 { get; set; } = new byte[600][];
}

and then

var lst = new List<Block>();

var enc = Encoding.GetEncoding("iso-8859-1");

using (var fs = File.OpenRead("somefile.bin"))
using (var br = new BinaryReader(fs, enc))
{
    while (br.PeekChar() != -1)
    {
        var block = new Block();

        block.Timestamp = br.ReadInt64();

        for (int i = 0; i < block.DataBlock1.Length; i++)
        {
            block.DataBlock1[i] = br.ReadBytes(16);

            if (block.DataBlock1[i].Length != 16)
            {
                throw new Exception();
            }
        }

        for (int i = 0; i < block.DataBlock2.Length; i++)
        {
            block.DataBlock2[i] = br.ReadBytes(16);

            if (block.DataBlock2[i].Length != 16)
            {
                throw new Exception();
            }
        }

        lst.Add(block);
    }
}

In the end you use a FileStream (returned by File.OpenRead()) and on top of that you put a BinaryReader. I read 16 bytes at a time with BinaryReader, but would be perhaps faster to read multiple "rows" at a time and then split them (a DataBlockX is 9600 bytes, so it isn't too much big). For the EOF handling, I've used BinaryReader.PeekChar, as suggested by Marc Gravell. But note that I concur with the problems presented by some persons, so I'm using the iso-8859-1 encoding, that guarantees that any byte is ok for the method (the default solution suggested by Gravell will break for some combination of bytes)

Something like:

public static void ReadDataBlock(BinaryReader br, byte[][] dataBlock, int size)
{
    int totalSize = dataBlock.Length * size;
    byte[] bytes = br.ReadBytes(totalSize);

    if (bytes.Length != totalSize)
    {
        throw new Exception();
    }

    for (int i = 0; i < dataBlock.Length; i++)
    {
        var block = new byte[size];
        dataBlock[i] = block;
        Buffer.BlockCopy(bytes, i * size, block, 0, size);
    }
}

and then:

block.Timestamp = br.ReadInt64();
ReadDataBlock(br, block.DataBlock1, 16);
ReadDataBlock(br, block.DataBlock2, 16);

Answer 2

Use Marshal Techniques

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Runtime.InteropServices;
using System.IO;


namespace ConsoleApplication49
{
    [StructLayout(LayoutKind.Sequential)]
    public struct Data
    {
        [MarshalAs(UnmanagedType.I8)]
        public Int64 timestamp;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 600 * 16)]
        public byte[,] dataBlock1;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 600 * 16)]
        public byte[,] dataBlock2;
    }
    class Program
    {

        const string FILENAME = @"c:\temp\test.bin";
        static void Main(string[] args)
        {
            Stream oStream = File.OpenWrite(FILENAME);
            BinaryWriter writer = new BinaryWriter(oStream);

            Data writeData = new Data();
            writeData.timestamp = DateTime.Now.ToBinary();

            int size = Marshal.SizeOf(typeof(Data));

            IntPtr wPtr = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(writeData,wPtr,true);
            byte[] oBuffer = new byte[size];
            Marshal.Copy(wPtr, oBuffer, 0, size);
            writer.Write(oBuffer);

            writer.Flush();
            writer.Close();

            Stream iStream = File.OpenRead(FILENAME);
            BinaryReader reader = new BinaryReader(iStream);

            while (!((iStream.Position + size) < iStream.Length))
            {

                IntPtr ptr = Marshal.AllocHGlobal(size);

                byte[] buffer = reader.ReadBytes(size);

                Marshal.Copy(buffer, 0, ptr, size);

                Data data = (Data)Marshal.PtrToStructure(ptr, typeof(Data));
                DateTime now = DateTime.FromBinary(data.timestamp);

            }

        }
    }


}