this comes from my own l33t hax0r skillz
if you've got a better way, say so
method 1 just copies the bitmap bytes from memory
method 2 actually saves the image and writes any image headers and whatnot using a proper image format, and then converts the written data to a byte array
method 3 saves the objects data using serialization (very useless
just serialize to file or something... included for the heck of it)
the l33test way in my opinion is using unsafe code:
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 
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。