在 C# 中监听另一个窗口调整大小事件

Question

我正在实现一个小型应用程序（观察者），它需要将自身“附加”到另一个窗口（观察者）的底部。后者不是应用程序内的窗口。

此时，我通过获取窗口的 hWnd 并在线程中定期查询观察到的窗口的位置，相应地移动观察者窗口来解决。

然而，这是一个非常不优雅的解决方案。我想做的是监听被观察窗口的调整大小事件，以便观察者仅在必要时做出反应。

我认为我应该使用钩子，并且我发现了很多方法来做到这一点，但是我对 C WinAPI 的缺乏知识阻碍了我理解我需要创建哪个钩子以及如何创建（pinvoke/参数/等）。

我很确定这是非常微不足道的，并且一些熟悉 C/C++ 和 WinAPI 的人会手头有答案；）

谢谢

Answer 1

扩展 Chris Taylor 的答案：您可以使用 ManagedWinApi，而不是自己进行本机互操作，其中包含 钩子类。

编辑：使用 ManagedWinApi。代码中的某个位置：

Hook MyHook = new Hook(HookType.WH_CALLWNDPROC, false, false);
MyHook.Callback += MyHookCallback;
MyHook StartHook();

对于回调，请参考 CallWndProc 和 CWPSTRUCT：

private static int MyHookCallback(int code, IntPtr wParam, IntPtr lParam, ref bool callNext)
{
    if (code >= 0)
    {
        // You will need to define the struct
        var message = (CWPSTRUCT)Marshal.PtrToStructure(lParam, typeof(CWPSTRUCT));
        // Do something with the data
    }
    return 0; // Return value is ignored unless you set callNext to false
}

Answer 2

我在使用的一些代码中遇到了同样的问题，并发现我无法将托管 .DLL 注入到进程中。

由于不想编写使用 SetWindowsHook 的 C++ 非托管 DLL，我结合使用了 SetWinEventHook，它在窗口开始和结束移动事件时发出信号，并使用 Timer 进行轮询窗口移动时使其看起来跟随窗口移动。

这是一个可以做到这一点的类的（非常简化的）版本（只需用移动窗口或引发事件的代码替换 TODO）。

public class DockingHelper
{
    private readonly uint m_processId, m_threadId;

    private readonly IntPtr m_target;

    // Needed to prevent the GC from sweeping up our callback
    private readonly WinEventDelegate m_winEventDelegate;
    private IntPtr m_hook;

    private Timer m_timer;

    public DockingHelper(string windowName, string className)
    {
        if (windowName == null && className == null) throw new ArgumentException("Either windowName or className must have a value");

        m_target = FindWindow(className, windowName);
        ThrowOnWin32Error("Failed to get target window");

        m_threadId = GetWindowThreadProcessId(m_target, out m_processId);
        ThrowOnWin32Error("Failed to get process id");

        m_winEventDelegate = WhenWindowMoveStartsOrEnds;
    }

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool UnhookWinEvent(IntPtr hWinEventHook);

    [DllImport("user32.dll")]
    private static extern IntPtr SetWinEventHook(uint eventMin, uint eventMax, IntPtr hmodWinEventProc, WinEventDelegate lpfnWinEventProc, uint idProcess, uint idThread, uint dwFlags);

    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);

    private void ThrowOnWin32Error(string message)
    {
        int err = Marshal.GetLastWin32Error();
        if (err != 0)
            throw new Win32Exception(err, message);
    }

    private RECT GetWindowLocation()
    {
        RECT loc;
        GetWindowRect(m_target, out loc);
        if (Marshal.GetLastWin32Error() != 0)
        {
            // Do something useful with this to handle if the target window closes, etc.
        }
        return loc;
    }

    public void Subscribe()
    {
        // 10 = window move start, 11 = window move end, 0 = fire out of context
        m_hook = SetWinEventHook(10, 11, m_target, m_winEventDelegate, m_processId, m_threadId, 0);
    }

    private void PollWindowLocation(object state)
    {
        var location = GetWindowLocation();
        // TODO: Reposition your window with the values from location (or fire an event with it attached)
    }

    public void Unsubscribe()
    {
        UnhookWinEvent(m_hook);
    }

    private void WhenWindowMoveStartsOrEnds(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
    {
        if (hwnd != m_target) // We only want events from our target window, not other windows owned by the thread.
            return;

        if (eventType == 10) // Starts
        {
            m_timer = new Timer(PollWindowLocation, null, 10, Timeout.Infinite);
            // This is always the original position of the window, so we don't need to do anything, yet.
        }
        else if (eventType == 11)
        {
            m_timer.Dispose();
            m_timer = null;
            var location = GetWindowLocation();
            // TODO: Reposition your window with the values from location (or fire an event with it attached)
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct RECT
    {
        public int Left, Top, Right, Bottom;
    }

    private delegate void WinEventDelegate(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime);
}

Answer 3

WH_CALLWNDPROC hook 可能就足够了，这将允许您监视发往感兴趣窗口的所有消息。

您是否询问如何使用 C# 创建全局钩子，或者您是否乐意在 C++ 中创建钩子，然后与 .NET 中的钩子进行互操作？第二个选择是我要走的路线。

基本上我的头脑中，我要做的是以下

1- 在 C 中创建全局钩子，并将函数导出到 InstallHook 和 UninstallHook，可以从使用 Interop 的 C# 应用程序。 InstallHook 获取 C# 应用程序中窗口的 hwnd。

2- 当您感兴趣的消息（例如您的案例中的 WM_SIZE）时，让已安装的钩子函数将自定义消息发布到调用 InstallHook 中提供的 C# 窗口。

3- 在 C# 应用程序中，从挂钩接收发布消息的窗口将覆盖 WndProc 来处理自定义消息。

这是一种方法的概述。

Answer 4

我建议您使用 WinEvents：

public delegate void WinEventDelegate(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime);

    [DllImport("user32.dll")]
    public static extern IntPtr SetWinEventHook(uint eventMin, uint eventMax, IntPtr hmodWinEventProc, WinEventDelegate lpfnWinEventProc, uint idProcess, uint idThread, uint dwFlags);

另请参阅：事件挂钩