Convert class object to bytes and create object from bytes

Ok this maybe what your looking for

The assumptions gleaned from your comments and updates are as follows

• You want a generic way to serialize your classes (messages)
• You want to be able to use this over the wire (sockets, not wcf)
• It conforms to a socket regime
• You want some basic protection against corruption
• you want it easy to use

Note : there maybe many areas here which can be improved, however this is just to give you some ideas

If your using something like webservices this entire answer is null and void, this is really only a adhock method of serialization suitable for sockets

Overview

The Package class has some methods for the following

• Able to serialize objects to bytes
• Able to deserialize bytes to objects
• Can create packages with header information
• Header contains your message type (Option)
• The length of the entire package
• Some basic check summing and markers, in case of corruptions you can validate a package

So given the following

Message Enum

// Some predefined messages
public enum MessageType : byte
{
   MyClass,
   MyOtherClass,
   Message3,
   Message4,

}

Some class you want to send over the wire

// a serilaizable class
// Make this as you like
[Serializable]
public class MyClass
{

   public byte[] SomeArbitaryBytes { get; set; }
   public string SomeArbitaryString { get; set; }
   public int SomeArbitaryInt { get; set; }
   public double SomeArbitaryDouble { get; set; }

   public MyClass()
   {

      SomeArbitaryString = "hello";
      SomeArbitaryInt = 7;
      SomeArbitaryDouble = 98.1;
      SomeArbitaryBytes = new byte[10];
      for (var i = 0; i < SomeArbitaryBytes.Length; i++)
      {
         SomeArbitaryBytes[i] = (byte)i;
      }
   }
}

Package Class

public static class Package
{
   // Method for basic checksum
   private static byte GetBasicChecksum(this byte[] data)
   {
      byte sum = 0;
      unchecked // Let overflow occur without exceptions
      {
         foreach (byte b in data)
         {
            sum += b;
         }
      }
      return sum;
   }

   // Serialize to bytes (BinaryFormatter)
   public static byte[] SerializeToBytes<T>(this T source)
   {
      using (var stream = new MemoryStream())
      {
         var formatter = new BinaryFormatter();
         formatter.Serialize(stream, source);
         return stream.ToArray();
      }
   }

   // Deerialize from bytes (BinaryFormatter)
   public static T DeserializeFromBytes<T>(this byte[] source)
   {
      using (var stream = new MemoryStream(source))
      {
         var formatter = new BinaryFormatter();
         stream.Seek(0, SeekOrigin.Begin);
         return (T)formatter.Deserialize(stream);
      }
   }

   // Check if we have enough data
   // will throw if it detects a corruption (basic)
   // return false if there isnt enough data to determine
   // return true and length of the package if sucessfull
   public static bool HasValidPackage(this Stream stream, out Int32 messageSize)
   {
      messageSize = -1;

      if (stream.Length - stream.Position < sizeof(byte) * 2 + sizeof(Int32))
         return false;


      var stx = stream.ReadByte();

      if (stx != 2)
         throw new InvalidDataException("Invalid Package : STX Failed");

      var packageLength = new byte[sizeof(Int32)];
      stream.Read(packageLength, 0, sizeof(Int32));
      messageSize = BitConverter.ToInt32(packageLength, 0) - sizeof(byte) * 3;
      var checkSum = stream.ReadByte();

      if (checkSum != packageLength.GetBasicChecksum())
         throw new InvalidDataException("Invalid Package : CheckSum Failed");

      return stream.Length >= messageSize;

   }

   // Pack the message
   public static byte[] PackMessage<T>(this T source, MessageType messageType)
   {
      var buffer = source.SerializeToBytes();
      var packageLength = BitConverter.GetBytes(buffer.Length + sizeof(byte) * 3);
      using (var stream = new MemoryStream())
      {
         stream.WriteByte(2);
         stream.Write(packageLength, 0, sizeof(Int32));
         stream.WriteByte(packageLength.GetBasicChecksum());
         stream.WriteByte((byte)messageType);
         stream.Write(buffer, 0, buffer.Length);
         stream.WriteByte(3);
         return stream.ToArray();
      }
   }

   // Unpack the message
   public static MessageType UnPackMessage(this Stream stream, Int32 messageSize, out byte[] buffer)
   {

      var messageType = (MessageType)stream.ReadByte();
      buffer = new byte[messageSize];
      stream.Read(buffer, 0, buffer.Length);

      var etx = stream.ReadByte();

      if (etx != 3)
         throw new InvalidDataException("Invalid Package : ETX Failed");

      return messageType;
   }

}

Client Side Code

// create your class 
var myClass = new MyClass();

// Create a package out of it
var bytes = myClass.PackMessage(MessageType.MyClass);

Server Side Code

// this is server side
using (var stream = new MemoryStream(bytes))
{
   Int32 messageSize;

   // if we have a valid package do stuff
   // this loops until there isnt enough data for a package or empty
   while (stream.HasValidPackage(out messageSize))
   {

      byte[] buffer;

      switch (stream.UnPackMessage(messageSize, out buffer))
      {
         case MessageType.MyClass:
            var myClassCopy = buffer.DeserializeFromBytes<MyClass>();
            // do stuff with your class
            break;
         case MessageType.MyOtherClass:
            break;
         case MessageType.Message3:
            break;
         case MessageType.Message4:
            break;
         default:
            throw new ArgumentOutOfRangeException();
      }

   }

   // do something with the remaining bytes here, if any, i.e partial package

}