C#/WPF位图在设置一些值（带锁位）后保持白色

使用MS Visual Studio 2013，具有以下代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices; 
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Drawing;
using System.Drawing.Imaging;

namespace SplashNS
{    

    public partial class DocumentWindow : Window
    {
        public SplashFile File;

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

        private BitmapSource _loadBitmap(System.Drawing.Bitmap source)
        {
            IntPtr ip = source.GetHbitmap();
            BitmapSource bs = null;
            try
            {
                bs = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(ip,
                   IntPtr.Zero, Int32Rect.Empty,
                   System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
            }
            finally
            {
                DeleteObject(ip);
            }

            return bs;
        }

        public DocumentWindow()
        {
            InitializeComponent();
            Bitmap canvas = new Bitmap(663, 356);
            BitmapData bmd = canvas.LockBits(new System.Drawing.Rectangle(0, 0, canvas.Width, canvas.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, canvas.PixelFormat);
            int PixelSize = 4;

            unsafe
            {
                for (int y = 0; y < canvas.Height; y++)
                {
                    byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                    for (int x = 0; x < canvas.Width; x++)
                    {
                        row[x * PixelSize] = 255;    
                    }
                }
            }
            canvas.UnlockBits(bmd);          
            SplashCanvas.Source = this._loadBitmap(canvas);
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用System.Runtime.InteropServices；
使用System.Windows；
使用System.Windows.Controls；
使用System.Windows.Data；
使用System.Windows.Documents；
使用System.Windows.Input；
使用System.Windows.Media；
使用System.Windows.Media.Imaging；
使用System.Windows.Shapes；
使用系统图；
使用系统、绘图、成像；
名称空间SplashNS
{    
公共部分类文档窗口：窗口
{
公共文件；
[DllImport（“gdi32”）]
静态外部intdeleteObject（IntPtr o）；
专用位图源\u加载位图（System.Drawing.Bitmap源）
{
IntPtr ip=source.GetHbitmap（）；
BitmapSource bs=null；
尝试
{
bs=System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap（ip，
IntPtr.Zero，Int32Rect.Empty，
System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions（））；
}
最后
{
删除对象（ip）；
}
返回bs；
}
公共文档窗口（）
{
初始化组件（）；
位图画布=新位图（663356）；
BitmapData bmd=canvas.LockBits（新的System.Drawing.Rectangle（0，0，canvas.Width，canvas.Height），System.Drawing.Imaging.ImageLockMode.ReadOnly，canvas.PixelFormat）；
int PixelSize=4；
不安全的
{
对于（int y=0；y

不起作用。它生成一个白色位图，而不是所有蓝色像素的位图。不显示任何错误

---

我想，这一定是一个noob问题，但我是一个初学者。我想这一定是像素格式的问题，但我也可能是错误的…

我想问题是您在

标志
参数中指定了
图像锁定模式。只读

尝试使用
ImageLockMode.ReadWrite
（或
ImageLockMode.WriteOnly
）。
您似乎正在创建一个老式的
系统.Drawing.Bitmap
，然后将其转换为WPF，但是WPF有一套非常完整的实用程序，可以使用它从头开始创建位图。有关概述，请参阅本文：

例如，下面是创建给定大小和颜色的实心位图的代码：

public static class BitmapHelper
{
    public unsafe static BitmapSource CreateSolidBitmap(int width, int height, double dpiX, double dpiY, Color color)
    {
        var bitmap = new WriteableBitmap(width, height, dpiX, dpiY, PixelFormats.Pbgra32, null);
        var format = bitmap.Format;
        int blueIndex, greenIndex, redIndex, alphaIndex;
        int bitsPerPixel, bytesPerPixel;
        if (!TryParsePixelFormat(format, out bitsPerPixel, out bytesPerPixel, out blueIndex, out greenIndex, out redIndex, out alphaIndex))
            return null;
        var byteWidth = bytesPerPixel * width;
        bitmap.Lock();
        try
        {
            var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();
            for (int iRow = 0; iRow < height; iRow++)
            {
                var row = backBuffer + (iRow * bitmap.BackBufferStride);
                for (byte* pixel = row, endRow = row + byteWidth; pixel < endRow; pixel += bytesPerPixel)
                {
                    pixel[blueIndex] = color.B;
                    pixel[greenIndex] = color.G;
                    pixel[redIndex] = color.R;
                    if (alphaIndex >= 0)
                        pixel[alphaIndex] = color.A;
                }
            }
            bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));
        }
        finally
        {
            bitmap.Unlock();
        }
        return bitmap;
    }

    static int BlueIndex = 0;
    static int GreenIndex = 1;
    static int RedIndex = 2;
    static int AlphaIndex = 3;

    private static bool TryFindColorIndex(PixelFormatChannelMask mask, out int index)
    {
        var maskList = mask.Mask;
        for (int i = 0, count = maskList.Count; i < count; i++)
        {
            if (maskList[i] == 255)
            {
                index = i;
                return true;
            }
        }
        index = -1;
        return false;
    }

    static bool TryParsePixelFormat(PixelFormat format, out int bitsPerPixel, out int bytesPerPixel, out int blueIndex, out int greenIndex, out int redIndex, out int alphaIndex)
    {
        // Currently only implemented for non-indexed formats with 3 or 4 bytes
        // per color.
        bitsPerPixel = format.BitsPerPixel;
        if ((bitsPerPixel % 8) != 0)
        {
            bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
            return false;
        }

        bytesPerPixel = bitsPerPixel / 8;

        var masks = format.Masks;
        int maskCount = masks.Count;

        if (maskCount == 3 || maskCount == 4)
        {
            var blueMask = masks[BlueIndex];
            var greenMask = masks[GreenIndex];
            var redMask = masks[RedIndex];

            if (!TryFindColorIndex(blueMask, out blueIndex)
                || !TryFindColorIndex(greenMask, out greenIndex)
                || !TryFindColorIndex(redMask, out redIndex))
            {
                bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
                return false;
            }

            if (maskCount == 3)
            {
                alphaIndex = -1;
            }
            else
            {
                if (!TryFindColorIndex(masks[AlphaIndex], out alphaIndex))
                    alphaIndex = -1;
            }

            return true;
        }

        bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
        return false;
    }
}

96似乎在不可用时按惯例使用。
@Clemens-谢谢。我根据自己编写的一些代码改编了这个答案，将转换应用于可写位图。Microsoft显示的代码示例创建了一个索引位图，该位图较小（良好），但更难进一步修改（可能不好）。
    PresentationSource source = PresentationSource.FromVisual(this);

    double dpiX = 96.0, dpiY = 96.0;
    if (source != null)
    {
        dpiX = 96.0 * source.CompositionTarget.TransformToDevice.M11;
        dpiY = 96.0 * source.CompositionTarget.TransformToDevice.M22;
    }