Winforms Static HandleCreated or OnLoad Event

Question

Is there any static event that is triggered when a handle for a Winforms control is created or when it is loaded for the first time?

This is a contrived example:

using (Form f1 = new Form())
{
    f1.HandleCreated += (sender, args) => { MessageBox.Show("hi"); };
    f1.ShowDialog();
}
using (Form f2 = new Form())
{
    f2.HandleCreated += (sender, args) => { MessageBox.Show("hi"); };
    f2.ShowDialog();
}

And this is what I want:

Form.StaticHandleCreated += (sender, args) => { MessageBox.Show("hi"); };
using (Form f1 = new Form())
{
    f1.ShowDialog();
}
using (Form f2 = new Form())
{
    f2.ShowDialog();
}

(I want this because I have several hundred controls, and I need to customize the default behavior of a third party control, and the vendor does not provide a better way. They specifically say to handle the OnLoad event to do the customization, but this is a massive workload.)

---

Thanks to xtu, here is the working version that doesn't hold onto the forms longer than necessary, to avoid memory leaks.

public class WinFormMonitor : IDisposable
{
    private readonly IntPtr _eventHook;
    private List<Form> _detectedForms = new List<Form>();

    public event Action<Form> NewFormDetected;

    private WinEventDelegate _winEventDelegate;

    public WinFormMonitor()
    {
        _winEventDelegate = WinEventProc;

        _eventHook = SetWinEventHook(
            EVENT_OBJECT_CREATE,
            EVENT_OBJECT_CREATE,
            IntPtr.Zero,
            _winEventDelegate,
            0,
            0,
            WINEVENT_OUTOFCONTEXT);
    }

    public void Dispose()
    {
        _detectedForms.Clear();
        UnhookWinEvent(_eventHook);
    }

    private void WinEventProc(IntPtr hWinEventHook, uint eventType,
        IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
    {
        if (idObject != 0 || idChild != 0) return;
        var currentForms = Application.OpenForms.OfType<Form>().ToList();
        var newForms = currentForms.Except(_detectedForms);
        foreach (var f in newForms)
        {
            NewFormDetected?.Invoke(f);
        }
        _detectedForms = currentForms;
    }


    private const uint EVENT_OBJECT_CREATE = 0x8000;
    private const uint WINEVENT_OUTOFCONTEXT = 0;

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

    [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")]
    private static extern bool UnhookWinEvent(IntPtr hWinEventHook);
}

Answer 1

I was inspired by this answer and used SetWinEventHook API to create a new WinForm monitor. Basically, it monitors the EVENT_OBJECT_CREATE event and fires an event whenever a new window is found.

The usage is very simple. You create a new instance and then attach a handler to the NewFormCreated event. Here is an example:

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    using (var monitor = new WinFormMonitor())
    {
        monitor.NewFormCreated += (sender, form) => { MessageBox.Show($"hi {form.Text}"); };

        Application.Run(new Form1());
    }
}

And here is the source of the WinFormMonitor:

public class WinFormMonitor : IDisposable
{
    private readonly IntPtr _eventHook;
    private readonly IList<int> _detectedFormHashes = new List<int>();

    public event EventHandler<Form> NewFormCreated = (sender, form) => { };

    public WinFormMonitor()
    {
        _eventHook = SetWinEventHook(
            EVENT_OBJECT_CREATE,
            EVENT_OBJECT_CREATE,
            IntPtr.Zero,
            WinEventProc,
            0,
            0,
            WINEVENT_OUTOFCONTEXT);
    }

    public void Dispose()
    {
        _detectedFormHashes.Clear();
        UnhookWinEvent(_eventHook);
    }

    private void WinEventProc(IntPtr hWinEventHook, uint eventType,
        IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
    {
        // filter out non-HWND namechanges... (eg. items within a listbox)
        if (idObject != 0 || idChild != 0) return;
        if (!TryFindForm(hwnd, out var foundForm)) return;

        RaiseIfNewFormFound(foundForm);
    }

    private void RaiseIfNewFormFound(Form foundForm)
    {
        var formHash = foundForm.GetHashCode();
        if (_detectedFormHashes.Contains(formHash)) return;

        NewFormCreated(this, foundForm);
        _detectedFormHashes.Add(formHash);
    }

    private static bool TryFindForm(IntPtr handle, out Form foundForm)
    {
        foreach (Form openForm in Application.OpenForms)
        {
            if (openForm.Handle != handle) continue;
            foundForm = openForm;
            return true;
        }

        foundForm = null;
        return false;
    }

    private const uint EVENT_OBJECT_CREATE = 0x8000;
    private const uint WINEVENT_OUTOFCONTEXT = 0;

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

    [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")]
    private static extern bool UnhookWinEvent(IntPtr hWinEventHook);
}