pinvoke async delegate when desktop windows collection changes?

Question

I have a C# program that polls for changes to EnumDesktopWindows collection. If a user closes or opens a window the polling routine detects this and sends an updated list of available windows to another .Net windows forms project. However, I do not like the polling method. I would prefer that any change to the EnumDesktopWindows triggers an event so that responding to the change is done asynchronously.

The best I could come up with is what you see below. I tried out Scott C.'s suggestion to execute from a console window, but it did not work.

Currently what you see below captures CreateWnd=3 when the Windows Form loads (this is a windows form application). However it does not capture globally: it only captures the window events from the currently running executable. If anyone has eagle eyes and can spot how to make this code capture globally I will award the answer.

To try it out; first create a Windows Forms application project and add the following code to Form1.cs (you will need to add a ListBox to the Form named lstLog to compile correctly)

using System;
using System.Windows.Forms;

namespace Utilities
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            var gwh = new GlobalWindowHook();
            gwh.WindowCreated += onWindowCreated;
        }

        private void onWindowCreated()
        {
            lstLog.Items.Add("window creation event detected.");
        }
    }
}

Create a class file in the same project named GlobalWindowHook.cs and copy paste the following:

using System;
using System.Runtime.InteropServices;

namespace Utilities
{
    internal class GlobalWindowHook
    {
        private delegate IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam);

        [DllImport("user32.dll")]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

        public enum HookType
        {
            WH_JOURNALRECORD = 0,
            WH_JOURNALPLAYBACK = 1,
            WH_KEYBOARD = 2,
            WH_GETMESSAGE = 3,
            WH_CALLWNDPROC = 4,
            WH_CBT = 5,
            WH_SYSMSGFILTER = 6,
            WH_MOUSE = 7,
            WH_HARDWARE = 8,
            WH_DEBUG = 9,
            WH_SHELL = 10,
            WH_FOREGROUNDIDLE = 11,
            WH_CALLWNDPROCRET = 12,
            WH_KEYBOARD_LL = 13,
            WH_MOUSE_LL = 14
        }

        public enum HCBT
        {
            MoveSize = 0,
            MinMax = 1,
            QueueSync = 2,
            CreateWnd = 3,
            DestroyWnd = 4,
            Activate = 5,
            ClickSkipped = 6,
            KeySkipped = 7,
            SysCommand = 8,
            SetFocus = 9
        }

        private IntPtr hhook = IntPtr.Zero;

        public GlobalWindowHook()
        {
            hook();
        }


        ~GlobalWindowHook()
        {
            unhook();
        }


        public void hook()
        {
            IntPtr hInstance = LoadLibrary("User32");

            hhook = SetWindowsHookEx(HookType.WH_CBT, hookProc, hInstance, 0);
        }

        public void unhook()
        {
            UnhookWindowsHookEx(hhook);
        }

        public IntPtr hookProc(int code, IntPtr wParam, IntPtr lParam)
        {
            if (code != (int) HCBT.CreateWnd && code != (int) HCBT.DestroyWnd)
                return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);

            //Do whatever with the created or destroyed window.

            return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
        }


        [DllImport("user32.dll")]
        private static extern IntPtr SetWindowsHookEx(HookType code, HookProc func, IntPtr hInstance, int threadId);

        [DllImport("user32.dll")]
        private static extern bool UnhookWindowsHookEx(IntPtr hInstance);

        [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern IntPtr LoadLibrary(string fileName);
    }
}

After performing the above steps execute the windows forms project. You should see that it detects one window being created, namely the one you just executed.

Answer 1

If you want to be pushed the notifications instead of pulling them it is not too difficult. What you will need to do is P/Invoke SetWindowsHookEx and register for the WH_CBT event. Once you get those messages you can listen for messages with the HCBT_CREATEWND or HCBT_DESTROYWND codes. That will notify you when a new window is created or is destroyed.

Using the types defined at pinvoke.net

class HookingClass
{
    private delegate IntPtr CBTProc(HCBT nCode, IntPtr wParam, IntPtr lParam);

    private readonly CBTProc _callbackDelegate;

    public HookingClass()
    {
         _callbackDelegate = CallbackFunction;
    }

    private IntPtr _hook;

    private void CreateHook()
    {
        using (Process process = Process.GetCurrentProcess())
        using (ProcessModule module = process.MainModule)
        {
            IntPtr hModule = GetModuleHandle(module.ModuleName);

            _hook = SetWindowsHookEx(HookType.WH_CBT, _callbackDelegate, hModule, 0);
            if(_hook == IntPtr.Zero)
                throw new Win32Exception(); //The default constructor automatically calls Marshal.GetLastError()
        }

    }

    private void Unhook()
    {
        var success = UnhookWindowsHookEx(_hook);
        if(!success)
            throw new Win32Exception();
    }

     private IntPtr CallbackFunction(HCBT code, IntPtr wParam, IntPtr lParam)
     {
         if (code != HCBT.CreateWnd && code != HCBT.DestroyWnd) 
         {         
             return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
         }

         //Do whatever with the created or destroyed window.

         return CallNextHookEx(IntPtr.Zero, (int)code, wParam, lParam);
     }
}