怎么用C#注册三键组合的全局快捷键 在线等

Question

RT
关于注册快捷键 我在网上找了很多了 都是那一片文章 是两键组合的小弟是初学 希望XDJM给点详细的提示先谢过了我的分也不多了

Answer 1

http://www.tansea.cn/article.asp?id=114C#注册全局热键调用API的.
注意其中的: RegKey(Handle,Space,MOD_ALT | MOD_CONTROL | MOD_SHIFT,VK_SPACE); //注册热键
这个就是注册多个键的

Answer 2

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;namespace WindowsFormsApplication1
{
    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);
                    Modifiers modifier = (Modifiers)((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(Modifiers 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 Modifiers _modifier;
        private Keys _key;        internal KeyPressedEventArgs(Modifiers modifier, Keys key)
        {
            _modifier = modifier;
            _key = key;
        }        public Modifiers Modifier
        {
            get { return _modifier; }
        }        public Keys Key
        {
            get { return _key; }
        }
    }    /// <summary>
    /// The enumeration of possible modifiers.
    /// </summary>
    [Flags]
    public enum Modifiers : uint
    {
        Alt = 1,
        Control = 2,
        Shift = 4,
        Win = 8
    }    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }        private void Form1_Load(object sender, EventArgs e)
        {
            var h = new KeyboardHook();
            h.RegisterHotKey(Modifiers.Alt | Modifiers.Control, Keys.A);            h.KeyPressed += new EventHandler<KeyPressedEventArgs>(h_KeyPressed);
        }        void h_KeyPressed(object sender, KeyPressedEventArgs e)
        {
            throw new NotImplementedException();
        }
    }
}