Question

public delegate void KeyboardHookCaptureHandler(KeyboardHookEventArgs keyboardEvents);

public class KeyboardHookEventArgs : EventArgs {

    private Keys _pressedKey;
    private int _pressedKeyCode;    

    public Keys PressedKey { get { return _pressedKey; } }
    public int PressedKeyCode { get { return _pressedKeyCode; } }

    public KeyboardHookEventArgs(int vkCode) {
        _pressedKey = (Keys)vkCode;
        _pressedKeyCode = vkCode;
    }
}

public class KeyboardHook {

    private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

    public event KeyboardHookCaptureHandler KeyIntercepted;

    private const int WH_KEYBOARD_LL = 13;
    private const int WM_KEYDOWN = 0x0100;

    private LowLevelKeyboardProc _proc;
    private IntPtr _hookID = IntPtr.Zero;

    public KeyboardHook() {
        _proc = HookCallback;
        _hookID = SetHook(_proc);
    }
    public bool UnHookKey() {
        return UnhookWindowsHookEx(_hookID);
    }

    private IntPtr SetHook(LowLevelKeyboardProc proc) {
        using (Process curProcess = Process.GetCurrentProcess())
        using (ProcessModule curModule = curProcess.MainModule) {
            return SetWindowsHookEx(WH_KEYBOARD_LL, proc,
                GetModuleHandle(curModule.ModuleName), 0);
        }
    }

    private IntPtr HookCallback(
        int nCode, IntPtr wParam, IntPtr lParam) {
        if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) {
            int vkCode = Marshal.ReadInt32(lParam);          
            KeyboardHookEventArgs keyHookArgs = new KeyboardHookEventArgs(vkCode);
            KeyIntercepted(keyHookArgs);
        }
        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }


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

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool UnhookWindowsHookEx(IntPtr hhk);

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

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

so I have no idea what this code means even though its the core of my program. It hooks a keyboard press event and sends it to my program. Can anyone take there precious time and explain a few things to me. I understand the args class so you can skip that. I am mostly interested in what a delegate is, what an IntPtr is and the two methods and what they do line by line.

thanks if anyone has the time

Answer 1

A delegate type basically specifies the signature of a function or method: it’s a way of capturing a function or method as an object, so that you can call that method later. A delegate instance is therefore basically a reference to a function or method.

An IntPtr is an operating system native pointer — an opaque reference to a piece of unmanaged memory.

The SetHook method is installing a hook procedure into Windows, so that the hook procedure will be called for every keyboard event in the system. What is the hook procedure? It is proc, an instance of the LowLevelKeyboardProc delegate type. In this case, proc is always being set to refer to your HookCallback function. So what SetHook ends up doing is telling Windows to call HookCallback every time a keyboard event happens.

HookCallback is unpacking the native operating system information associated with the keyboard event, and raising the KeyIntercepted event with that unpacked data. It’s then passing control to the next hook in the chain, in case anybody else is wanting to hook keyboard events.

So the final result of all this is that every time a keyboard event happens, this class raises the KeyIntercepted event. Users of this class can provide KeyIntercepted event handlers to do useful things, for example sending your bank password to the crime syndicate of your choice… *grin*