我需要捕捉的关键preSS时，我的计划是没有焦点。 （即按Ctrl + Alt键+ J），并在我的计划触发事件。

到目前为止，我发现这个DLL，它似乎是corrrect路径

  [的DllImport（user32.dll中）的私人静态外部INT RegisterHotKey（IntPtr的HWND，INT ID，诠释fsModifiers，INT VK）;

[的DllImport（user32.dll中）的私人静态外部INT UnregisterHotKey（IntPtr的HWND，INT ID）;
 

解决方案

请注意，此code 将不会触发事件在控制台应用程序项目。你必须使用的WinForms项目的事件触发。

这是正确的code：

 公共密封类的KeyboardHook：IDisposable的
{
    //注册一个热键与Windows。
    [的DllImport（user32.dll中）
    私人静态外部布尔RegisterHotKey（IntPtr的的HWND，INT ID，UINT fsModifiers，UINT VK）;
    //注销热键与Windows。
    [的DllImport（user32.dll中）
    私人静态外部布尔UnregisterHotKey（IntPtr的的HWND，INT ID）;

    ///＆LT;总结＆gt;
    ///重新presents内部使用，以获得消息的窗口。
    ///＆LT; /总结＆gt;
    私有类窗口：NativeWindow中，IDisposable的
    {
        私有静态诠释WM_HOTKEY = 0x0312;

        公共窗口（）
        {
            //创建的句柄的窗口。
            this.CreateHandle（新的CreateParams（））;
        }

        ///＆LT;总结＆gt;
        ///重写得到通知。
        ///＆LT; /总结＆gt;
        ///＆LT; PARAM NAME =M＆GT;＆LT; /参数＆GT;
        保护覆盖无效的WndProc（参考消息M）
        {
            base.WndProc（REF米）;

            //检查，如果我们得到了一个热键pressed。
            如果（m.Msg == WM_HOTKEY）
            {
                //拿到钥匙。
                按键键=（密钥）（（（INT）m.LParam＆GT;＆GT; 16）及0xFFFF的）;
                ModifierKeys修改=（ModifierKeys）（（INT）m.LParam和放大器; 0xFFFF的）;

                //调用事件通知父。
                如果（主要pressed！= NULL）
                    主要pressed（这一点，新的关键pressedEventArgs（修改，键））;
            }
        }

        公共事件的EventHandler＆LT;关键pressedEventArgs＆GT;主要pressed;

        ＃地区IDisposable的成员

        公共无效的Dispose（）
        {
            this.DestroyHandle（）;
        }

        #endregion
    }

    私人窗口_window =新窗口（）;
    私人诠释_currentId;

    公众的KeyboardHook（）
    {
        //注册内原有窗口的事件。
        _window.Key pressed + =委托（对象发件人，重点pressedEventArgs参数）
        {
            如果（主要pressed！= NULL）
                主要pressed（这一点，参数）;
        };
    }

    ///＆LT;总结＆gt;
    ///注册热键在系统中。
    ///＆LT; /总结＆gt;
    ///＆LT; PARAM NAME =修饰符＆GT;与该快捷键关联的改性剂LT; /参数＆GT;
    ///＆LT; PARAM NAME =键和GT;密钥本身与该快捷键关联＆LT; /参数＆GT;
    公共无效RegisterHotKey（ModifierKeys修改，按键键）
    {
        //增加计数器。
        _currentId = _currentId + 1;

        //注册热键。
        如果（！RegisterHotKey（_window.Handle，_currentId，（UINT）改性剂，（UINT）键））
            抛出新的InvalidOperationException异常（无法注册热键。）;
    }

    ///＆LT;总结＆gt;
    ///热键一直pssed $ P $。
    ///＆LT; /总结＆gt;
    公共事件的EventHandler＆LT;关键pressedEventArgs＆GT;主要pressed;

    ＃地区IDisposable的成员

    公共无效的Dispose（）
    {
        //注销所有已注册的热键。
        对于（INT I = _currentId; I＆GT; 0;我 - ）
        {
            UnregisterHotKey（_window.Handle，我）;
        }

        //处理内部原生窗口。
        _window.Dispose（）;
    }

    #endregion
}

///＆LT;总结＆gt;
///事件参数为被解雇后，热键已pssed $ P $事件。
///＆LT; /总结＆gt;
公共类主要pressedEventArgs：EventArgs的
{
    私人ModifierKeys _modifier;
    私钥_key;

    内部主要pressedEventArgs（ModifierKeys修改，按键键）
    {
        _modifier =改性剂;
        _key =键;
    }

    公共ModifierKeys修改
    {
        {返回_modifier; }
    }

    公钥密钥
    {
        {返回_key; }
    }
}

///＆LT;总结＆gt;
///可能的修饰符枚举。
///＆LT; /总结＆gt;
[国旗]
公共枚举ModifierKeys：UINT
{
    中高音= 1，
    对照= 2，
    移= 4，
    赢= 8
}
 

要使用（我不得不编辑修饰键来施展他们（修改）1（修改）2等

 公共部分类Form1中：形态
{
    的KeyboardHook挂钩=新的KeyboardHook（）;

    公共Form1中（）
    {
        的InitializeComponent（）;

        //寄存器，之后的关键preSS触发事件。
        hook.Key pressed + =
            新的事件处理程序＆LT;关键pressedEventArgs＆GT;（hook_Key pressed）;
        //注册控制+ ALT + F12组合作为热键。
        hook.RegisterHotKey（ModifierKeys.Control | ModifierKeys.Alt，
            Keys.F12）;
    }

    无效hook_Key pressed（对象发件人，重点pressedEventArgs E）
    {
        //显示pssed在标签的按键$ P $。
        label1.Text = e.Modifier.ToString（）+++ e.Key.ToString（）;
    }
}
 

I need to capture a key press when my program is not in focus. (ie. Ctrl+Alt+J) and trigger an event in my program.

Thus far i have found this dll that appears to be the corrrect path"

[DllImport("user32.dll")]private static extern int RegisterHotKey(IntPtr hwnd, int id,int fsModifiers, int vk);

[DllImport("user32.dll")] private static extern int UnregisterHotKey(IntPtr hwnd, int id);

Please note that this code will not trigger events in console application projects. You have to use WinForms project for events to fire.

This is the correct code:

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
}

to use (i had to edit the modifier keys to cast them (modifier)1 (modifier)2 etc

public partial  class Form1 : Form
{
    KeyboardHook hook = new KeyboardHook();

    public Form1()
    {
        InitializeComponent();

        // register the event that is fired after the key press.
        hook.KeyPressed +=
            new EventHandler<KeyPressedEventArgs>(hook_KeyPressed);
        // register the control + alt + F12 combination as hot key.
        hook.RegisterHotKey(ModifierKeys.Control | ModifierKeys.Alt,
            Keys.F12);
    }

    void hook_KeyPressed(object sender, KeyPressedEventArgs e)
    {
        // show the keys pressed in a label.
        label1.Text = e.Modifier.ToString() + " + " + e.Key.ToString();
    }
}