Image Convert from Byte to Image and Image to Byte

Method 1: unsafe code, locking the bitmap and using the Marshal class

Code:

// import this
// using System.Runtime.InteropServices;
private unsafe byte[] BmpToBytes_Unsafe (Bitmap bmp)
{
BitmapData bData = bmp.LockBits(new Rectangle (new Point(), bmp.Size),
 ImageLockMode.ReadOnly,
 PixelFormat.Format24bppRgb);
// number of bytes in the bitmap
int byteCount = bData.Stride * bmp.Height;
byte[] bmpBytes = new byte[byteCount];

// Copy the locked bytes from memory
Marshal.Copy (bData.Scan0, bmpBytes, 0, byteCount);

// don't forget to unlock the bitmap!!
bmp.UnlockBits (bData);

return bmpBytes;
}

in most cases this works fine, because your bitmap doesn't have an alpha channel. But if it does, and you want to preserve it, then use Format32bppArgb in the fist line when locking the bitmap.
I wish I could think of a way of doing this without locking the bitmap (ie, you could use GCHandle.Alloc() and then call Marshal.Copy() using the created handle, but the problem is I wouldnt know the size of the bitmap without locking it's bits and the Marshal.Copy() function needs to know the size).

reversing this process is a bit ugly, as you need to know the dimensions of the bitmap.

Code:

private unsafe Bitmap BytesToBmp (byte[] bmpBytes, Size imageSize)
{
Bitmap bmp = new Bitmap (imageSize.Width, imageSize.Height);

BitmapData bData  = bmp.LockBits (new Rectangle (new Point(), bmp.Size),
 ImageLockMode.WriteOnly,
 PixelFormat.Format24bppRgb);

// Copy the bytes to the bitmap object
Marshal.Copy (bmpBytes, 0, bData.Scan0, bmpBytes.Length);
bmp.UnlockBits(bData);
return bmp;
}

ok that was if you wanted to have exactly the same bytes as in the memory There are two other ways I can think of. Note that these won't produce the exact copy of the bitmap bits from the memory

Method 2: using a memory stream
This just asks the .Save() method to save the bytes to a memory stream, then you can get the written bytes to the stream:

Code:

// Bitmap bytes have to be created via a direct memory copy of the bitmap
private byte[] BmpToBytes_MemStream (Bitmap bmp)
{
MemoryStream ms = new MemoryStream();
// Save to memory using the Jpeg format
bmp.Save (ms, ImageFormat.Jpeg);

// read to end
byte[] bmpBytes = ms.GetBuffer();
bmp.Dispose();
ms.Close();

return bmpBytes;
}

converting that back to a bitmap is easy.

Code:

//Bitmap bytes have to be created using Image.Save()
private Image BytesToImg (byte[] bmpBytes)
{
MemoryStream ms = new MemoryStream(bmpBytes);
Image img = Image.FromStream(ms);
// Do NOT close the stream!

return img;
}

Method 3:using serialization
I can't see any reason why someone would use this method, it's very stupid including it just for reference

Code:

// import these
// using System.Runtime.Serialization;
// using System.Runtime.Serialization.Formatters.Binary;
private byte[] BmpToBytes_Serialization (Bitmap bmp)
{
// stream to save the bitmap to
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize (ms, bmp);

// read to end
byte[] bmpBytes = ms.GetBuffer();
bmp.Dispose();
ms.Close();

return bmpBytes;
}
private Bitmap BytesToBmp_Serialized (byte[] bmpBytes)
{
BinaryFormatter bf = new BinaryFormatter ();
// copy the bytes to the memory
MemoryStream ms = new MemoryStream (bmpBytes);
return (Bitmap)bf.Deserialize(ms);
}

big note: if you use any of these methods, then you have to use both functions presented in the method together. For example you can't get the bitmap bytes using method 1, and then call method2's function BytesToImg()

also, a bit after I wrote that method 1, I realized that there was an API for doing this . It's maybe the best method but there is a turn down: you have to use reflection to retreive the bitmap handle in order to use it with the api function:
Method 4: using reflection and API
I just tell you the APIs to retreive the bitmap handle you can use this

Code:

  private IntPtr getImageHandle (Image img)
 {
  FieldInfo fi = typeof(Image).GetField("nativeImage", BindingFlags.NonPublic | BindingFlags.Instance);
  if (fi == null)
   return IntPtr.Zero;

   return (IntPtr)fi.GetValue (img);
  }

the GetBitmapBits API seems to be the easy way out, but apparently it's just there for 16bit compatibility. You should use the GetDIBits instead. If you end up using that method, please post your code