深入 WPF：构建高性能桌面应用的核心技术剖析

UI 线程                       渲染线程
────────                      ─────────
OnRender()  →  记录指令流  →  MilCore 指令缓冲
              (RenderData)          ↓
                              构建/更新 D3D 资源
                                    ↓
                              GPU 合成 → 显示

protected override void OnRender(DrawingContext dc)
{
    // ✅ 正确：只做指令录制，所有几何对象预先构造并 Freeze
    dc.DrawGeometry(_frozenBrush, _frozenPen, _cachedGeometry);

    // ❌ 错误：每帧分配新对象，触发 GC 与依赖属性系统开销
    // dc.DrawRectangle(new SolidColorBrush(Color.FromRgb(255,0,0)), null, rect);
}

await Dispatcher.Yield(DispatcherPriority.Input);

// 方案 A：同步 Invoke —— 调用线程阻塞，等待 UI 线程执行
// 风险：UI 线程若正等待调用线程，直接死锁
Application.Current.Dispatcher.Invoke(() => _textBlock.Text = "x");

// 方案 B：异步 BeginInvoke —— 推荐，无死锁风险
Application.Current.Dispatcher.BeginInvoke(
    DispatcherPriority.Background,
    new Action(() => _textBlock.Text = "x"));

// 方案 C：async/await —— 语法糖，本质仍是 BeginInvoke
await Dispatcher.InvokeAsync(() => _textBlock.Text = "x");

public static void DoEvents()
{
    var frame = new DispatcherFrame();
    Dispatcher.CurrentDispatcher.BeginInvoke(
        DispatcherPriority.Background,
        new DispatcherOperationCallback(f => { ((DispatcherFrame)f!).Continue = false; return null; }),
        frame);
    Dispatcher.PushFrame(frame);   // 在此处泵消息，直到 Continue = false
}

DependencyProperty（全局单例）
  ├─ GlobalIndex : int          ← 全局唯一索引
  ├─ PropertyType
  └─ Metadata

DependencyObject
  └─ _effectiveValues : EffectiveValueEntry[]   ← 稀疏数组，按 GlobalIndex 索引

1.  CoerceValueCallback 强制转换
2.  动画 (Animation)
3.  本地值 (SetValue / XAML 直接赋值)
4.  TemplatedParent 的模板触发器
5.  TemplatedParent 的模板 Setter
6.  隐式 Style
7.  Style Trigger
8.  Template Trigger
9.  Style Setter
10. 主题 Style Trigger
11. 主题 Style Setter
12. 属性继承 (Inherits)
13. 元数据默认值 (DefaultValue)

var brush = new SolidColorBrush(Color.FromRgb(0, 120, 215));
brush.Freeze();   // ✅ 冻结后：无锁、可跨线程、可被渲染线程直接引用

// 冻结后尝试修改会抛 InvalidOperationException
// brush.Color = Colors.Red;  // 💥

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Media;

namespace HighPerf.Wpf.Controls;

/// <summary>
/// 高性能实时曲线控件：环形缓冲区 + DrawingVisual 分层渲染。
/// </summary>
public sealed class RealTimeChart : FrameworkElement
{
    private const int Capacity = 1 << 17;   // 131072 点

    // ── 视觉层：网格 / 曲线 / 游标分离，各自独立失效 ──
    private readonly VisualCollection _layers;
    private readonly DrawingVisual _gridLayer   = new();
    private readonly DrawingVisual _seriesLayer = new();
    private readonly DrawingVisual _cursorLayer = new();

    // ── 数据：环形缓冲区，O(1) 写入 ──
    private readonly double[] _buffer = new double[Capacity];
    private int _head;      // 下一个写入位置
    private int _count;     // 有效数据量

    // ── 渲染资源：全部冻结 ──
    private readonly Pen   _seriesPen;
    private readonly Pen   _gridPen;
    private readonly Brush _axisBrush;

    private bool _seriesDirty = true;

    public RealTimeChart()
    {
        _layers = new VisualCollection(this) { _gridLayer, _seriesLayer, _cursorLayer };

        _seriesPen = new Pen(new SolidColorBrush(Color.FromRgb(0, 200, 255)), 1.4);
        _seriesPen.Freeze();

        _gridPen = new Pen(new SolidColorBrush(Color.FromArgb(40, 255, 255, 255)), 0.6);
        _gridPen.Freeze();

        _axisBrush = new SolidColorBrush(Color.FromArgb(120, 255, 255, 255));
        _axisBrush.Freeze();

        // 挂接到合成帧回调，统一节流刷新
        CompositionTarget.Rendering += OnCompositionRendering;
    }

    // ══════════════ 视觉树契约 ══════════════

    protected override int VisualChildrenCount => _layers.Count;

    protected override Visual GetVisualChild(int index)
    {
        if ((uint)index >= (uint)_layers.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
        return _layers[index];
    }

    // ══════════════ 数据写入 API ══════════════

    /// <summary>追加一批采样点。可在任意线程调用。</summary>
    public void Append(ReadOnlySpan<double> samples)
    {
        lock (_buffer)
        {
            foreach (var v in samples)
            {
                _buffer[_head] = v;
                _head = (_head + 1) & (Capacity - 1);
                if (_count < Capacity) _count++;
            }
        }
        _seriesDirty = true;   // 仅置标志，不立即重绘
    }

    // ══════════════ 帧回调：批量合并重绘 ══════════════

    private void OnCompositionRendering(object? sender, EventArgs e)
    {
        if (!_seriesDirty) return;
        _seriesDirty = false;
        RenderSeries();
    }

    // ══════════════ 渲染 ══════════════

    protected override void OnRenderSizeChanged(SizeChangedInfo info)
    {
        base.OnRenderSizeChanged(info);
        RenderGrid();
        _seriesDirty = true;
    }

    private void RenderGrid()
    {
        using var dc = _gridLayer.RenderOpen();
        double w = ActualWidth, h = ActualHeight;
        if (w <= 0 || h <= 0) return;

        const int divisions = 8;
        for (int i = 0; i <= divisions; i++)
        {
            double y = h * i / divisions;
            dc.DrawLine(_gridPen, new Point(0, y), new Point(w, y));
            double x = w * i / divisions;
            dc.DrawLine(_gridPen, new Point(x, 0), new Point(x, h));
        }
    }

    private void RenderSeries()
    {
        double w = ActualWidth, h = ActualHeight;
        if (w <= 0 || h <= 0 || _count < 2)
        {
            using var empty = _seriesLayer.RenderOpen();
            return;
        }

        // 1. 在锁内一次性快照，避免渲染过程中数据被写
        double[] snapshot;
        int count, head;
        lock (_buffer)
        {
            count = _count;
            head  = _head;
            snapshot = new double[count];
            // 环形缓冲区展开为线性数组
            int start = (head - count + Capacity) & (Capacity - 1);
            if (start + count <= Capacity)
            {
                Array.Copy(_buffer, start, snapshot, 0, count);
            }
            else
            {
                int first = Capacity - start;
                Array.Copy(_buffer, start, snapshot, 0, first);
                Array.Copy(_buffer, 0, snapshot, first, count - first);
            }
        }

        // 2. 降采样：像素宽度决定实际可渲染点数
        int targetPoints = Math.Min(count, (int)w * 2);
        var (minMax, step) = Downsample(snapshot, targetPoints);

        // 3. 构建 StreamGeometry（比 PathGeometry 轻量，且支持 Freeze）
        var geo = new StreamGeometry();
        using (var ctx = geo.Open())
        {
            double xScale = w / (minMax.Length - 1);
            ctx.BeginFigure(new Point(0, ToY(minMax[0].Max, h)), false, false);
            for (int i = 1; i < minMax.Length; i++)
            {
                // 用 min/max 两个点形成垂直段，保留信号包络
                ctx.LineTo(new Point(i * xScale, ToY(minMax[i].Max, h)), true, false);
                ctx.LineTo(new Point(i * xScale, ToY(minMax[i].Min, h)), true, false);
            }
        }
        geo.Freeze();

        // 4. 一次性提交到视觉层
        using var dc = _seriesLayer.RenderOpen();
        dc.DrawGeometry(null, _seriesPen, geo);
    }

    /// <summary>按列取 min/max，保证不丢失尖峰。</summary>
    private static ((double Min, double Max)[] buckets, int step) Downsample(double[] src, int target)
    {
        int step = Math.Max(1, src.Length / target);
        int n = src.Length / step;
        var result = new (double, double)[n];

        for (int i = 0; i < n; i++)
        {
            double min = double.MaxValue, max = double.MinValue;
            int offset = i * step;
            for (int j = 0; j < step; j++)
            {
                double v = src[offset + j];
                if (v < min) min = v;
                if (v > max) max = v;
            }
            result[i] = (min, max);
        }
        return (result, step);
    }

    private static double ToY(double value, double height)
        => height * 0.5 - value * height * 0.4;   // 简单映射，实际项目应接入坐标轴
}

public sealed class VirtualizingCollection<T> : IList<T>, IList, INotifyCollectionChanged
    where T : class
{
    private readonly IDataPageProvider<T> _provider;   // 分页数据源
    private readonly Dictionary<int, T[]> _pages = new();
    private const int PageSize = 128;

    public VirtualizingCollection(IDataPageProvider<T> provider)
    {
        _provider = provider;
        TotalCount = provider.GetTotalCount();
    }

    public int TotalCount { get; }

    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= TotalCount)
                throw new ArgumentOutOfRangeException(nameof(index));

            int pageIndex = index / PageSize;
            if (!_pages.TryGetValue(pageIndex, out var page))
            {
                page = _provider.GetPage(pageIndex, PageSize);
                _pages[pageIndex] = page;
                // 简单的 LRU：超过 32 页则清空（生产环境建议用真正的 LRU 链表）
                if (_pages.Count > 32) _pages.Clear();
            }

            return page[index % PageSize];
        }
        set => throw new NotSupportedException();
    }

    public event NotifyCollectionChangedEventHandler? CollectionChanged;
    public int Count => TotalCount;
    public bool IsReadOnly => true;

    // IEnumerator 实现略（建议实现为按需拉取，避免 foreach 触发全量加载）
    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < TotalCount; i++)
            yield return this[i];
    }
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    public int IndexOf(T item) => -1;
    public void Insert(int index, T item) => throw new NotSupportedException();
    public void RemoveAt(int index) => throw new NotSupportedException();
    public void Add(T item) => throw new NotSupportedException();
    public void Clear() => throw new NotSupportedException();
    public bool Contains(T item) => false;
    public void CopyTo(T[] array, int arrayIndex) { }
    public bool Remove(T item) => false;
    public bool IsFixedSize => true;
    public object? this[int index] { get => this[index]; set => throw new NotSupportedException(); }
    public bool IsSynchronized => false;
    public object SyncRoot => this;
    public int Add(object? value) => throw new NotSupportedException();
    public bool Contains(object? value) => false;
    public int IndexOf(object? value) => -1;
    public void Insert(int index, object? value) => throw new NotSupportedException();
    public void Remove(object? value) => throw new NotSupportedException();
    public void CopyTo(Array array, int index) { }
}

// ✅ 唯一合法场景：事件处理器
private async void OnButtonClick(object sender, RoutedEventArgs e)
{
    try
    {
        await LongRunningAsync();
    }
    catch (Exception ex)
    {
        // 必须捕获！否则异常会直接崩溃进程（无法被上层 try/catch 捕获）
        ShowError(ex);
    }
}

// ❌ 其他所有场景都用 async Task
public async Task LoadDataAsync() { ... }

// 在 UI 事件处理器中：需要回到 UI 线程
var data = await service.FetchAsync().ConfigureAwait(true);   // 或省略
_textBlock.Text = data;

// 在类库中：不需要回 UI 线程，用 ConfigureAwait(false) 避免上下文捕获开销
public async Task<string> FetchAsync()
{
    var json = await _http.GetStringAsync(url).ConfigureAwait(false);
    return Parse(json);
}

// ✅ 正确：Progress<T> 会在创建它的线程（UI 线程）上回调
var progress = new Progress<int>(p => _progressBar.Value = p);
await Task.Run(() => HeavyWork(progress));

// Progress<T> 的内部实现等价于：
// void Report(T value) => _syncContext.Post(_ => _handler(value), null);

// App.xaml.cs
PresentationTraceSources.Refresh();
PresentationTraceSources.DataBindingSource.Listeners.Add(
    new ConsoleTraceListener());
PresentationTraceSources.DataBindingSource.Switch.Level = SourceLevels.Warning;

<TextBlock Text="{Binding Name,
    PresentationTraceSources.TraceLevel=High}" />