关于c＃：如何使用WPF和.NET 3.5注册一个全局热键以说CTRL + SHIFT +(LETTER)？

How can I register a global hot key to say CTRL+SHIFT+(LETTER) using WPF and .NET 3.5?

我正在使用WPF在C＃中构建应用程序。如何绑定某些键？

另外，如何绑定Windows键？

这是一个完整的解决方案，希望对您有所帮助。

用法：

1	_hotKey = new HotKey(Key.F9, KeyModifier.Shift \| KeyModifier.Win, OnHotKeyHandler);

...

1
2
3
4

private void OnHotKeyHandler(HotKey hotKey)
{
SystemHelper.SetScreenSaverRunning();
}

类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Mime;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;

namespace UnManaged
{
public class HotKey : IDisposable
{
private static Dictionary<int, HotKey> _dictHotKeyToCalBackProc;

[DllImport("user32.dll")]
private static extern bool RegisterHotKey(IntPtr hWnd, int id, UInt32 fsModifiers, UInt32 vlc);

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

public const int WmHotKey = 0x0312;

private bool _disposed = false;

public Key Key { get; private set; }
public KeyModifier KeyModifiers { get; private set; }
public Action<HotKey> Action { get; private set; }
public int Id { get; set; }

// ******************************************************************
public HotKey(Key k, KeyModifier keyModifiers, Action<HotKey> action, bool register = true)
{
Key = k;
KeyModifiers = keyModifiers;
Action = action;
if (register)
{
Register();
}
}

// ******************************************************************
public bool Register()
{
int virtualKeyCode = KeyInterop.VirtualKeyFromKey(Key);
Id = virtualKeyCode + ((int)KeyModifiers * 0x10000);
bool result = RegisterHotKey(IntPtr.Zero, Id, (UInt32)KeyModifiers, (UInt32)virtualKeyCode);

if (_dictHotKeyToCalBackProc == null)
{
_dictHotKeyToCalBackProc = new Dictionary<int, HotKey>();
ComponentDispatcher.ThreadFilterMessage += new ThreadMessageEventHandler(ComponentDispatcherThreadFilterMessage);
}

_dictHotKeyToCalBackProc.Add(Id, this);

Debug.Print(result.ToString() +"," + Id +"," + virtualKeyCode);
return result;
}

// ******************************************************************
public void Unregister()
{
HotKey hotKey;
if (_dictHotKeyToCalBackProc.TryGetValue(Id, out hotKey))
{
UnregisterHotKey(IntPtr.Zero, Id);
}
}

// ******************************************************************
private static void ComponentDispatcherThreadFilterMessage(ref MSG msg, ref bool handled)
{
if (!handled)
{
if (msg.message == WmHotKey)
{
HotKey hotKey;

if (_dictHotKeyToCalBackProc.TryGetValue((int)msg.wParam, out hotKey))
{
if (hotKey.Action != null)
{
hotKey.Action.Invoke(hotKey);
}
handled = true;
}
}
}
}

// ******************************************************************
// Implement IDisposable.
// Do not make this method virtual.
// A derived class should not be able to override this method.
public void Dispose()
{
Dispose(true);
// This object will be cleaned up by the Dispose method.
// Therefore, you should call GC.SupressFinalize to
// take this object off the finalization queue
// and prevent finalization code for this object
// from executing a second time.
GC.SuppressFinalize(this);
}

// ******************************************************************
// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be _disposed.
// If disposing equals false, the method has been called by the
// runtime from inside the finalizer and you should not reference
// other objects. Only unmanaged resources can be _disposed.
protected virtual void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this._disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Dispose managed resources.
Unregister();
}

// Note disposing has been done.
_disposed = true;
}
}
}

// ******************************************************************
[Flags]
public enum KeyModifier
{
None = 0x0000,
alt=0x0001,
Ctrl = 0x0002,
NoRepeat = 0x4000,
Shift = 0x0004,
Win = 0x0008
}

// ******************************************************************
}

我不确定这里所说的"全局"是什么意思(我假设您是指应用程序级别的命令，例如，保存可以通过Ctrl + Shift + S触发的所有内容) )

您可以找到所选的全局UIElement，例如，顶级窗口，该窗口是需要此绑定的所有控件的父级。由于WPF事件的"冒泡"，子元素上的事件将一直冒泡直到控制树的根。

现在，首先您需要

像这样使用InputBinding将键组合与命令绑定

然后可以通过CommandBinding将命令连接到处理程序(例如，被SaveAll调用的代码)。

对于Windows密钥，请使用正确的Key枚举成员Key.LWin或Key.RWin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public WindowMain()
{
InitializeComponent();

// Bind Key
var ib = new InputBinding(
MyAppCommands.SaveAll,
new KeyGesture(Key.S, ModifierKeys.Shift | ModifierKeys.Control));
this.InputBindings.Add(ib);

// Bind handler
var cb = new CommandBinding( MyAppCommands.SaveAll);
cb.Executed += new ExecutedRoutedEventHandler( HandlerThatSavesEverthing );

this.CommandBindings.Add (cb );
}

private void HandlerThatSavesEverthing (object obSender, ExecutedRoutedEventArgs e)
{
// Do the Save All thing here.
}

注册操作系统级别的快捷方式从来都不是一件好事：用户不希望您弄乱自己的操作系统。

就是说，如果您只确定热键仅在应用程序内运行(即只要您的WPF应用程序具有焦点)，那么在WPF中，有一种更简单且用户友好的方法：

在App.xaml.cs中：

1
2
3
4
5
6
7
8
9

protected override void OnStartup(StartupEventArgs e)
{
EventManager.RegisterClassHandler(typeof(Window), Window.PreviewKeyUpEvent, new KeyEventHandler(OnWindowKeyUp));
}

private void OnWindowKeyUp(object source, KeyEventArgs e))
{
//Do whatever you like with e.Key and Keyboard.Modifiers
}

就这么简单

如果要混合使用Win32和WPF，请按以下步骤操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

using System;
using System.Runtime.InteropServices;
using System.Windows.Interop;
using System.Windows.Media;
using System.Threading;
using System.Windows;
using System.Windows.Input;

namespace GlobalKeyboardHook
{
public class KeyboardHandler : IDisposable
{

public const int WM_HOTKEY = 0x0312;
public const int VIRTUALKEYCODE_FOR_CAPS_LOCK = 0x14;

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vlc);

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool UnregisterHotKey(IntPtr hWnd, int id);

private readonly Window _mainWindow;
WindowInteropHelper _host;

public KeyboardHandler(Window mainWindow)
{
_mainWindow = mainWindow;
_host = new WindowInteropHelper(_mainWindow);

SetupHotKey(_host.Handle);
ComponentDispatcher.ThreadPreprocessMessage += ComponentDispatcher_ThreadPreprocessMessage;
}

void ComponentDispatcher_ThreadPreprocessMessage(ref MSG msg, ref bool handled)
{
if (msg.message == WM_HOTKEY)
{
//Handle hot key kere
}
}

private void SetupHotKey(IntPtr handle)
{
RegisterHotKey(handle, GetType().GetHashCode(), 0, VIRTUALKEYCODE_FOR_CAPS_LOCK);
}

public void Dispose()
{
UnregisterHotKey(_host.Handle, GetType().GetHashCode());
}
}
}

您可以在此处获取要注册的热键的虚拟键代码：http://msdn.microsoft.com/zh-cn/library/ms927178.aspx

也许有更好的方法，但这是我到目前为止所掌握的。

干杯!

这类似于已经给出的答案，但我发现它更干净：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

using System;
using System.Windows.Forms;

namespace GlobalHotkeyExampleForm
{
public partial class ExampleForm : Form
{
[System.Runtime.InteropServices.DllImport("user32.dll")]
private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
[System.Runtime.InteropServices.DllImport("user32.dll")]
private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

enum KeyModifier
{
None = 0,
alt=1,
Control = 2,
Shift = 4,
WinKey = 8
}

public ExampleForm()
{
InitializeComponent();

int id = 0; // The id of the hotkey.
RegisterHotKey(this.Handle, id, (int)KeyModifier.Shift, Keys.A.GetHashCode()); // Register Shift + A as global hotkey.
}

protected override void WndProc(ref Message m)
{
base.WndProc(ref m);

if (m.Msg == 0x0312)
{
/* Note that the three lines below are not needed if you only want to register one hotkey.
* The below lines are useful in case you want to register multiple keys, which you can use a switch with the id as argument, or if you want to know which key/modifier was pressed for some particular reason. */

Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF); // The key of the hotkey that was pressed.
KeyModifier modifier = (KeyModifier)((int)m.LParam & 0xFFFF); // The modifier of the hotkey that was pressed.
int id = m.WParam.ToInt32(); // The id of the hotkey that was pressed.

MessageBox.Show("Hotkey has been pressed!");
// do something
}
}

private void ExampleForm_FormClosing(object sender, FormClosingEventArgs e)
{
UnregisterHotKey(this.Handle, 0); // Unregister hotkey with id 0 before closing the form. You might want to call this more than once with different id values if you are planning to register more than one hotkey.
}
}
}

我在fluxbytes.com上找到了它。

Baboon的解决方案效果最好，因为您可能有多个窗口。我做了调整，以便它使用PreviewKeyDownEvent而不是PreviewKeyUpEvent来处理击键重复。

我建议不要进行操作系统级别的注册，除非您正在编写诸如截图工具或录音应用之类的东西，否则当窗口未聚焦时，它将使您能够使用功能。

我在codeproject.com上找到了WPF项目中的Global Hotkeys，可以为我完成工作。它是相对较新的，不需要引用System.Windows.Forms，即使在"您的"应用程序不是活动窗口的情况下，它也可以"全局"地对按下的热键做出反应。

尽管有时RegisterHotKey正是您想要的，但在大多数情况下，您可能不想使用系统范围的热键。我最终使用了如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

using System.Windows;
using System.Windows.Interop;

namespace WpfApp
{
public partial class MainWindow : Window
{
const int WM_KEYUP = 0x0101;

const int VK_RETURN = 0x0D;
const int VK_LEFT = 0x25;

public MainWindow()
{
this.InitializeComponent();

ComponentDispatcher.ThreadPreprocessMessage +=
ComponentDispatcher_ThreadPreprocessMessage;
}

void ComponentDispatcher_ThreadPreprocessMessage(
ref MSG msg, ref bool handled)
{
if (msg.message == WM_KEYUP)
{
if ((int)msg.wParam == VK_RETURN)
MessageBox.Show("RETURN was pressed");

if ((int)msg.wParam == VK_LEFT)
MessageBox.Show("LEFT was pressed");
}
}
}
}

我不确定WPF，但这可能会有所帮助。我使用了RegisterHotKey(user32)中描述的解决方案(根据我的需要进行了修改)，用于C＃Windows Forms应用程序，以便在Windows中分配CTRL-KEY组合来调出C＃表单，并且效果很好(即使在Windows Vista中) 。希望对您有帮助，祝您好运！

使用NHotKey软件包，您可以将您的热键设置为全局：

https://github.com/thomaslevesque/NHotkey
https://thomaslevesque.com/2014/02/05/wf-declare-global-hotkeys-in-xaml-with-nhotkey/(如果链接断开，请使用web.archive.org)

简而言之，对于XAML，您所需要做的就是替换