WPF菜单打开时标题栏最小化/最大化/关闭按钮单次点击无效

我太懂这个糟心的问题了——当WPF的Menu处于展开状态时，首次点标题栏的最小化、最大化或关闭按钮，居然只会把菜单收起来，得点第二次才会执行窗口操作。你试过ContextMenu/Popup的解决方案但对Menu无效，下面给你调整后的可行方案：

核心问题在于Menu展开时，窗口的消息处理被菜单拦截了，首次点击只会触发菜单失焦关闭，而不会传递到窗口按钮的命令逻辑。我们需要通过钩子窗口消息直接捕获标题栏按钮的点击动作，同时关闭菜单并执行对应的窗口操作。

完整实现代码 #

1. XAML命名空间引用 #

xmlns:controls="clr-namespace:TestProject.Controls"

2. MainWindow.xaml中的Menu配置 #

<Menu Style="{StaticResource CustomMenuStyle}" controls:MenuMouseEnhance.Enabled="True">
    <MenuItem Header="List of Items">
        <MenuItem Header="MenuOne" />
        <MenuItem Header="MenuTwo" />
    </MenuItem>
</Menu>

3. 修正后的MenuMouseEnhance.cs逻辑 #

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;

namespace TestProject.Controls
{
    public static class MenuMouseEnhance
    {
        public static bool GetEnabled(UIElement element)
        {
            return (bool)element.GetValue(EnabledProperty);
        }

        public static void SetEnabled(UIElement element, bool value)
        {
            element.SetValue(EnabledProperty, value);
        }

        public static readonly DependencyProperty EnabledProperty =
            DependencyProperty.RegisterAttached(
                "Enabled", 
                typeof(bool), 
                typeof(MenuMouseEnhance), 
                new PropertyMetadata(false, EnabledChanged));

        private static void EnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is Menu menu)
            {
                if ((bool)e.NewValue)
                {
                    menu.Opened += Menu_Opened;
                    menu.Closed += Menu_Closed;
                }
                else
                {
                    menu.Opened -= Menu_Opened;
                    menu.Closed -= Menu_Closed;
                }
            }
        }

        private static void Menu_Opened(object sender, RoutedEventArgs e)
        {
            if (sender is Menu menu)
            {
                Window window = Window.GetWindow(menu);
                if (window != null)
                {
                    HwndSource hwndSource = HwndSource.FromHwnd(new WindowInteropHelper(window).Handle);
                    if (hwndSource != null)
                    {
                        WindowHelper.Enable(hwndSource, window, menu);
                    }
                }
            }
        }

        private static void Menu_Closed(object sender, RoutedEventArgs e)
        {
            if (sender is Menu menu)
            {
                Window window = Window.GetWindow(menu);
                if (window != null)
                {
                    HwndSource hwndSource = HwndSource.FromHwnd(new WindowInteropHelper(window).Handle);
                    if (hwndSource != null)
                    {
                        WindowHelper.Disable(hwndSource);
                    }
                }
            }
        }

        private class WindowHelper
        {
            private static HwndSource _hwndSource;
            private static Window _window;
            private static Menu _menu;
            private static IntPtr _hookHandle;

            private static IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
            {
                const int WM_SETCURSOR = 0x0020;
                const int WM_LBUTTONDOWN = 0x0201;
                const int HTMINBUTTON = 8;
                const int HTMAXBUTTON = 9;
                const int HTCLOSE = 20;

                if (msg == WM_SETCURSOR)
                {
                    int hitTest = (int)lParam & 0xFFFF;
                    int mouseMsg = ((int)lParam & 0xFFFF0000) >> 16;

                    // 仅处理标题栏按钮的左键点击
                    if ((hitTest == HTMINBUTTON || hitTest == HTMAXBUTTON || hitTest == HTCLOSE) 
                        && mouseMsg == WM_LBUTTONDOWN)
                    {
                        // 先关闭展开的菜单
                        if (_menu != null && _menu.IsOpen)
                        {
                            _menu.IsOpen = false;
                        }

                        // 执行对应的窗口操作
                        switch (hitTest)
                        {
                            case HTMINBUTTON:
                                _window.WindowState = WindowState.Minimized;
                                break;
                            case HTMAXBUTTON:
                                _window.WindowState = _window.WindowState == WindowState.Maximized 
                                    ? WindowState.Normal 
                                    : WindowState.Maximized;
                                break;
                            case HTCLOSE:
                                _window.Close();
                                break;
                        }

                        handled = true;
                        return IntPtr.Zero;
                    }
                }

                return IntPtr.Zero;
            }

            public static void Enable(HwndSource hwndSource, Window window, Menu menu)
            {
                _hwndSource = hwndSource;
                _window = window;
                _menu = menu;
                _hookHandle = hwndSource.AddHook(WndProc);
            }

            public static void Disable(HwndSource hwndSource)
            {
                if (_hookHandle != IntPtr.Zero)
                {
                    hwndSource.RemoveHook(WndProc);
                    _hookHandle = IntPtr.Zero;
                }
            }
        }
    }
}

关键改进说明 #

• 绑定Menu自身的Opened/Closed事件，而非MenuItem的子菜单事件，确保顶级菜单展开时也能生效
• 捕获WM_LBUTTONDOWN消息，精准响应点击动作（而非之前的鼠标移动消息）
• 执行窗口操作前先关闭菜单，避免后续焦点混乱
• 统一管理钩子的添加与移除，防止内存泄漏

这样调整后，当菜单处于打开状态时，首次点击标题栏的最小化、最大化或关闭按钮，会直接关闭菜单并执行对应的窗口操作，无需二次点击。

内容的提问来源于stack exchange，提问作者DotNetSpartan