关于c＃：从System.Drawing.Bitmap加载WPF BitmapImage

Load a WPF BitmapImage from a System.Drawing.Bitmap

我有一个System.Drawing.Bitmap的实例，并希望以System.Windows.Media.Imaging.BitmapImage的形式将其提供给我的WPF应用程序。

最好的方法是什么？

如何从MemoryStream加载它？

1
2
3
4
5
6
7
8
9
10

using(MemoryStream memory = new MemoryStream())
{
bitmap.Save(memory, ImageFormat.Png);
memory.Position = 0;
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = memory;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.EndInit();
}

感谢Hallgrim，这是我最终得到的代码：

1
2
3
4
5

ScreenCapture = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
bmp.GetHbitmap(),
IntPtr.Zero,
System.Windows.Int32Rect.Empty,
BitmapSizeOptions.FromWidthAndHeight(width, height));

我也结束了绑定到BitmapSource而不是绑定到原始问题中的BitmapImage

我知道已经回答了，但是这里有几个扩展方法(用于.NET 3.0+)可以进行转换。 :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/// <summary>
/// Converts a <see cref="System.Drawing.Image"/> into a WPF <see cref="BitmapSource"/>.
/// </summary>
/// <param name="source">The source image.</param>
/// <returns>A BitmapSource</returns>
public static BitmapSource ToBitmapSource(this System.Drawing.Image source)
{
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(source);

var bitSrc = bitmap.ToBitmapSource();

bitmap.Dispose();
bitmap = null;

return bitSrc;
}

/// <summary>
/// Converts a <see cref="System.Drawing.Bitmap"/> into a WPF <see cref="BitmapSource"/>.
/// </summary>
/// <remarks>Uses GDI to do the conversion. Hence the call to the marshalled DeleteObject.
/// </remarks>
/// <param name="source">The source bitmap.</param>
/// <returns>A BitmapSource</returns>
public static BitmapSource ToBitmapSource(this System.Drawing.Bitmap source)
{
BitmapSource bitSrc = null;

var hBitmap = source.GetHbitmap();

try
{
bitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
hBitmap,
IntPtr.Zero,
Int32Rect.Empty,
BitmapSizeOptions.FromEmptyOptions());
}
catch (Win32Exception)
{
bitSrc = null;
}
finally
{
NativeMethods.DeleteObject(hBitmap);
}

return bitSrc;
}

和NativeMethods类(以安抚FxCop)

1
2
3
4
5
6
7
8
9

/// <summary>
/// FxCop requires all Marshalled functions to be in a class called NativeMethods.
/// </summary>
internal static class NativeMethods
{
[DllImport("gdi32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool DeleteObject(IntPtr hObject);
}

我花了一些时间才能使转换同时进行，所以这是我想到的两种扩展方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Windows.Media.Imaging;

public static class BitmapConversion {

public static Bitmap ToWinFormsBitmap(this BitmapSource bitmapsource) {
using (MemoryStream stream = new MemoryStream()) {
BitmapEncoder enc = new BmpBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(bitmapsource));
enc.Save(stream);

using (var tempBitmap = new Bitmap(stream)) {
// According to MSDN, one"must keep the stream open for the lifetime of the Bitmap."
// So we return a copy of the new bitmap, allowing us to dispose both the bitmap and the stream.
return new Bitmap(tempBitmap);
}
}
}

public static BitmapSource ToWpfBitmap(this Bitmap bitmap) {
using (MemoryStream stream = new MemoryStream()) {
bitmap.Save(stream, ImageFormat.Bmp);

stream.Position = 0;
BitmapImage result = new BitmapImage();
result.BeginInit();
// According to MSDN,"The default OnDemand cache option retains access to the stream until the image is needed."
// Force the bitmap to load right now so we can dispose the stream.
result.CacheOption = BitmapCacheOption.OnLoad;
result.StreamSource = stream;
result.EndInit();
result.Freeze();
return result;
}
}
}

最简单的方法是，您可以直接从文件中制作WPF位图。

否则，您将不得不使用System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// at class level;
[System.Runtime.InteropServices.DllImport("gdi32.dll")]
public static extern bool DeleteObject(IntPtr hObject); // https://stackoverflow.com/a/1546121/194717

/// <summary>
/// Converts a <see cref="System.Drawing.Bitmap"/> into a WPF <see cref="BitmapSource"/>.
/// </summary>
/// <remarks>Uses GDI to do the conversion. Hence the call to the marshalled DeleteObject.
/// </remarks>
/// <param name="source">The source bitmap.</param>
/// <returns>A BitmapSource</returns>
public static System.Windows.Media.Imaging.BitmapSource ToBitmapSource(this System.Drawing.Bitmap source)
{
var hBitmap = source.GetHbitmap();
var result = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, System.Windows.Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

DeleteObject(hBitmap);

return result;
}

我在图像处理供应商处工作，并为WPF编写了一个适配器，将其转换为类似于System.Drawing.Bitmap的图像格式。

我写了这个知识库，向我们的客户解释：

http://www.atalasoft.com/kb/article.aspx?id=10156

那里有执行此操作的代码。您需要用Bitmap替换AtalaImage并执行我们正在做的等效工作-它应该非常简单。

您只需编写自定义位图源，即可在两个名称空间(媒体和图形)之间共享pixeldata。转换将立即发生，并且不会分配额外的内存。如果您不想显式创建位图的副本，则可以使用这种方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

class SharedBitmapSource : BitmapSource, IDisposable
{
#region Public Properties

/// <summary>
/// I made it public so u can reuse it and get the best our of both namespaces
/// </summary>
public Bitmap Bitmap { get; private set; }

public override double DpiX { get { return Bitmap.HorizontalResolution; } }

public override double DpiY { get { return Bitmap.VerticalResolution; } }

public override int PixelHeight { get { return Bitmap.Height; } }

public override int PixelWidth { get { return Bitmap.Width; } }

public override System.Windows.Media.PixelFormat Format { get { return ConvertPixelFormat(Bitmap.PixelFormat); } }

public override BitmapPalette Palette { get { return null; } }

#endregion

#region Constructor/Destructor

public SharedBitmapSource(int width, int height,System.Drawing.Imaging.PixelFormat sourceFormat)
:this(new Bitmap(width,height, sourceFormat) ) { }

public SharedBitmapSource(Bitmap bitmap)
{
Bitmap = bitmap;
}

// Use C# destructor syntax for finalization code.
~SharedBitmapSource()
{
// Simply call Dispose(false).
Dispose(false);
}

#endregion

#region Overrides

public override void CopyPixels(Int32Rect sourceRect, Array pixels, int stride, int offset)
{
BitmapData sourceData = Bitmap.LockBits(
new Rectangle(sourceRect.X, sourceRect.Y, sourceRect.Width, sourceRect.Height),
ImageLockMode.ReadOnly,
Bitmap.PixelFormat);

var length = sourceData.Stride * sourceData.Height;

if (pixels is byte[])
{
var bytes = pixels as byte[];
Marshal.Copy(sourceData.Scan0, bytes, 0, length);
}

Bitmap.UnlockBits(sourceData);
}

protected override Freezable CreateInstanceCore()
{
return (Freezable)Activator.CreateInstance(GetType());
}

#endregion

#region Public Methods

public BitmapSource Resize(int newWidth, int newHeight)
{
Image newImage = new Bitmap(newWidth, newHeight);
using (Graphics graphicsHandle = Graphics.FromImage(newImage))
{
graphicsHandle.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphicsHandle.DrawImage(Bitmap, 0, 0, newWidth, newHeight);
}
return new SharedBitmapSource(newImage as Bitmap);
}

public new BitmapSource Clone()
{
return new SharedBitmapSource(new Bitmap(Bitmap));
}

//Implement IDisposable.
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

#endregion

#region Protected/Private Methods

private static System.Windows.Media.PixelFormat ConvertPixelFormat(System.Drawing.Imaging.PixelFormat sourceFormat)
{
switch (sourceFormat)
{
case System.Drawing.Imaging.PixelFormat.Format24bppRgb:
return PixelFormats.Bgr24;

case System.Drawing.Imaging.PixelFormat.Format32bppArgb:
return PixelFormats.Pbgra32;

case System.Drawing.Imaging.PixelFormat.Format32bppRgb:
return PixelFormats.Bgr32;

}
return new System.Windows.Media.PixelFormat();
}

private bool _disposed = false;

protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
// Free other state (managed objects).
}
// Free your own state (unmanaged objects).
// Set large fields to null.
_disposed = true;
}
}

#endregion
}

我对此有很多了解。 https://stackoverflow.com/a/7035036 https://stackoverflow.com/a/1470182/360211

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

using System;
using System.Drawing;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media.Imaging;
using Microsoft.Win32.SafeHandles;

namespace WpfHelpers
{
public static class BitmapToBitmapSource
{
public static BitmapSource ToBitmapSource(this Bitmap source)
{
using (var handle = new SafeHBitmapHandle(source))
{
return Imaging.CreateBitmapSourceFromHBitmap(handle.DangerousGetHandle(),
IntPtr.Zero, Int32Rect.Empty,
BitmapSizeOptions.FromEmptyOptions());
}
}

[DllImport("gdi32")]
private static extern int DeleteObject(IntPtr o);

private sealed class SafeHBitmapHandle : SafeHandleZeroOrMinusOneIsInvalid
{
[SecurityCritical]
public SafeHBitmapHandle(Bitmap bitmap)
: base(true)
{
SetHandle(bitmap.GetHbitmap());
}

[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
protected override bool ReleaseHandle()
{
return DeleteObject(handle) > 0;
}
}
}
}

我之所以遇到这个问题，是因为我试图这样做，但就我而言，位图来自资源/文件。我发现最佳解决方案如以下链接所述：

http://msdn.microsoft.com/zh-CN/library/system.windows.media.imaging.bitmapimage.aspx

1
2
3
4
5
6
7
8
9
10
11
12
13

// Create the image element.
Image simpleImage = new Image();
simpleImage.Width = 200;
simpleImage.Margin = new Thickness(5);

// Create source.
BitmapImage bi = new BitmapImage();
// BitmapImage.UriSource must be in a BeginInit/EndInit block.
bi.BeginInit();
bi.UriSource = new Uri(@"/sampleImages/cherries_larger.webp",UriKind.RelativeOrAbsolute);
bi.EndInit();
// Set the image source.
simpleImage.Source = bi;