[C#] グローバルフックとキーボードフックを理解する - SetWindowsHookExの使い方

HHOOK SetWindowsHookEx(
  int       idHook,
  HOOKPROC  lpfn,
  HINSTANCE hMod,
  DWORD     dwThreadId
);

WH_KEYBOARD_LL = 13

WH_KEYBOARD_LL

SetWindowsHookEx(WH_KEYBOARD_LL, proc, hModule, 0);

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Sample;

public sealed class KeyboardHook : IDisposable
{
    // Low-level keyboard hook
    private const int WH_KEYBOARD_LL = 13;

    private const int WM_KEYDOWN = 0x0100;
    private const int WM_SYSKEYDOWN = 0x0104;

    private readonly HookProc _proc;
    private nint _hookId;

    public event EventHandler<KeyPressedEventArgs>? KeyPressed;

    public KeyboardHook()
    {
        _proc = HookCallback;
    }

    public void Start()
    {
        if (_hookId != nint.Zero) return;
        _hookId = SetHook(_proc);
        if (_hookId == nint.Zero)
        {
            throw new System.ComponentModel.Win32Exception(
                Marshal.GetLastWin32Error(), "Failed to set keyboard hook.");
        }
    }

    public void Stop()
    {
        if (_hookId == nint.Zero) return;
        UnhookWindowsHookEx(_hookId);
        _hookId = nint.Zero;
    }

    public void Dispose()
    {
        Stop();
        GC.SuppressFinalize(this);
    }

    private static nint SetHook(HookProc proc)
    {
        using var curProcess = Process.GetCurrentProcess();
        using var curModule = curProcess.MainModule!;
        var hModule = GetModuleHandle(curModule.ModuleName);

        // For WH_KEYBOARD_LL, hMod is ok; threadId must be 0 for global
        return SetWindowsHookEx(WH_KEYBOARD_LL, proc, hModule, 0);
    }

    private nint HookCallback(int nCode, nint wParam, nint lParam)
    {
        if (nCode >= 0)
        {
            int msg = unchecked((int)wParam);
            if (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN)
            {
                var data = Marshal.PtrToStructure<KBDLLHOOKSTRUCT>(lParam);

                // vkCode is what we want (virtual-key code)
                KeyPressed?.Invoke(this, new KeyPressedEventArgs((int)data.vkCode, data.flags));
            }
        }

        return CallNextHookEx(_hookId, nCode, wParam, lParam);
    }

    public sealed class KeyPressedEventArgs : EventArgs
    {
        public KeyPressedEventArgs(int vkCode, uint flags)
        {
            VkCode = vkCode;
            Flags = flags;
        }

        public int VkCode { get; }
        public uint Flags { get; }
    }

    private delegate nint HookProc(int nCode, nint wParam, nint lParam);

    [StructLayout(LayoutKind.Sequential)]
    private struct KBDLLHOOKSTRUCT
    {
        public uint vkCode;
        public uint scanCode;
        public uint flags;
        public uint time;
        public nint dwExtraInfo;
    }

    [DllImport("user32.dll", SetLastError = true)]
    private static extern nint SetWindowsHookEx(int idHook, HookProc lpfn, nint hMod, uint dwThreadId);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool UnhookWindowsHookEx(nint hhk);

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

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern nint GetModuleHandle(string lpModuleName);
}