Разобраться с классом Hook

_hook = new Hook(0x90); // _hook- это переменная которая задается в 9-ой строке, ему присваивается новый класс new Hook который содержит значение 0x90 которое обозначает кнопку numlock, и делается это все для ...

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        private Hook _hook;
 
        [DllImport("user32.dll")]
        static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
 
        public Form1() //Конструктор формы
        {
            InitializeComponent();
            keybd_event(0x90, 0x45, 0x1, (UIntPtr)0);
 
            // 0x90 клавиша NumLock
            _hook = new Hook(0x90); //Передаем код клавиши на которую ставим хук, тут это CapsLock
 
            _hook.KeyPressed += new KeyPressEventHandler(_hook_KeyPressed);
            _hook.SetHook();
        }
 
        void _hook_KeyPressed(object sender, KeyPressEventArgs e) //Событие нажатия клавиш
        {
            this.Visible = !this.Visible; //показываем форму 
            this.Activate();
        }
    }
 
    public class Hook : IDisposable
    {
        #region Declare WinAPI functions
        [DllImport("kernel32.dll")]
        private static extern IntPtr LoadLibrary(string lpFileName);
 
        [DllImport("user32.dll")]
        private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hInstance, uint threadId);
        [DllImport("user32.dll")]
        private static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, int wParam, IntPtr lParam);
        [DllImport("user32.dll")]
        private static extern bool UnhookWindowsHookEx(IntPtr hInstance);
        #endregion
        #region Constants
        private const int WH_KEYBOARD_LL = 13;
        private const int WH_KEYDOWN = 0x0100;
        #endregion
 
        // код клавиши на которую ставим хук
        private int _key;
        public event KeyPressEventHandler KeyPressed;
 
        private delegate IntPtr KeyboardHookProc(int code, IntPtr wParam, IntPtr lParam);
        private KeyboardHookProc _proc;
        private IntPtr _hHook = IntPtr.Zero;
 
        public Hook(int keyCode)
        {
            _key = keyCode;
            _proc = HookProc;
        }
 
        public void SetHook()
        {
            var hInstance = LoadLibrary("User32");
            _hHook = SetWindowsHookEx(WH_KEYBOARD_LL, _proc, hInstance, 0);
        }
 
        public void Dispose()
        {
            UnHook();
        }
 
        public void UnHook()
        {
            UnhookWindowsHookEx(_hHook);
        }
 
        private IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam)
        {
            if ((code >= 0 && wParam == (IntPtr)WH_KEYDOWN) && Marshal.ReadInt32(lParam) == _key)
            {
 
                // бросаем событие
                if (KeyPressed != null)
                {
                    KeyPressed(this, new KeyPressEventArgs(Convert.ToChar(code)));
                }
            }
 
            // пробрасываем хук дальше
            return CallNextHookEx(_hHook, code, (int)wParam, lParam);
        }
    }
}

public sealed class KeyboardHook : IDisposable
    {
        // Registers a hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
        // Unregisters the hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
 
        /// <summary>
        /// Represents the window that is used internally to get the messages.
        /// </summary>
        private class Window : NativeWindow, IDisposable
        {
            private static int WM_HOTKEY = 0x0312;
 
            public Window()
            {
                // create the handle for the window.
                this.CreateHandle(new CreateParams());
            }
 
            /// <summary>
            /// Overridden to get the notifications.
            /// </summary>
            /// <param name="m"></param>
            protected override void WndProc(ref Message m)
            {
                base.WndProc(ref m);
 
                // check if we got a hot key pressed.
                if (m.Msg == WM_HOTKEY)
                {
                    // get the keys.
                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                    ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);
 
                    // invoke the event to notify the parent.
                    if (KeyPressed != null)
                        KeyPressed(this, new KeyPressedEventArgs(modifier, key));
                }
            }
 
            public event EventHandler<KeyPressedEventArgs> KeyPressed;
 
            #region IDisposable Members
 
            public void Dispose()
            {
                this.DestroyHandle();
            }
 
            #endregion
        }
 
        private Window _window = new Window();
        private int _currentId;
 
        public KeyboardHook()
        {
            // register the event of the inner native window.
            _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
            {
                if (KeyPressed != null)
                    KeyPressed(this, args);
            };
        }
 
        /// <summary>
        /// Registers a hot key in the system.
        /// </summary>
        /// <param name="modifier">The modifiers that are associated with the hot key.</param>
        /// <param name="key">The key itself that is associated with the hot key.</param>
        public void RegisterHotKey(ModifierKeys modifier, Keys key)
        {
            // increment the counter.
            _currentId = _currentId + 1;
 
            // register the hot key.
            if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
                throw new InvalidOperationException("Couldn’t register the hot key.");
        }
 
        /// <summary>
        /// A hot key has been pressed.
        /// </summary>
        public event EventHandler<KeyPressedEventArgs> KeyPressed;
 
        #region IDisposable Members
 
        public void Dispose()
        {
            // unregister all the registered hot keys.
            for (int i = _currentId; i > 0; i--)
            {
                UnregisterHotKey(_window.Handle, i);
            }
 
            // dispose the inner native window.
            _window.Dispose();
        }
 
        #endregion
    }
 
    /// <summary>
    /// Event Args for the event that is fired after the hot key has been pressed.
    /// </summary>
    public class KeyPressedEventArgs : EventArgs
    {
        private ModifierKeys _modifier;
        private Keys _key;
 
        internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
        {
            _modifier = modifier;
            _key = key;
        }
 
        public ModifierKeys Modifier
        {
            get { return _modifier; }
        }
 
        public Keys Key
        {
            get { return _key; }
        }
    }
 
    /// <summary>
    /// The enumeration of possible modifiers.
    /// </summary>
    [Flags]
    public enum ModifierKeys : uint
    {
        Alt = 1,
        Control = 2,
        Shift = 4,
        Win = 8
    }

KeyboardHook hook = new KeyboardHook();

hook.RegisterHotKey(AutoBot.ModifierKeys.Control, Keys.NumPad1); // комбинация CTRL+1 на цифровой клавиатуре

hook.KeyPressed += new EventHandler<KeyPressedEventArgs>(hook_KeyPressed);