Question

我正试图像现在的“懒惰”VisualBrush一样实现某些东西。有没有人知道如何做到这一点？含义：某些行为类似于VisualBrush，但不会更新Visual中的每个更改，但最多每秒一次（或其他）。

我最好还是应该给出一些背景知识，为什么我这样做以及我猜测我想做的事情：）

问题：我现在的工作是提高相当大的WPF应用程序的性能。我跟踪了应用程序中使用的一些可视画笔的主要性能问题（无论如何在UI级别）。该应用程序包含一个带有一些相当复杂的UserControls的“桌面”区域和一个包含桌面缩小版本的导航区域。导航区域使用可视化笔刷完成工作。只要桌面项目或多或少是静态的，一切都很好。但是如果元素经常变化（因为它们包含动画），那么VisualBrushes就会变得疯狂。它们将随动画的帧速率一起更新。降低帧速率当然有帮助，但我正在寻找一个更普遍的解决方案来解决这个问题。虽然“源”控件仅渲染受动画影响的小区域，但可视刷子容器将完全呈现，从而导致应用程序性能下降到地狱。我已经尝试过使用BitmapCacheBrush。不幸的是没有帮助。动画在控件内。所以无论如何必须刷新刷子。

可能的解决方案：我创建的控件的行为或多或少类似于VisualBrush。它需要一些视觉效果（如VisualBrush），但使用DiapatcherTimer和RenderTargetBitmap来完成这项工作。现在我正在订阅控件的LayoutUpdated事件，每当它更改时，它将被安排为“渲染”（使用RenderTargetBitmap）。然后由DispatcherTimer触发实际渲染。这样，控件将在DispatcherTimer的频率中最大程度地重新绘制自身。

以下是代码：

public sealed class VisualCopy : Border
{
    #region private fields

    private const int mc_mMaxRenderRate = 500;
    private static DispatcherTimer ms_mTimer;
    private static readonly Queue<VisualCopy> ms_renderingQueue = new Queue<VisualCopy>();
    private static readonly object ms_mQueueLock = new object();

    private VisualBrush m_brush;
    private DrawingVisual m_visual;
    private Rect m_rect;
    private bool m_isDirty;
    private readonly Image m_content = new Image();
    #endregion

    #region constructor
    public VisualCopy()
    {
        m_content.Stretch = Stretch.Fill;
        Child = m_content;
    }
    #endregion

    #region dependency properties

    public FrameworkElement Visual
    {
        get { return (FrameworkElement)GetValue(VisualProperty); }
        set { SetValue(VisualProperty, value); }
    }

    // Using a DependencyProperty as the backing store for Visual.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty VisualProperty =
        DependencyProperty.Register("Visual", typeof(FrameworkElement), typeof(VisualCopy), new UIPropertyMetadata(null, OnVisualChanged));

    #endregion

    #region callbacks

    private static void OnVisualChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        var copy = obj as VisualCopy;
        if (copy != null)
        {
            var oldElement = args.OldValue as FrameworkElement;
            var newelement = args.NewValue as FrameworkElement;
            if (oldElement != null)
            {
                copy.UnhookVisual(oldElement);
            }
            if (newelement != null)
            {
                copy.HookupVisual(newelement);
            }
        }
    }

    private void OnVisualLayoutUpdated(object sender, EventArgs e)
    {
        if (!m_isDirty)
        {
            m_isDirty = true;
            EnqueuInPipeline(this);
        }
    }

    private void OnVisualSizeChanged(object sender, SizeChangedEventArgs e)
    {
        DeleteBuffer();
        PrepareBuffer();
    }

    private static void OnTimer(object sender, EventArgs e)
    {
        lock (ms_mQueueLock)
        {
            try
            {
                if (ms_renderingQueue.Count > 0)
                {
                    var toRender = ms_renderingQueue.Dequeue();
                    toRender.UpdateBuffer();
                    toRender.m_isDirty = false;
                }
                else
                {
                    DestroyTimer();
                }
            }
            catch (Exception ex)
            {
            }
        }
    }
    #endregion

    #region private methods
    private void HookupVisual(FrameworkElement visual)
    {
        visual.LayoutUpdated += OnVisualLayoutUpdated;
        visual.SizeChanged += OnVisualSizeChanged;
        PrepareBuffer();
    }

    private void UnhookVisual(FrameworkElement visual)
    {
        visual.LayoutUpdated -= OnVisualLayoutUpdated;
        visual.SizeChanged -= OnVisualSizeChanged;
        DeleteBuffer();
    }


    private static void EnqueuInPipeline(VisualCopy toRender)
    {
        lock (ms_mQueueLock)
        {
            ms_renderingQueue.Enqueue(toRender);
            if (ms_mTimer == null)
            {
                CreateTimer();
            }
        }
    }

    private static void CreateTimer()
    {
        if (ms_mTimer != null)
        {
            DestroyTimer();
        }
        ms_mTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(mc_mMaxRenderRate) };
        ms_mTimer.Tick += OnTimer;
        ms_mTimer.Start();
    }

    private static void DestroyTimer()
    {
        if (ms_mTimer != null)
        {
            ms_mTimer.Tick -= OnTimer;
            ms_mTimer.Stop();
            ms_mTimer = null;
        }
    }

    private RenderTargetBitmap m_targetBitmap;
    private void PrepareBuffer()
    {
        if (Visual.ActualWidth > 0 && Visual.ActualHeight > 0)
        {
            const double topLeft = 0;
            const double topRight = 0;
            var width = (int)Visual.ActualWidth;
            var height = (int)Visual.ActualHeight;
            m_brush = new VisualBrush(Visual);
            m_visual = new DrawingVisual();
            m_rect = new Rect(topLeft, topRight, width, height);
            m_targetBitmap = new RenderTargetBitmap((int)m_rect.Width, (int)m_rect.Height, 96, 96, PixelFormats.Pbgra32);
            m_content.Source = m_targetBitmap;
        }
    }

    private void DeleteBuffer()
    {
        if (m_brush != null)
        {
            m_brush.Visual = null;
        }
        m_brush = null;
        m_visual = null;
        m_targetBitmap = null;
    }

    private void UpdateBuffer()
    {
        if (m_brush != null)
        {
            var dc = m_visual.RenderOpen();
            dc.DrawRectangle(m_brush, null, m_rect);
            dc.Close();
            m_targetBitmap.Render(m_visual);
        }
    }

    #endregion
}

到目前为止这项工作非常好。唯一的问题是触发器。当我使用LayoutUpdated时，即使Visual本身根本没有改变，也会不断地触发渲染（可能是因为应用程序的其他部分或其他部分的动画）。 LayoutUpdated经常被解雇。事实上，我可以跳过触发器，只需使用定时器更新控件，无需任何触发器。没关系。我还尝试在Visual中覆盖OnRender并引发自定义事件以触发更新。不起作用，因为当VisualTree内部的某些内容发生变化时，不会调用OnRender。这是我现在最好的拍摄。它的工作原理比原来的VisualBrush解决方案要好得多（从性能的角度来看）。但我仍然在寻找更好的解决方案。

有没有人知道如何 a）仅在nessasarry时触发更新要么 b）以完全不同的方式完成工作？

感谢!!!

Answer 1

我通过反射使用WPF的内部监控了控件的可视状态。所以我编写的代码挂钩到CompositionTarget.Rendering事件，遍历树，并查找子树中的任何更改。我正在编写它来拦截被推送到MilCore的数据，然后将其用于我自己的目的，因此将此代码视为黑客而已。如果它对你有帮助，那很好。我在.NET 4上使用它。

首先，遍历树的代码读取状态标志：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Reflection;

namespace MilSnatch.Utils
{
    public static class VisualTreeHelperPlus
    {
        public static IEnumerable<DependencyObject> WalkTree(DependencyObject root)
        {
            yield return root;
            int count = VisualTreeHelper.GetChildrenCount(root);
            for (int i = 0; i < count; i++)
            {
                foreach (var descendant in WalkTree(VisualTreeHelper.GetChild(root, i)))
                    yield return descendant;
            }
        }

        public static CoreFlags ReadFlags(UIElement element)
        {
            var fieldInfo = typeof(UIElement).GetField("_flags", BindingFlags.Instance | BindingFlags.NonPublic);
            return (CoreFlags)fieldInfo.GetValue(element);
        }

        public static bool FlagsIndicateUpdate(UIElement element)
        {
            return (ReadFlags(element) &
                (
                    CoreFlags.ArrangeDirty |
                    CoreFlags.MeasureDirty |
                    CoreFlags.RenderingInvalidated
                )) != CoreFlags.None;
        }
    }

    [Flags]
    public enum CoreFlags : uint
    {
        AreTransformsClean = 0x800000,
        ArrangeDirty = 8,
        ArrangeInProgress = 0x20,
        ClipToBoundsCache = 2,
        ExistsEventHandlersStore = 0x2000000,
        HasAutomationPeer = 0x100000,
        IsCollapsed = 0x200,
        IsKeyboardFocusWithinCache = 0x400,
        IsKeyboardFocusWithinChanged = 0x800,
        IsMouseCaptureWithinCache = 0x4000,
        IsMouseCaptureWithinChanged = 0x8000,
        IsMouseOverCache = 0x1000,
        IsMouseOverChanged = 0x2000,
        IsOpacitySuppressed = 0x1000000,
        IsStylusCaptureWithinCache = 0x40000,
        IsStylusCaptureWithinChanged = 0x80000,
        IsStylusOverCache = 0x10000,
        IsStylusOverChanged = 0x20000,
        IsVisibleCache = 0x400000,
        MeasureDirty = 4,
        MeasureDuringArrange = 0x100,
        MeasureInProgress = 0x10,
        NeverArranged = 0x80,
        NeverMeasured = 0x40,
        None = 0,
        RenderingInvalidated = 0x200000,
        SnapsToDevicePixelsCache = 1,
        TouchEnterCache = 0x80000000,
        TouchesCapturedWithinCache = 0x10000000,
        TouchesCapturedWithinChanged = 0x20000000,
        TouchesOverCache = 0x4000000,
        TouchesOverChanged = 0x8000000,
        TouchLeaveCache = 0x40000000
    }

}

接下来，支持渲染事件的代码：

//don't worry about RenderDataWrapper. Just use some sort of WeakReference wrapper for each UIElement
    void CompositionTarget_Rendering(object sender, EventArgs e)
{
    //Thread.Sleep(250);
    Dictionary<int, RenderDataWrapper> newCache = new Dictionary<int, RenderDataWrapper>();
    foreach (var rawItem in VisualTreeHelperPlus.WalkTree(m_Root))
    {
        var item = rawItem as FrameworkElement;
        if (item == null)
        {
            Console.WriteLine("Encountered non-FrameworkElement: " + rawItem.GetType());
            continue;
        }
        int hash = item.GetHashCode();
        RenderDataWrapper cacheEntry;
        if (!m_Cache.TryGetValue(hash, out cacheEntry))
        {
            cacheEntry = new RenderDataWrapper();
            cacheEntry.SetControl(item);
            newCache.Add(hash, cacheEntry);
        }
        else
        {
            m_Cache.Remove(hash);
            newCache.Add(hash, cacheEntry);
        }
            //check the visual for updates - something like the following...
            if(VisualTreeHelperPlus.FlagsIndicateUpdate(item as UIElement))
            {
                //flag for new snapshot.
            }
        }
    m_Cache = newCache;
}

无论如何，通过这种方式，我监控了可视化树的更新，我认为如果您愿意，可以使用类似的东西监控它们。这远非最佳实践，但有时必须使用务实的代码。当心。

Answer 2

我认为您的解决方案已经非常好了。您可以尝试使用具有ApplicationIdle优先级的Dispatcher回调来执行此操作，而这将有效地使更新变得懒惰，因为它只会在应用程序不忙时发生。此外，正如您已经说过的，您可能会尝试使用BitmapCacheBrush而不是VisualBrush来绘制概览图像和看看这是否有所不同。

关于何时重绘画笔的问题：

基本上你想知道什么时候发生了变化，将现有的缩略图标记为脏。

我认为你可以在后端/模型中攻击这个问题，并在那里有一个脏标志或试图从前端获取它。

后端显然取决于您的应用程序，因此我无法发表评论。

在前端，LayoutUpdated事件似乎是正确的事情，但正如你所说，它可能比必要时更频繁地发射。

这是一个黑暗中的镜头 - 我不知道LayoutUpdated如何在内部工作，因此它可能与LayoutUpdated具有相同的问题：您可以覆盖要观察的控件中的ArrangeOverride。每当调用ArrangeOverride时，您都会使用调度程序触发自己的布局更新事件，以便在布局传递完成后触发它。（甚至可能等待几毫秒的时间，如果同时调用新的ArrangeOverride，则不排队更多事件）。由于布局过程总是会调用Measure然后排列并向上移动树，这应该涵盖控件内任何位置的任何变化。

WPF“懒惰”VisualBrush

2 个答案: