WPF CreateBitmapSourceFromHBitmap() memory leak

MSDN for Bitmap.GetHbitmap() states:

Remarks

You are responsible for calling the GDI DeleteObject method to free the memory used by the GDI bitmap object.

So use the following code:

// at class level[System.Runtime.InteropServices.DllImport("gdi32.dll")]public static extern bool DeleteObject(IntPtr hObject);// your codeusing (System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1000, 1000)) {    IntPtr hBitmap = bmp.GetHbitmap();     try     {        var source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());    }    finally     {        DeleteObject(hBitmap);    }}

I also replaced your Dispose() call by an using statement.

Whenever dealing with unmanaged handles it can be a good idea to use the "safe handle" wrappers:

public class SafeHBitmapHandle : SafeHandleZeroOrMinusOneIsInvalid{    [SecurityCritical]    public SafeHBitmapHandle(IntPtr preexistingHandle, bool ownsHandle)        : base(ownsHandle)    {        SetHandle(preexistingHandle);    }    protected override bool ReleaseHandle()    {        return GdiNative.DeleteObject(handle) > 0;    }}

Construct one like so as soon as you surface a handle (ideally your APIs would never expose IntPtr, they would always return safe handles):

IntPtr hbitmap = bitmap.GetHbitmap();var handle = new SafeHBitmapHandle(hbitmap , true);

And use it like so:

using (handle){  ... Imaging.CreateBitmapSourceFromHBitmap(handle.DangerousGetHandle(), ...)}

The SafeHandle base gives you an automatic disposable/finalizer pattern, all you need to do is override the ReleaseHandle method.

I had the same requirement and issue (memory leak). I implemented the same solution as marked as answer. But although the solution works, it caused an unacceptable hit to performance. Running on a i7, my test app saw a steady 30-40% CPU, 200-400MB RAM increases and the garbage collector was running almost every millisecond.

Since I'm doing video processing, I'm in need of much better performance. I came up with the following, so thought I would share.

Reusable Global Objects

//set up your Bitmap and WritableBitmap as you see fitBitmap colorBitmap = new Bitmap(..);WriteableBitmap colorWB = new WriteableBitmap(..);//choose appropriate bytes as per your pixel format, I'll cheat here an just pick 4int bytesPerPixel = 4;//rectangles will be used to identify what bits changeRectangle colorBitmapRectangle = new Rectangle(0, 0, colorBitmap.Width, colorBitmap.Height);Int32Rect colorBitmapInt32Rect = new Int32Rect(0, 0, colorWB.PixelWidth, colorWB.PixelHeight);

Conversion Code

private void ConvertBitmapToWritableBitmap(){    BitmapData data = colorBitmap.LockBits(colorBitmapRectangle, ImageLockMode.WriteOnly, colorBitmap.PixelFormat);    colorWB.WritePixels(colorBitmapInt32Rect, data.Scan0, data.Width * data.Height * bytesPerPixel, data.Stride);    colorBitmap.UnlockBits(data); }

Implementation Example

//do stuff to your bitmapConvertBitmapToWritableBitmap();Image.Source = colorWB;

The result is a steady 10-13% CPU, 70-150MB RAM, and the garbage collector only ran twice in a 6 minute run.