WPF-事件系统底层原理.

┌─────────────────────────────────────────────┐
│           Class Handler (类级别)             │
│   通过 RegisterClassHandler 注册             │
│   存储在 EventManager 全局表中               │
│   优先执行，所有实例共享                      │
├─────────────────────────────────────────────┤
│         Instance Handler (实例级别)          │
│   通过 AddHandler / += 注册                  │
│   存储在每个 UIElement 实例的 EventHandlersStore │
│   后执行                                     │
└─────────────────────────────────────────────┘

// 在静态构造函数中注册
static MyButton()
{
    EventManager.RegisterClassHandler(
    	typeof(MyButton),
    	ButtonBase.ClickEvent,
    	new RoutedEventHandler(OnClickClassHandler),
    	handledEventsToo: false);		// 是否处理已标记 Handled 的事件
}

private static void OnClickClassHandler(object sender, RoutedEventArgs e)
{
    // 类级别处理,优先于实例处理器
}

// UIElement 内部简化：
public class UIElement : Visual
{
    private EventHandlersStore _eventHandlersStore;
    
    public void AddHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo)
    {
        if (_eventHandlersStore == null)
            _eventHandlersStore = new EventHandlersStore();
            
        _eventHandlersStore.AddRoutedEventHandler(routedEvent, handler, handledEventsToo);
    }
}

// UIElement.RaiseEvent 简化逻辑
public void RaiseEvent(RoutedEventArgs e)
{
    e.Source = this;
    
    // 1. 构建事件路由
    EventRoute route = new EventRoute(e.RoutedEvent);
    
    // 2. 沿可视树构建路由路径
    BuildRoute(route);
    
    // 3. 按路由策略调用处理器
    route.InvokeHandlers(e);
    
    e.Source = e.OriginalSource;
}

// 简化的路由构建过程
internal void BuildRoute(EventRoute route)
{
    // 从当前元素向上遍历可视树
    UIElement current = this;
    
    while (current != null)
    {
        // 将每个节点的处理器信息加入路由表
        current.AddToEventRoute(route);
        
        // 向上走到父元素
        current = VisualTreeHelper.GetParent(current) as UIElement;
    }
}

internal sealed class EventRoute
{
    private RoutedEvent _routedEvent;
    private List<RouteItem> _routeItemList;
    
    internal struct RouteItem
    {
        internal object Target; 	// 目标要素
        internal RoutedEventHandlerInfo Handler;	// 处理器信息
    }
}

对于路由上的每一个节点:

┌──────────────────────────────────┐
│ 1. Class Handlers (类级别)       │ ← 优先！无法被实例移除
│    按继承链从基类到派生类执行      │
│    UIElement → Control → Button  │
├──────────────────────────────────┤
│ 2. Instance Handlers (实例级别)  │ ← 按 AddHandler 注册顺序执行
└──────────────────────────────────┘

然后移动到路由上的下一个节点...

// 方法一： AddHandler 指定 handledEventsToo = true
grid.AddHandler(
	ButtonBase.ClickEvent,
	new RoutedEventHandler(Grid_Click),
	handledEventsToo: true);	//  <- 即使 Handled = true 也执行

// 方法二： 类级别注册时指定
EventManager.RegisterClassHandler(
	typeof(MyGrid),
	ButtonBase.ClickEvent,
	new RoutedEventHandler(OnClick),
	handledEventsToo: true);

用户点击 Button:

                    Tunnel 阶段 (Preview)
                    ─────────────────────
Step 1: Window.PreviewMouseDown     ↓
Step 2: Grid.PreviewMouseDown       ↓
Step 3: StackPanel.PreviewMouseDown ↓
Step 4: Button.PreviewMouseDown     ↓

                    Bubble 阶段
                    ─────────────────────
Step 5: Button.MouseDown            ↑
Step 6: StackPanel.MouseDown        ↑
Step 7: Grid.MouseDown              ↑
Step 8: Window.MouseDown            ↑

// 在输入系统中 (MouseDevice / KeyboardDevice)
// 简化的鼠标按下处理:

internal void ReportMouseDown(MouseButton button)
{
    // 1. 先触发 Tunnel 事件
    var previewArgs = new MouseButtonEventArgs(...);
    previewArgs.RoutedEvent = Mouse.PreviewMouseDownEvent;
    target.RaiseEvent(previewArgs);
    
    // 2. 再触发 Bubble 事件
    var args = new MouseButtonEventArgs(...);
    args.RoutedEvent = Mouse.MouseDownEvent;
    
    // 如果 Preview 阶段 Handled，Bubble 也跳过
    if (!previewArgs.Handled)
    {
        target.RaiseEvent(args);
    }
}

// Mouse 类定义了 MouseDown, 但任何 UIElement 都能使用
public static class Mouse
{
    public static readonly RoutedEvent MouseDownEvent = 
        EventManager.RegisterRoutedEvent(
    		"MouseDown",
    		RoutingStrategy.Bubble,
    		typeof(MouseButtonEventHandler),
    		typeof(Mouse));		// 拥有者是 Mouse 类， 不是 UIElement
    
    // 附加的 Add/Remove 方法
    public static void AddMouseDownHandler(DependencyObject d, MouseButtonEventHandler handler)
    {
        if (d is UIElement uie)
        {
            uie.AddHandler(MouseDownEvent, handler);
        }
    }
    
    public static void RemoveMouseDownHandler(DependencyObject d, MouseButtonEventHandler handler)
    {
        if (d is UIElement uie)
        {
            uie.RemoveHandler(MouseDownEvent, handler);
        }
    }
}

public class ButtonBase : ContentControl
{
    // 1. RoutedEvent 注册
    public static readonly RoutedEvent ClickEvent = 
        EventManger.RegisterRoutedEvent("Click", ...);
    
    // 2. CLR 事件包装器(XAML 解析器需要)
    public event RoutedEventHandler Click
    {
        add 	{ AddHandler(ClickEvent, value); }
        remove  { RemoveHandler(ClickEvent, value); }
    }
    
    // 触发事件
    protected virtual void OnClick()
    {
        RaiseEvent(new RoutedEventArgs(ClickEvent, this));
    }
}

用户鼠标点击屏幕
        │
        ▼
┌──────────────────┐
│   Win32 消息循环   │  WM_LBUTTONDOWN
│   (HwndSource)    │
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│   InputManager    │  WPF 输入管理器
│  (Dispatcher 线程) │
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│   MouseDevice     │  确定命中测试目标
│   HitTest         │  → 找到 Button
└────────┬─────────┘
         │
         ├──→ 构建 PreviewMouseDownEvent 的 EventRoute
         │        收集路由上所有节点的 Handler
         │        Window → Grid → StackPanel → Button
         │
         ├──→ Tunnel: 从 Window 到 Button 依次调用
         │        每个节点: ClassHandler → InstanceHandler
         │        检查 e.Handled
         │
         ├──→ 构建 MouseDownEvent 的 EventRoute
         │
         ├──→ Bubble: 从 Button 到 Window 依次调用
         │        每个节点: ClassHandler → InstanceHandler
         │        检查 e.Handled
         │
         ├──→ ButtonBase 内部逻辑判断 Click
         │
         ├──→ 构建 ClickEvent 的 EventRoute
         │
         └──→ Bubble: 从 Button 到 Window 依次调用
                 ClickEvent 的所有处理器

                    WPF RoutedEvent 系统
                    
  ┌──────────── 注册层 ────────────┐
  │  EventManager (全局注册表)      │
  │  RoutedEvent (事件标识)         │
  │  GlobalIndex (快速索引)         │
  └───────────────────────────────┘
                  │
  ┌──────────── 存储层 ────────────┐
  │  ClassHandler (全局共享)        │
  │  EventHandlersStore (实例私有)  │
  │  FrugalMap (轻量存储)           │
  └───────────────────────────────┘
                  │
  ┌──────────── 路由层 ────────────┐
  │  EventRoute (路由路径)          │
  │  BuildRoute (沿可视树构建)      │
  │  Tunnel / Bubble / Direct      │
  └───────────────────────────────┘
                  │
  ┌──────────── 调用层 ────────────┐
  │  InvokeHandlers                │
  │  ClassHandler 优先于 Instance   │
  │  Handled 机制控制传播           │
  └───────────────────────────────┘