title: C# Struct to byte array marshalling the same way as with packed records in Delphi
body: <p>I have a legacy application written in Delphi 2007 which generates byte arrays like this:</p>
  
  <pre><code>command_data = packed record
      direction     : word;
      name          : array [0..9] of char;
  end;
  
  command_header = packed record
      length      : word;
      data1       : word;
      data2       : cardinal;
  end;
  
  command_data_container = packed record
      data          : command_data;
      containerId   : word;
  end;
  
  function Generate(name: string)boolean;
  var
    header  : command_header;
    container : command_data_container;
    charArrayName: array [0..9] of char;
  
  begin
    charArrayName = array [0..9] of char;
  
    for I := 0 to Length(name) - 1 do begin
      charArrayName[i] := name[i+1];
    end;
    charArrayName[i+1] := #0;
  
    header.length := sizeof(header) + sizeof(container);
    header.data1 := 0;
    header.data2 := 1;
  
    container.data.direction := 1;
    container.data.name      := charArrayName;
    container.containerId    := 1;
  
    stream := TMemoryStream.Create;
    stream.WriteBuffer(header, SizeOf(header));
    stream.WriteBuffer(container, SizeOf(container));
    //...
   end;
  </code></pre>
  
  <p>I need to rewrite this part in C#. I got this so far:</p>
  
  <pre><code>[StructLayout(LayoutKind.Sequential, Pack = 1)]
  unsafe struct command_data
  {
      public ushort direction;
      public fixed char name[10];
  }
  
  [StructLayout(LayoutKind.Sequential, Pack = 1)]
  unsafe struct command_header
  {
      public ushort length;
      public ushort data1;
      public ulong data2;
  }    
  
  [StructLayout(LayoutKind.Sequential, Pack = 1)]
  struct command_data_container
  {
      public command_data data;
      public ushort containerId;
  } 
  
   public bool Generate(string name)
   {
      name = name + Char.MinValue; // Add null terminator.
      char[] charArrayName = agentId.ToCharArray();
  
      unsafe
      {
          command_header header;
          command_data_container command;
  
          header.data1 = 0;
          header.data2 = 1;
          header.length = (ushort)(sizeof(command_header) + sizeof(command_data_container));
  
  
          command.data.direction = 1;
          *command.data.name = charArrayName[0];
  
          for (int i = 1; i &lt; charArrayName.Length; i++)
          {
              *(command.data.name + i) = charArrayName[i];
          }
          command.containerId = 1;
  
          var headerBytes = StructToBytes&lt;command_header&gt;(header);
          var commandBytes = StructToBytes&lt;command_data_container&gt;(command);
  
          byte[] combined = new byte[headerBytes.Length + commandBytes.Length];
          Buffer.BlockCopy(headerBytes, 0, combined, 0, headerBytes.Length);
          Buffer.BlockCopy(commandBytes, 0, combined, headerBytes.Length, commandBytes.Length);
  
          //combined should have the same data as the stream in the delphi code
  
      }
   }
  
  
  public static byte[] StructToBytes&lt;T&gt;(T structure) where T : struct
  {
      int size = Marshal.SizeOf(structure);
      byte[] rawData = new byte[size];
      GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
      try
      {
          IntPtr rawDataPtr = handle.AddrOfPinnedObject();
          Marshal.StructureToPtr(structure, rawDataPtr, false);
      }
      finally
      {
          handle.Free();
      }
      return rawData;
  }
  </code></pre>
  
  <p>I tried several methods to convert the struct to a byte array, but none of them reproduced the same result as the Delphi code.</p>
  
  <p>The StructToBytes method is borrowed from here: <a href="https://stackoverflow.com/questions/17549123/c-sharp-performance-using-unsafe-pointers-instead-of-intptr-and-marshal">C# performance - Using unsafe pointers instead of IntPtr and Marshal</a></p>
  
  <p>I also tried some others marshalling methods from SO, but nothing worked.
  What did I do wrong?</p>