WPF 性能优化深入

SunnyFan大约 17 分钟约 4985 字

WPF 性能优化深入

简介

WPF 的渲染管线基于 DirectX，提供了强大的图形能力，但也带来了独特的性能挑战。不当的控件使用、绑定方式、资源管理、图片处理等都可能导致界面卡顿、内存泄漏或高 CPU 占用。本文将深入分析 WPF 渲染管线、虚拟化、绑定优化、资源管理、内存泄漏排查等关键主题，帮助开发者构建流畅、高效的 WPF 应用。

特点

1.渲染管线优化 — 理解 WPF 渲染流程是优化的基础
2.虚拟化技术 — VirtualizingStackPanel 大幅降低大数据量渲染开销
3.绑定优化 — 减少不必要的绑定和通知
4.资源管理 — 合理使用和释放资源
5.Freezable 冻结 — 冻结不可变对象减少开销

渲染管线概述

WPF 渲染阶段

/// <summary>
/// WPF 渲染管线三个阶段：
/// 
/// 1. Measure（测量）— 计算每个元素期望的大小
///    调用 UIElement.Measure()，从子到父递归
/// 
/// 2. Arrange（排列）— 确定每个元素的最终位置和大小
///    调用 UIElement.Arrange()，从父到子分配
/// 
/// 3. Render（渲染）— 将可视化树渲染到屏幕
///    由 Dispatcher 优先级 Render 触发
///    底层使用 DirectX / MilCore
/// 
/// 性能瓶颈通常出现在：
/// - 过深的可视化树 → Measure/Arrange 开销大
/// - 频繁的属性变更 → 触发反复布局
/// - 复杂的绑定表达式 → 数据转换开销
/// - 大量非虚拟化数据 → 渲染过多元素
/// </summary>
public static class RenderPipeline
{
    /// <summary>
    /// 监控布局更新次数
    /// </summary>
    public static void EnableLayoutTracking()
    {
        // 使用 PresentationTraceSources 跟踪布局
        PresentationTraceSources.Refresh();
        PresentationTraceSources.DataBindingSource.Listeners.Add(
            new ConsoleTraceListener());
        PresentationTraceSources.DataBindingSource.Switch.Level =
            SourceLevels.Warning;
    }
}

减少布局更新

/// <summary>
/// 优化布局更新的策略
/// </summary>
public static class LayoutOptimization
{
    /// <summary>
    /// 批量更新时使用 Begin/EndInit 避免中间布局
    /// </summary>
    public static void BatchUpdate(Panel panel)
    {
        // 方式1：使用 BeginInit/EndInit
        ((ISupportInitialize)panel).BeginInit();
        try
        {
            for (int i = 0; i < 100; i++)
            {
                panel.Children.Add(new Button { Content = $"Item {i}" });
            }
        }
        finally
        {
            ((ISupportInitialize)panel).EndInit();
        }
    }

    /// <summary>
    /// 使用 Dispatcher 批量处理 UI 更新
    /// </summary>
    public static void BatchDispatcherUpdates(Window window)
    {
        // 将低优先级更新合并到一帧
        window.Dispatcher.BeginInvoke(DispatcherPriority.Background, () =>
        {
            // 在这里集中处理更新
            UpdateAllVisualElements();
        });
    }

    /// <summary>
    /// 使用 DispatcherFrame 手动控制渲染帧
    /// </summary>
    public static void ProcessPendingVisualUpdates()
    {
        // 强制处理所有挂起的 UI 操作
        DispatcherFrame frame = new DispatcherFrame();
        Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Render,
            new DispatcherOperationCallback(state =>
            {
                ((DispatcherFrame)state!).Continue = false;
                return null;
            }), frame);
        Dispatcher.PushFrame(frame);
    }

    private static void UpdateAllVisualElements() { }
}

虚拟化

VirtualizingStackPanel 深入

<!-- 
VirtualizingStackPanel 是 WPF 最重要的性能优化控件之一。
它只为当前可见区域创建 UI 元素，滚动时回收和创建元素。

默认情况下 ListBox、ListView、DataGrid 已使用 VirtualizingStackPanel。
但某些设置可能意外禁用虚拟化。
-->

<!-- 正确的虚拟化配置 -->
<ListBox
    VirtualizingPanel.IsVirtualizing="True"
    VirtualizingPanel.VirtualizationMode="Recycling"
    VirtualizingPanel.CacheLength="10,20"
    VirtualizingPanel.CacheLengthUnit="Item"
    VirtualizingPanel.ScrollUnit="Pixel"
    ScrollViewer.CanContentScroll="True">

    <ListBox.ItemTemplate>
        <DataTemplate>
            <!-- 保持模板简单 -->
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Name}" />
                <TextBlock Text="{Binding Value}" />
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

/// <summary>
/// 虚拟化配置详解与常见陷阱
/// </summary>
public class VirtualizationConfig
{
    /// <summary>
    /// 虚拟化模式：
    /// Standard — 滚动时销毁旧元素，创建新元素
    /// Recycling — 滚动时复用现有元素（推荐，性能更好）
    /// </summary>
    public static void EnableRecycling(ListBox listBox)
    {
        VirtualizingPanel.SetVirtualizationMode(listBox, VirtualizationMode.Recycling);
        VirtualizingPanel.SetIsVirtualizing(listBox, true);
    }

    /// <summary>
    /// 缓存长度 — 控制可见区域外缓存多少项
    /// CacheLength="10,20" 表示：
    ///   可见区域前缓存 10 项，可见区域后缓存 20 项
    /// </summary>
    public static void ConfigureCache(ListBox listBox)
    {
        VirtualizingPanel.SetCacheLength(listBox, (CacheLength)10);
        VirtualizingPanel.SetCacheLengthUnit(listBox, CacheLengthUnit.Item);
    }

    /// <summary>
    /// 注意：以下操作会禁用虚拟化！
    /// 1. 在 ItemTemplate 中使用 ScrollViewer
    /// 2. 将 ItemsPanel 替换为普通 StackPanel
    /// 3. 对 ItemContainerStyle 设置 Height 而不设置 MaxHeight
    /// 4. 使用 GroupStyle 且未启用虚拟化分组
    /// </summary>
    public static void AvoidVirtualizationKillers()
    {
        // 错误：使用普通 StackPanel 替换 ItemsPanel（禁用虚拟化）
        // <ListBox.ItemsPanel>
        //   <ItemsPanelTemplate>
        //     <StackPanel />  ← 虚拟化失效！
        //   </ItemsPanelTemplate>
        // </ListBox.ItemsPanel>

        // 正确：使用 VirtualizingStackPanel
        // <ListBox.ItemsPanel>
        //   <ItemsPanelTemplate>
        //     <VirtualizingStackPanel />
        //   </ItemsPanelTemplate>
        // </ListBox.ItemsPanel>
    }
}

延迟加载（Lazy Loading）

/// <summary>
/// 数据延迟加载 — 分页加载大数据集
/// </summary>
public class LazyLoadingViewModel : ObservableObject
{
    private readonly ObservableCollection<DataItem> _items = new();
    private int _currentPage = 0;
    private const int PageSize = 50;
    private bool _hasMoreItems = true;
    private bool _isLoading;

    public ObservableCollection<DataItem> Items => _items;

    public async Task LoadMoreItemsAsync()
    {
        if (_isLoading || !_hasMoreItems) return;

        _isLoading = true;

        try
        {
            var newItems = await FetchPageAsync(_currentPage + 1, PageSize);

            if (newItems.Count == 0)
            {
                _hasMoreItems = false;
                return;
            }

            _currentPage++;

            // 在 UI 线程上批量添加
            Application.Current.Dispatcher.Invoke(() =>
            {
                foreach (var item in newItems)
                {
                    _items.Add(item);
                }
            });
        }
        finally
        {
            _isLoading = false;
        }
    }

    /// <summary>
    /// 滚动到底部时自动加载更多
    /// </summary>
    public void OnScrollChanged(ScrollChangedEventArgs e)
    {
        if (e.VerticalOffset + e.ViewportHeight >= e.ExtentHeight * 0.9)
        {
            _ = LoadMoreItemsAsync();
        }
    }

    private Task<List<DataItem>> FetchPageAsync(int page, int size)
    {
        // 模拟数据获取
        return Task.FromResult(new List<DataItem>());
    }
}

public class DataItem
{
    public string Name { get; set; } = "";
    public double Value { get; set; }
}

可视化树优化

控制可视化树深度

/// <summary>
/// 可视化树复杂度直接影响布局性能
/// 每增加一层嵌套，Measure/Arrange 开销增加
/// 
/// 优化原则：
/// 1. 减少不必要的嵌套层级
/// 2. 使用轻量级控件
/// 3. 避免在 DataTemplate 中嵌套复杂结构
/// 4. 合并同类容器
/// </summary>
public class VisualTreeOptimization
{
    // 反模式：过度嵌套
    // <Grid>
    //   <Grid>
    //     <StackPanel>
    //       <Border>
    //         <Grid>
    //           <TextBlock Text="Hello" />  ← 5 层嵌套！
    //         </Grid>
    //       </Border>
    //     </StackPanel>
    //   </Grid>
    // </Grid>

    // 优化：扁平化结构
    // <Grid>
    //   <TextBlock Text="Hello" Margin="5" />  ← 2 层
    // </Grid>

    /// <summary>
    /// 分析可视化树复杂度
    /// </summary>
    public static int CountVisualTreeDepth(DependencyObject element)
    {
        int maxDepth = 0;
        int childCount = VisualTreeHelper.GetChildrenCount(element);

        for (int i = 0; i < childCount; i++)
        {
            var child = VisualTreeHelper.GetChild(element, i);
            int childDepth = CountVisualTreeDepth(child);
            maxDepth = Math.Max(maxDepth, childDepth);
        }

        return maxDepth + 1;
    }

    /// <summary>
    /// 输出可视化树统计
    /// </summary>
    public static (int ElementCount, int MaxDepth) AnalyzeVisualTree(FrameworkElement root)
    {
        int count = 0;
        int maxDepth = 0;

        void Traverse(DependencyObject obj, int depth)
        {
            count++;
            maxDepth = Math.Max(maxDepth, depth);

            int childCount = VisualTreeHelper.GetChildrenCount(obj);
            for (int i = 0; i < childCount; i++)
            {
                Traverse(VisualTreeHelper.GetChild(obj, i), depth + 1);
            }
        }

        Traverse(root, 1);
        return (count, maxDepth);
    }
}

绑定优化

高效数据绑定

/// <summary>
/// WPF 数据绑定优化策略
/// </summary>
public class BindingOptimization
{
    /// <summary>
    /// 1. 减少 PropertyChanged 通知范围
    /// </summary>
    public class OptimizedViewModel : ObservableObject
    {
        private string _firstName = "";
        private string _lastName = "";
        private string _fullName = "";

        public string FirstName
        {
            get => _firstName;
            set
            {
                if (SetProperty(ref _firstName, value))
                {
                    // 只在真正需要时通知相关属性
                    OnPropertyChanged(nameof(FullName));
                }
            }
        }

        public string LastName
        {
            get => _lastName;
            set
            {
                if (SetProperty(ref _lastName, value))
                {
                    OnPropertyChanged(nameof(FullName));
                }
            }
        }

        public string FullName => $"{_firstName} {_lastName}";
    }

    /// <summary>
    /// 2. 使用 BindingMode 减少开销
    /// OneTime — 只绑定一次（最轻量）
    /// OneWay — 单向（推荐只读数据）
    /// TwoWay — 双向（仅在需要时使用）
    /// </summary>
    public static void OptimizeBindingModes()
    {
        // XAML 中示例：
        // <TextBlock Text="{Binding Name, Mode=OneTime}" />
        // <TextBlock Text="{Binding Description, Mode=OneWay}" />
        // <TextBox Text="{Binding Input, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
    }

    /// <summary>
    /// 3. 避免在绑定中使用复杂 Converter
    /// </summary>
    public static void AvoidComplexConverters()
    {
        // 反模式：在 Converter 中执行复杂计算
        // <TextBlock Text="{Binding Price, Converter={StaticResource ComplexFormatter}}" />

        // 推荐：在 ViewModel 中提供格式化属性
        // public string FormattedPrice => Price.ToString("C");
        // <TextBlock Text="{Binding FormattedPrice, Mode=OneWay}" />
    }

    /// <summary>
    /// 4. 大集合使用 ReadOnlyObservableCollection 暴露
    /// </summary>
    public class CollectionBindingViewModel
    {
        private readonly ObservableCollection<Item> _items;
        private readonly ReadOnlyObservableCollection<Item> _readOnlyItems;

        public ReadOnlyObservableCollection<Item> Items => _readOnlyItems;

        public CollectionBindingViewModel()
        {
            _items = new ObservableCollection<Item>();
            _readOnlyItems = new ReadOnlyObservableCollection<Item>(_items);
        }

        public void AddItem(Item item)
        {
            _items.Add(item);
        }

        // 批量添加时先移除监听
        public void BatchAdd(IEnumerable<Item> newItems)
        {
            var list = newItems.ToList();
            if (list.Count > 10)
            {
                // 使用 BindingList 或直接操作
                foreach (var item in list)
                    _items.Add(item);
            }
            else
            {
                foreach (var item in list)
                    _items.Add(item);
            }
        }
    }

    /// <summary>
    /// 5. 使用 x:Shared="False" 避免共享资源冲突
    /// </summary>
}

public class Item
{
    public string Name { get; set; } = "";
}

异步绑定

/// <summary>
/// .NET 4.5+ 支持异步绑定 (Task / Task of T)
/// 通过 IsAsync=true 或绑定到 Task.Result
/// </summary>
public class AsyncBindingExample
{
    /// <summary>
    /// 使用 IsAsync 绑定避免 UI 阻塞
    /// </summary>
    public static void UseAsyncBinding()
    {
        // XAML:
        // <Image Source="{Binding LargeImage, IsAsync=True}" />
        //
        // IsAsync=True 时，绑定引擎在后台线程获取值
        // 适合耗时的属性访问（如从数据库/文件加载）
    }

    /// <summary>
    /// 使用 awaitable 属性模式
    /// </summary>
    public class AsyncDataViewModel : ObservableObject
    {
        private string _data = "Loading...";
        private Task<string>? _dataTask;

        public string Data
        {
            get => _data;
            private set => SetProperty(ref _data, value);
        }

        public async Task LoadDataAsync()
        {
            Data = "Loading...";
            try
            {
                string result = await FetchDataFromServiceAsync();
                Data = result;
            }
            catch (Exception ex)
            {
                Data = $"Error: {ex.Message}";
            }
        }

        private Task<string> FetchDataFromServiceAsync()
        {
            return Task.FromResult("Sample Data");
        }
    }
}

资源字典优化

资源管理策略

/// <summary>
/// ResourceDictionary 优化
/// </summary>
public class ResourceOptimization
{
    /// <summary>
    /// 1. 资源查找顺序（从快到慢）：
    ///    元素自身 → 父元素 → Application.Current → Theme
    ///    资源越靠近使用位置，查找越快
    /// </summary>
    public static void OptimizeResourceLocation()
    {
        // 高频使用的资源放在元素级别
        // <Window.Resources>
        //   <SolidColorBrush x:Key="LocalBrush">Red</SolidColorBrush>
        // </Window.Resources>

        // 全局共享的资源放在 Application 级别
        // <Application.Resources>
        //   <SolidColorBrush x:Key="GlobalBrush">Blue</SolidColorBrush>
        // </Application.Resources>
    }

    /// <summary>
    /// 2. 合并资源字典的优化
    /// </summary>
    public static void OptimizeMergedDictionaries()
    {
        // 反模式：在多个页面中重复合并同一个字典
        // <Page.Resources>
        //   <ResourceDictionary>
        //     <ResourceDictionary.MergedDictionaries>
        //       <ResourceDictionary Source="SharedStyles.xaml" />  ← 每个页面都加载
        //     </ResourceDictionary.MergedDictionaries>
        //   </ResourceDictionary>
        // </Page.Resources>

        // 优化：在 App.xaml 中统一合并
        // <Application.Resources>
        //   <ResourceDictionary>
        //     <ResourceDictionary.MergedDictionaries>
        //       <ResourceDictionary Source="Styles/Brushes.xaml" />
        //       <ResourceDictionary Source="Styles/Buttons.xaml" />
        //       <ResourceDictionary Source="Styles/Texts.xaml" />
        //     </ResourceDictionary.MergedDictionaries>
        //   </ResourceDictionary>
        // </Application.Resources>
    }
}

图片优化

图片加载与渲染优化

/// <summary>
/// WPF 图片性能优化
/// </summary>
public static class ImageOptimization
{
    /// <summary>
    /// 1. 正确加载图片 — 指定 DecodePixelWidth 避免加载大图
    /// </summary>
    public static BitmapImage LoadOptimizedImage(string path, int decodePixelWidth)
    {
        var bitmap = new BitmapImage();
        bitmap.BeginInit();
        bitmap.UriSource = new Uri(path, UriKind.RelativeOrAbsolute);
        bitmap.DecodePixelWidth = decodePixelWidth; // 只解码到指定宽度
        bitmap.CacheOption = BitmapCacheOption.OnLoad; // 立即加载，释放文件锁
        bitmap.EndInit();

        if (bitmap.CanFreeze)
            bitmap.Freeze(); // 冻结使其线程安全且不可变

        return bitmap;
    }

    /// <summary>
    /// 2. 图片列表延迟加载
    /// </summary>
    public class LazyImageLoader
    {
        private readonly Dictionary<string, BitmapImage> _cache = new();
        private readonly SemaphoreSlim _semaphore = new(4); // 最多4个并发加载

        public async Task<BitmapImage?> LoadImageAsync(string path, int targetSize)
        {
            if (_cache.TryGetValue(path, out var cached))
                return cached;

            await _semaphore.WaitAsync();
            try
            {
                var bitmap = await Task.Run(() => LoadOptimizedImage(path, targetSize));

                if (bitmap.CanFreeze)
                    bitmap.Freeze();

                _cache[path] = bitmap;
                return bitmap;
            }
            catch
            {
                return null;
            }
            finally
            {
                _semaphore.Release();
            }
        }

        public void ClearCache()
        {
            _cache.Clear();
        }
    }

    /// <summary>
    /// 3. 使用 RenderOptions 优化图片渲染
    /// </summary>
    public static void ConfigureRenderOptions(Image image)
    {
        // 高质量缩放（默认值，适合照片）
        RenderOptions.SetBitmapScalingMode(image, BitmapScalingMode.HighQuality);

        // 对于需要像素精确的图片（如条形码）
        // RenderOptions.SetBitmapScalingMode(image, BitmapScalingMode.NearestNeighbor);

        // 边缘模式
        RenderOptions.SetEdgeMode(image, EdgeMode.Aliased);
    }
}

文本渲染优化

文本渲染模式选择

/// <summary>
/// WPF 文本渲染优化
/// </summary>
public static class TextRenderingOptimization
{
    /// <summary>
    /// TextFormattingMode 选择：
    /// Display — 使用 GDI 兼容的文本渲染，更清晰（推荐）
    /// Ideal — WPF 原生渲染，支持亚像素定位
    /// </summary>
    public static void ConfigureTextRendering(Window window)
    {
        // 全局设置 Display 模式（推荐大多数场景）
        TextOptions.SetTextFormattingMode(window, TextFormattingMode.Display);

        // 文本渲染模式：
        // Auto — 自动选择
        // Grayscale — 灰度抗锯齿
        // Aliased — 无抗锯齿
        // ClearType — ClearType 亚像素渲染
        TextOptions.SetTextRenderingMode(window, TextRenderingMode.Auto);
    }

    /// <summary>
    /// 大量文本使用 FixedDocument/FlowDocument
    /// </summary>
    public static FlowDocument CreateOptimizedDocument()
    {
        var doc = new FlowDocument
        {
            PagePadding = new Thickness(10),
            TextAlignment = TextAlignment.Left,
            FontFamily = new FontFamily("Microsoft YaHei"),
            FontSize = 14
        };

        // 使用段落而不是大量 TextBlock
        var paragraph = new Paragraph(new Run("这是一段文本内容"))
        {
            Margin = new Thickness(0, 0, 0, 5)
        };

        doc.Blocks.Add(paragraph);
        return doc;
    }
}

Freezable 对象冻结

冻结不可变资源

/// <summary>
/// Freezable 冻结 — WPF 特有的性能优化机制
/// 
/// 冻结后的对象：
/// 1. 不再监听变更通知
/// 2. 变得线程安全
/// 3. 减少内存占用
/// 
/// 可以冻结的常见类型：
/// Brush、Pen、Transform、Geometry、BitmapImage 等
/// </summary>
public static class FreezableOptimization
{
    /// <summary>
    /// 冻结画笔资源
    /// </summary>
    public static void FreezeBrushes()
    {
        var solidBrush = new SolidColorBrush(Colors.Red);
        if (solidBrush.CanFreeze)
            solidBrush.Freeze();

        var linearBrush = new LinearGradientBrush(
            Colors.Blue, Colors.White,
            new Point(0, 0), new Point(1, 1));
        if (linearBrush.CanFreeze)
            linearBrush.Freeze();
    }

    /// <summary>
    /// 冻结变换
    /// </summary>
    public static void FreezeTransforms()
    {
        var rotateTransform = new RotateTransform(45);
        if (rotateTransform.CanFreeze)
            rotateTransform.Freeze();

        var scaleTransform = new ScaleTransform(1.5, 1.5);
        if (scaleTransform.CanFreeze)
            scaleTransform.Freeze();
    }

    /// <summary>
    /// 冻结几何图形
    /// </summary>
    public static void FreezeGeometries()
    {
        var geometry = Geometry.Parse("M10,10 L100,10 L100,100 L10,100 Z");
        if (geometry.CanFreeze)
            geometry.Freeze();
    }

    /// <summary>
    /// 在 ResourceDictionary 中使用冻结
    /// </summary>
    public static ResourceDictionary CreateFrozenResources()
    {
        var resources = new ResourceDictionary();

        var primaryBrush = new SolidColorBrush(Color.FromRgb(0x00, 0x78, 0xD4));
        primaryBrush.Freeze();
        resources["PrimaryBrush"] = primaryBrush;

        var borderPen = new Pen(Brushes.Gray, 1);
        if (borderPen.CanFreeze)
            borderPen.Freeze();
        resources["BorderPen"] = borderPen;

        return resources;
    }

    /// <summary>
    /// 批量冻结 ResourceDictionary 中的所有 Freezable
    /// </summary>
    public static void FreezeAllResources(ResourceDictionary resources)
    {
        foreach (var key in resources.Keys)
        {
            if (resources[key] is Freezable freezable && freezable.CanFreeze)
            {
                freezable.Freeze();
            }
        }
    }
}

内存泄漏检测

常见内存泄漏场景与修复

/// <summary>
/// WPF 常见内存泄漏场景及解决方案
/// </summary>
public class MemoryLeakPrevention
{
    /// <summary>
    /// 泄漏1：事件订阅未取消
    /// </summary>
    public class EventLeakExample
    {
        private readonly Window _window;
        private readonly MyService _service;

        public EventLeakExample(Window window)
        {
            _window = window;
            _service = new MyService();

            // 错误：强引用事件订阅
            _service.DataChanged += OnDataChanged;

            // 正确：使用弱事件模式
            WeakEventManager<MyService, EventArgs>
                .AddHandler(_service, nameof(MyService.DataChanged), OnDataChanged);
        }

        private void OnDataChanged(object? sender, EventArgs e) { }

        // 如果不使用 WeakEventManager，必须取消订阅
        public void Dispose()
        {
            _service.DataChanged -= OnDataChanged;
        }
    }

    /// <summary>
    /// 泄漏2：DispatcherTimer 未停止
    /// </summary>
    public class TimerLeakExample : IDisposable
    {
        private readonly DispatcherTimer _timer;

        public TimerLeakExample()
        {
            _timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromSeconds(1)
            };
            _timer.Tick += OnTimerTick;
            _timer.Start();
        }

        private void OnTimerTick(object? sender, EventArgs e) { }

        public void Dispose()
        {
            _timer.Stop();
            _timer.Tick -= OnTimerTick;
        }
    }

    /// <summary>
    /// 泄漏3：绑定到静态对象
    /// </summary>
    public class StaticBindingLeak
    {
        // 错误：绑定到静态单例会导致目标对象无法被 GC
        // public static ObservableCollection<Item> GlobalItems { get; }

        // 正确：使用弱引用或显式清理
        public static void ClearBindings(FrameworkElement element)
        {
            BindingOperations.ClearAllBindings(element);
        }
    }

    /// <summary>
    /// 泄漏4：DataContext 未清理
    /// </summary>
    public class DataContextLeak
    {
        // 页面/用户控件卸载时清理 DataContext
        public static void RegisterCleanup(FrameworkElement element)
        {
            element.Unloaded += (s, e) =>
            {
                if (s is FrameworkElement fe)
                {
                    // 清理 DataContext
                    fe.DataContext = null;

                    // 清理所有绑定
                    BindingOperations.ClearAllBindings(fe);
                }
            };
        }
    }
}

public class MyService
{
    public event EventHandler? DataChanged;
}

内存分析工具使用

/// <summary>
/// 内存分析工具集成
/// </summary>
public class MemoryProfiling
{
    /// <summary>
    /// 使用 dotMemory 单元测试集成
    /// NuGet: JetBrains.dotMemoryUnit
    /// </summary>
    public static void CheckForMemoryLeaks()
    {
        // 使用 WeakReference 检测对象是否被 GC 回收
        var weakRef = new WeakReference(null);

        // 创建对象
        var window = new Window();
        weakRef.Target = window;

        // 使用完毕后释放
        window.Close();
        window = null;

        // 强制 GC
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();

        // 检查是否已被回收
        bool isLeaked = weakRef.IsAlive;
        Console.WriteLine(isLeaked ? "内存泄漏！" : "对象已正确释放");
    }

    /// <summary>
    /// 运行时内存监控
    /// </summary>
    public static void StartMemoryMonitoring()
    {
        var timer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(5)
        };

        timer.Tick += (s, e) =>
        {
            var process = Process.GetCurrentProcess();
            long memoryMB = process.WorkingSet64 / (1024 * 1024);
            long privateMB = process.PrivateMemorySize64 / (1024 * 1024);
            int gen0Collections = GC.CollectionCount(0);
            int gen2Collections = GC.CollectionCount(2);

            Console.WriteLine(
                $"内存: {memoryMB}MB | " +
                $"私有: {privateMB}MB | " +
                $"Gen0 GC: {gen0Collections} | " +
                $"Gen2 GC: {gen2Collections}");
        };

        timer.Start();
    }
}

性能分析工具

WPF Performance Suite

/// <summary>
/// WPF 性能分析工具
/// 
/// 1. Perforator — 分析渲染性能
///    - 帧率（FPS）
///    - 脏区域比率
///    - 硬件/软件渲染
///    - 视频内存使用
/// 
/// 2. WPF Profiler — 分析布局性能
///    - 布局更新计数
///    - Measure/Arrange 耗时
///    - 可视化树节点数
/// 
/// 3. Visual Profiler — 分析控件性能
///    - 各控件的布局耗时
///    - 渲染开销排行
///    - 热路径分析
/// 
/// 4. dotTrace / dotMemory — JetBrains 全套分析
///    - CPU 性能剖析
///    - 内存分配追踪
///    - GC 暂停分析
/// </summary>
public static class PerformanceProfiling
{
    /// <summary>
    /// 代码中嵌入性能计数器
    /// </summary>
    public static PerformanceMetrics MeasureLayoutPerformance(FrameworkElement element)
    {
        var sw = Stopwatch.StartNew();

        // 强制一次完整布局
        element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
        long measureTime = sw.ElapsedTicks;

        sw.Restart();
        element.Arrange(new Rect(0, 0, element.DesiredSize.Width, element.DesiredSize.Height));
        long arrangeTime = sw.ElapsedTicks;

        sw.Restart();
        element.UpdateLayout();
        long updateTime = sw.ElapsedTicks;

        return new PerformanceMetrics
        {
            MeasureTicks = measureTime,
            ArrangeTicks = arrangeTime,
            UpdateTicks = updateTime,
            VisualChildren = CountVisualChildren(element),
            TreeDepth = VisualTreeOptimization.CountVisualTreeDepth(element)
        };
    }

    private static int CountVisualChildren(DependencyObject element)
    {
        int count = 0;
        int childCount = VisualTreeHelper.GetChildrenCount(element);
        for (int i = 0; i < childCount; i++)
        {
            count += 1 + CountVisualChildren(VisualTreeHelper.GetChild(element, i));
        }
        return count;
    }
}

public class PerformanceMetrics
{
    public long MeasureTicks { get; set; }
    public long ArrangeTicks { get; set; }
    public long UpdateTicks { get; set; }
    public int VisualChildren { get; set; }
    public int TreeDepth { get; set; }

    public override string ToString()
        => $"Measure: {MeasureTicks} ticks, Arrange: {ArrangeTicks} ticks, " +
           $"Children: {VisualChildren}, Depth: {TreeDepth}";
}

优点

1.优化效果显著 — 正确的优化可以带来 10-100 倍性能提升
2.用户体验提升 — 流畅的界面是用户满意度的关键
3.资源利用率降低 — 减少内存和 CPU 占用
4.可维护性 — 优化后的代码通常结构更清晰
5.可衡量 — 通过工具量化性能指标

缺点

1.学习曲线 — 需要深入理解 WPF 渲染管线
2.过早优化风险 — 可能优化不需要优化的地方
3.工具成本 — 专业性能分析工具可能需要付费
4.代码可读性 — 某些优化模式可能降低可读性
5.场景依赖 — 不同的优化策略适用于不同场景

性能注意事项

1.虚拟化是大数据列表的首要优化 — 没有虚拟化的列表是性能杀手
2.Freezable 冻结是零成本优化 — 没有理由不冻结不可变资源
3.DispatcherTimer 注意优先级 — 使用较低优先级避免阻塞 UI
4.大图片必须指定 DecodePixelWidth — 否则会加载全分辨率图片到内存
5.避免在 Layout 事件中执行耗时操作 — 每次布局更新都会触发

总结

WPF 性能优化是一项系统工程，从渲染管线理解到具体优化手段，每个环节都有改进空间。核心策略：控制可视化树复杂度、善用虚拟化、优化绑定方式、冻结 Freezable 资源、正确处理图片和文本渲染、及时检测内存泄漏。使用专业工具定位瓶颈，避免盲目优化。

关键知识点

WPF 渲染管线：Measure → Arrange → Render，理解管线才能找到瓶颈
VirtualizingStackPanel + Recycling 模式是大数据列表的必选项
Freezable.Freeze() 是零成本高性能优化
弱事件模式 (WeakEventManager) 防止事件导致的内存泄漏
BitmapImage.DecodePixelWidth 避免加载超大图片
TextFormattingMode.Display 提供更清晰的文本渲染
资源字典查找遵循元素→父元素→Application→Theme 的顺序
Dispatcher.PushFrame 可以手动控制渲染帧

常见误区

误区：WPF 很慢，不适合高性能应用
纠正：WPF 基于 DirectX，性能足够应对大多数桌面场景，慢的通常是不正确的使用方式
误区：所有集合都应该用 ObservableCollection
纠正：只对需要通知 UI 的集合使用，批量操作时考虑用 List 再整体替换
误区：虚拟化会自动生效
纠正：某些操作（如使用 ScrollViewer、GroupStyle）会禁用虚拟化
误区：内存泄漏只有 C++ 才有
纠正：WPF 的事件订阅、绑定、定时器等都是常见的泄漏源
误区：Dispatcher.Invoke 比 BeginInvoke 更安全
纠正：Invoke 会阻塞调用线程，可能导致死锁，优先使用 async/await 或 BeginInvoke

进阶路线

初级：启用虚拟化、冻结资源、设置正确的绑定模式
中级：分析可视化树深度、排查内存泄漏、优化图片加载
高级：使用性能分析工具定位瓶颈、自定义虚拟化面板
专家级：深入 WPF 渲染管线、自定义 DrawingVisual 高性能渲染

适用场景

大数据量列表/表格的流畅显示
实时数据监控面板
复杂布局的仪表盘应用
图片密集型的相册/查看器
长时间运行的工具类应用（内存泄漏敏感）

落地建议

项目初期即启用虚拟化和 Freezable 冻结
定期（每 sprint）运行内存泄漏检测
CI 中集成性能基准测试，监控关键指标变化
建立可视化树深度和元素数量的上限规范
培训团队成员识别常见的性能反模式
安装 WPF Performance Suite 作为开发环境标配

排错清单

复盘问题

列表滚动卡顿，如何定位是 Measure 还是 Render 阶段的瓶颈？
应用运行一段时间后越来越慢，可能的原因有哪些？
如何判断某个绑定是否造成了性能问题？
为什么设置了虚拟化但列表仍然很慢？
使用 DrawingVisual 和使用 UserControl 的性能差异有多大？
如何在代码中检测当前是硬件渲染还是软件渲染？
多个 ResourceDictionary 合并时查找性能如何优化？
如何实现自定义的虚拟化面板（非 StackPanel 布局）？