C#

public byte[] GetObjectBytes(object o)
{
  MemoryStream memstream = new MemoryStream();
  IFormatter formatter = new BinaryFormatter();
 
  formatter.Serialize(memstream, o);
 
  memstream.Close(); // Prevent further writing
 
  return memstream.GetBuffer();
}
 
public object GetObjectFromBytes(byte [] bytes)
{
  MemoryStream memstream = new MemoryStream(bytes);
  IFormatter formatter = new BinaryFormatter();
 
  object o = formatter.Deserialize(memstream);
 
  memstream.Close();
 
  return o;
}

private byte[] GetMyClassBytes(MyClass mc)
{
  return GetObjectBytes(mc);
}
 
private MyClass GetMyClassFromBytes(byte[] bytes)
{
  return (MyClass) GetObjectFromBytes(bytes);
}

using System;
using System.Runtime.InteropServices;

namespace Test
{
  public struct Data
  {
    public int i;
    public int j;
    public int k;
  }
 
  public class Driver
  {
    public static void Main(string [] args)
    {
      byte [] bytes;
      Data data;
      Data foo;
 
      data.i = 1;
      data.j = 2;
      data.k = 3;
 
      bytes = ToByteArray(data);
 
      foo = FromByteArrayToData(bytes);
 
      System.Console.WriteLine("{0}, {1}, {2}", foo.i, foo.j, foo.k);
    }
 
    private static byte[] ToByteArray(object data)
    {
      // Get size of the object
      int sizeofData = Marshal.SizeOf(data);
 
      // Allocate some system memory
      IntPtr pHData = Marshal.AllocHGlobal(sizeofData);
 
      // Fill that memory with the data in 'data'
      Marshal.StructureToPtr(data, pHData, true);
 
      // Create our byte array with the needed number of bytes
      byte [] bytes = new byte[sizeofData];
 
      // Copy data from the system memory back to our managed array
      Marshal.Copy(pHData, bytes, 0, sizeofData);
 
      // Free our system memory
      Marshal.FreeHGlobal(pHData);
 
      // Finally return the byte array, which was filled with the data
      // from the system memory, which contained memory filled by the
      // StructureToPtr call.
      return bytes;
    }
    
    unsafe private static Data FromByteArrayToData(byte[] bytes)
    {
      fixed(byte* pBytes = bytes)
      {
        return *((Data*) pBytes);
      }
    }
  }	
}