我在我们的应用程序中使用的系统有问题:有时，当我们向该系统询问数据时，他会弹出一个 MessageBox 来告诉我们类似这样的信息:“我无法检索您的数据，要搜索的数据太多了”。

这个问题是用户可能无法看到或关闭弹出窗口，因此这会阻止整个应用程序(解释为什么用户无法关闭/看到弹出窗口会花费太多时间并且偏离主题，这很糟糕但我们必须处理它)。

因此，作为一个临时解决方案，我想阻止这个特定进程创建 MessageBox。

我在网上寻找解决方案并找到了关于 CBTProc 的信息这似乎提供了一种对特定 Windows 事件(进程创建窗口的请求)作出 react 并指示操作系统阻止该请求的方法。

这是要走的路吗？

我测试了SetWinEventHook检测请求创建窗口和 DestroyWindow 的进程销毁窗口:

public class PopupWatchdog {

    #region constructor
    public PopupWatchdog() {
        SetWinEventHook(
            EVENT_OBJECT_CREATED,
            EVENT_OBJECT_CREATED,
            IntPtr.Zero,
            HookCallback,
            0, //id process
            0, //id thread
            WINEVENT_OUTOFCONTEXT
        );
    }
    #endregion

    #region functions
    private static void HookCallback(IntPtr hWinEventHook, int iEvent, IntPtr hWnd, int idObject, int idChild, int dwEventThread, int dwmsEventTime) {
        Console.WriteLine("window {0} requests creating an object, trying to destroy it...", idChild);
        DestroyWindow(hWnd);
    }

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SetWinEventHook(int eventMin, int eventMax, IntPtr hmodWinEventProc, HookProc lpfnWinEventProc, int idProcess, int idThread, int dwflags);

    [DllImport("user32.dll")]
    private static extern bool DestroyWindow(IntPtr hWnd);
    #endregion

    #region events

    #endregion

    #region variables
    #region const
    private const int EVENT_OBJECT_CREATED = 0x8000;
    private const int WINEVENT_OUTOFCONTEXT = 0;
    #endregion
    private delegate void HookProc(
        IntPtr hWinEventHook,
        int iEvent,
        IntPtr hWnd,
        int idObject, 
        int idChild,
        int dwEventThread, 
        int dwmsEventTime
    );
    #endregion
}

DestroyWindow 不能像 msdn 文档所说的那样用于销毁另一个线程创建的窗口，这是不稳定的。所以我的测试没有成功。我该如何解决这个问题？

我可能犯了错误，我不太了解 Windows api，只是听说了 CBTProc。

更新

我根据@DavidHeffernan 和@AlexK 的建议更改了代码，并且有效:

public class BlockingPopupWatchdog {
    #region ctor
    public BlockingPopupWatchdog(int processId) {
        _processId = processId;
    }
    #endregion

    #region functions
    internal bool Hook() {
        if (_hookId != IntPtr.Zero) {
            Unhook();
        }
        _hookId = SetWinEventHook(
            EVENT_OBJECT_CREATED,
            EVENT_OBJECT_CREATED,
            IntPtr.Zero,
            _hook,
            _processId, //id process
            0, //id thread
            WINEVENT_OUTOFCONTEXT
        );

        if (_hookId == IntPtr.Zero) {
            Logger.Log(String.Format("Error {0} while hooking", Marshal.GetLastWin32Error()), EventTypes.WARNING);
            return false;
        }
        return true;
    }

    internal bool Unhook() {
        if (_hookId == IntPtr.Zero) return false;
        if (!UnhookWinEvent(_hookId)) {
            Logger.Log(String.Format("Error {0} while unhooking", Marshal.GetLastWin32Error()), EventTypes.WARNING);
            return false;
        }
        return true;
    }
    private static void HookCallback(IntPtr hWinEventHook, int iEvent, IntPtr hWnd, int idObject, int idChild, int dwEventThread, int dwmsEventTime) {
        if (hWnd == IntPtr.Zero) return;

        try {
            AutomationElement elem = AutomationElement.FromHandle(hWnd);
            if (elem == null || !elem.Current.ClassName.Equals(MESSAGEBOX_CLASS_NAME)) {
                return;
            }

            object pattern;
            if (!elem.TryGetCurrentPattern(WindowPattern.Pattern, out pattern)) return;

            WindowPattern window = (WindowPattern)pattern;
            if (window.Current.WindowInteractionState == WindowInteractionState.ReadyForUserInteraction) {
                window.Close();
            }
        } catch (Exception e) {
            Console.WriteLine(e);
        }
    }
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SetWinEventHook(int eventMin, int eventMax, IntPtr hmodWinEventProc, HookProc lpfnWinEventProc, int idProcess, int idThread, int dwflags);

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

    #region variables
    #region const
    private const String MESSAGEBOX_CLASS_NAME = "#32770";
    private const int EVENT_OBJECT_CREATED = 0x8000;
    private const int WINEVENT_OUTOFCONTEXT = 0;
    #endregion

    private delegate void HookProc(
        IntPtr hWinEventHook,
        int iEvent,
        IntPtr hWnd,
        int idObject,
        int idChild,
        int dwEventThread,
        int dwmsEventTime
    );

    private static readonly HookProc _hook = HookCallback;
    private IntPtr _hookId;
    private readonly int _processId;
    #endregion
}

最佳答案

感谢 DavidHefferman 和 AlexK。这是实现我想要的解决方案。

使用 WinApi:

public class BlockingPopupWatchdog {
    #region ctor
    public BlockingPopupWatchdog(int processId) {
        _processId = processId;
    }
    #endregion

    #region functions
    internal bool Hook() {
        if (_hookId != IntPtr.Zero) {
            Unhook();
        }
        _hookId = SetWinEventHook(
            EVENT_OBJECT_CREATED,
            EVENT_OBJECT_CREATED,
            IntPtr.Zero,
            _hook,
            _processId, //id process
            0, //id thread
            WINEVENT_OUTOFCONTEXT
        );

        if (_hookId == IntPtr.Zero) {
            Logger.Log(String.Format("Error {0} while hooking", Marshal.GetLastWin32Error()), EventTypes.WARNING);
            return false;
        }
        return true;
    }

    internal bool Unhook() {
        if (_hookId == IntPtr.Zero) return false;
        if (!UnhookWinEvent(_hookId)) {
            Logger.Log(String.Format("Error {0} while unhooking", Marshal.GetLastWin32Error()), EventTypes.WARNING);
            return false;
        }
        return true;
    }
    private static void HookCallback(IntPtr hWinEventHook, int iEvent, IntPtr hWnd, int idObject, int idChild, int dwEventThread, int dwmsEventTime) {
        if (hWnd == IntPtr.Zero) return;

        try {
            AutomationElement elem = AutomationElement.FromHandle(hWnd);
            if (elem == null || !elem.Current.ClassName.Equals(MESSAGEBOX_CLASS_NAME)) {
                return;
            }

            object pattern;
            if (!elem.TryGetCurrentPattern(WindowPattern.Pattern, out pattern)) return;

            WindowPattern window = (WindowPattern)pattern;
            if (window.Current.WindowInteractionState == WindowInteractionState.ReadyForUserInteraction) {
                window.Close();
            }
        } catch (Exception e) {
            Console.WriteLine(e);
        }
    }
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SetWinEventHook(int eventMin, int eventMax, IntPtr hmodWinEventProc, HookProc lpfnWinEventProc, int idProcess, int idThread, int dwflags);

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

    #region variables
    #region const
    private const String MESSAGEBOX_CLASS_NAME = "#32770";
    private const int EVENT_OBJECT_CREATED = 0x8000;
    private const int WINEVENT_OUTOFCONTEXT = 0;
    #endregion

    private delegate void HookProc(
        IntPtr hWinEventHook,
        int iEvent,
        IntPtr hWnd,
        int idObject,
        int idChild,
        int dwEventThread,
        int dwmsEventTime
    );

    private static readonly HookProc _hook = HookCallback;
    private IntPtr _hookId;
    private readonly int _processId;
    #endregion
}

以及使用 UIAutomation 的解决方案:

private AutomationElement _watchedElement;
private void PopupOpenedHandler(Object sender, AutomationEventArgs args) {
    var element = sender as AutomationElement;
    if (element == null || !element.Current.ClassName.Equals(MESSAGEBOX_CLASS_NAME)) {
        return;
    }

    object pattern;
    if (!element.TryGetCurrentPattern(WindowPattern.Pattern, out pattern)) return;

    WindowPattern window = (WindowPattern)pattern;
    if (window.Current.WindowInteractionState == WindowInteractionState.ReadyForUserInteraction) {
        window.Close();
    }
}

internal bool Hook() {
    Process p = Process.GetProcessById(_processId);
    IntPtr wHnd = p.MainWindowHandle;
    if (wHnd != IntPtr.Zero) {
        _watchedElement = AutomationElement.FromHandle(wHnd);
        Automation.AddAutomationEventHandler (
            WindowPattern.WindowOpenedEvent,
            _watchedElement,
            TreeScope.Descendants,
            PopupOpenedHandler
        );
        return true;
    }
    return false;
}


internal bool Unhook() {
    if (_watchedElement == null) return false;
    Automation.RemoveAutomationEventHandler(WindowPattern.WindowOpenedEvent, _watchedElement, PopupOpenedHandler);
    return true;
}

关于c# - 阻止进程创建 MessageBox，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35845846/