问WPF中的低分配图

EN

using System;
using System.Drawing;
using System.Windows;
using SWM = System.Windows.Media;
using SWMI = System.Windows.Media.Imaging;

public class GdiGraphicsWriteableBitmap
{
    readonly Action<Rectangle, Graphics> m_draw;
    SWMI.WriteableBitmap m_wpfBitmap = null;
    Bitmap m_gdiBitmap = null;

    public GdiGraphicsWriteableBitmap(Action<Rectangle, Graphics> draw)
    {
        if (draw == null) { throw new ArgumentNullException(nameof(draw)); }
        m_draw = draw;
    }

    public SWMI.WriteableBitmap WriteableBitmap => m_wpfBitmap;

    public bool IfNewSizeResizeAndDraw(int width, int height)
    {
        if (m_wpfBitmap == null ||
            m_wpfBitmap.PixelHeight != height ||
            m_wpfBitmap.PixelWidth != width)
        {
            Reset();
            // Can't dispose wpf
            const double Dpi = 96;
            m_wpfBitmap = new SWMI.WriteableBitmap(width, height, Dpi, Dpi,
                SWM.PixelFormats.Bgr24, null);
            var ptr = m_wpfBitmap.BackBuffer;
            m_gdiBitmap = new Bitmap(width, height, m_wpfBitmap.BackBufferStride,
                System.Drawing.Imaging.PixelFormat.Format24bppRgb, ptr);

            Draw();

            return true;
        }
        return false;
    }

    public void Draw()
    {
        if (m_wpfBitmap != null)
        {
            m_wpfBitmap.Lock();
            int width = m_wpfBitmap.PixelWidth;
            int height = m_wpfBitmap.PixelHeight;
            {
                using (var g = Graphics.FromImage(m_gdiBitmap))
                {
                    m_draw(new Rectangle(0, 0, width, height), g);
                }
            }
            m_wpfBitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));
            m_wpfBitmap.Unlock();
        }
    }

    // If window containing this is not shown, one can Reset to stop draw or similar...
    public void Reset()
    {
        m_gdiBitmap?.Dispose();
        m_wpfBitmap = null;
    }
}

    <Grid x:Name="ImageContainer" SnapsToDevicePixels="True">
        <Image x:Name="ImageSource" 
               RenderOptions.BitmapScalingMode="HighQuality" SnapsToDevicePixels="True">
        </Image>
    </Grid>

public partial class SomeView : UserControl
{
    ISizeChangedViewModel m_viewModel = null;

    public SomeView()
    {
        InitializeComponent();

        this.DataContextChanged += OnDataContextChanged;
    }

    void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        if (m_viewModel != null)
        {
            this.ImageContainer.SizeChanged -= ImageSource_SizeChanged;
        }
        m_viewModel = e.NewValue as ISizeChangedViewModel;
        if (m_viewModel != null)
        {
            this.ImageContainer.SizeChanged += ImageSource_SizeChanged;
        }
    }

    private void ImageSource_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        var newSize = e.NewSize;
        var width = (int)Math.Round(newSize.Width);
        var height = (int)Math.Round(newSize.Height);
        m_viewModel?.SizeChanged(width, height);
    }
}

<Grid>
    <WindowsFormsHost x:Name="WinFormsHost>
        <custom:Canvas x:Name="Canvas" />
    </WindowsFormsHost>
</Grid>

public partial class Canvas 
    : UserControl
{
    // Implementing custom double buffered graphics, since this is a lot
    // faster both when drawing and with respect to GC, since normal
    // double buffered graphics leaks disposable objects that the GC needs to finalize
    protected BufferedGraphicsContext m_bufferedGraphicsContext = 
        new BufferedGraphicsContext();
    protected BufferedGraphics m_bufferedGraphics = null;
    protected Rectangle m_currentClientRectangle = new Rectangle();

    public Canvas()
    {
        InitializeComponent();
        Setup();
    }

    private void Setup()
    {
        SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint |
                 ControlStyles.Opaque | ControlStyles.ResizeRedraw, true);
        DoubleBuffered = false;

        this.Dock = DockStyle.Fill;
    }

    private void DisposeManagedResources()
    {
        m_bufferedGraphicsContext.Dispose();
        if (m_bufferedGraphics != null)
        {
            m_bufferedGraphics.Dispose();
        }
    }

    protected override void OnPaintBackground(PaintEventArgs e)
    {
        // Background paint is done in OnPaint
        // This reduces the "leaks" of System.Windows.Forms.Internal.DeviceContext 
        // and the amount of "GC" handles created considerably
        // as found by using CLR Profiler
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        // Specifically not calling base here since we draw entire area ourselves
        // base.OnPaint(e);
        // Should this be disposed? 
        using (e)
        using (var targetGraphics = e.Graphics)
        {
            ReallocBufferedGraphics(targetGraphics);

            // Use buffered graphics object
            var graphics = m_bufferedGraphics.Graphics;
            // Raise paint event
            PaintEvent?.Invoke(this.ClientRectangle, e.ClipRectangle, graphics);

            // Render to target graphics i.e. paint event args graphics
            m_bufferedGraphics.Render(targetGraphics);
        }
    }

    protected virtual void ReallocBufferedGraphics(Graphics graphics)
    {
        Rectangle newClientRectangle = this.ClientRectangle;

        // Realloc if new client rectangle is not contained within the current
        // or if no buffered graphics exists
        bool reallocBufferedGraphics = ShouldBufferBeReallocated(newClientRectangle);
        if (reallocBufferedGraphics)
        {
            if (m_bufferedGraphics != null)
            {
                m_bufferedGraphics.Dispose();
            }
            m_bufferedGraphics = m_bufferedGraphicsContext.Allocate(
                 graphics, newClientRectangle);
            m_currentClientRectangle = newClientRectangle;
        }
    }

    protected virtual bool ShouldBufferBeReallocated(Rectangle newClientRectangle)
    {
        return !m_currentClientRectangle.Contains(newClientRectangle) || 
                m_bufferedGraphics == null;
    }

    /// <summary>
    /// PaintEvent with <c>clientRectangle, clipRectangle, graphics</c> for the canvas.
    /// </summary>
    public event Action<Rectangle, Rectangle, Graphics> PaintEvent;
}