C#屏蔽组合键

Question

我想做一个屏幕锁定的功能，类似于网吧管理系统的客户端那样，但是不懂如何制作钩子来屏蔽组合键（如Ctrl+Alt+Z,Alt+F4……)，请高手们指点一下！！！！！！！！

Answer 1

www.codeproject.com
这个网站有C#的键盘钩子

Answer 2

//屏蔽键盘
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.IO;
using System.Reflection;namespace KeyboardDLL
{
    public class KeyboardHook
    {
        public delegate int KeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);        static int hKeyboardHook = 0;
        KeyboardProc KeyboardHookProcedure;        /// <summary>
        /// 钩子函数,需要引用空间(using System.Reflection;)
        /// 线程钩子监听键盘消息设为2,全局钩子监听键盘消息设为13
        /// 线程钩子监听鼠标消息设为7,全局钩子监听鼠标消息设为14
        /// </summary>        public const int WH_KEYBOARD = 13;
        public const int WH_MOUSE_LL = 14;
        
        public struct KeyboardMSG
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
            public int VK_CONTROL;
            public int VK_MENU;
            public int VK_DELETE;
        }        /// <summary>
        /// kernel32.dll是Windows 95,Windows 98和Windows Me中使用的32位动态链接库文件。
        /// kernel32.dll是负责内存管理、输入输出以及中断等工作。启动Windows系统之后，
        /// kernel32.dll就会被装载到不会被其他应用程序影响的受保护的内存空间中。在某些时候，
        /// 会出现invalid page fault(IPF)错误信息，这是由于其他应用程序视图访问kernel32.dll
        /// 所在的受保护内存空间引起的。不过有时，特定的某些程序也能引起这种错误。
        /// </summary>
        /// <returns></returns>
        [DllImport("kernel32")]
        public static extern int GetCurrentThreadId();        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, KeyboardProc lpfn, IntPtr hInstance, int threadId);        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, IntPtr lParam);        private int KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
            KeyboardMSG m = (KeyboardMSG)Marshal.PtrToStructure(lParam, typeof(KeyboardMSG));
            if ((int)m.vkCode == 91 || (int)m.vkCode == 92 ||(int)m.vkCode == 10)
            {
                return 1;
            }
            if (((int)m.vkCode == 46) && ((int)m.vkCode == 17) && ((int)m.vkCode == 18))
            {
                return 2;
            }
            if ((int)m.vkCode == 20)
            {
                return 1;
            }
            if (1 == 1)
            {
                return 1;
            }
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
        }        // 安装钩子
        public void KeyMaskStart()
        {
            if (hKeyboardHook == 0)
            {
                // 创建HookProc实例
                KeyboardHookProcedure = new KeyboardProc(KeyboardHookProc);                // 设置线程钩子
                hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, KeyboardHookProcedure,
                    Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
                // 如果设置钩子失败
                if (hKeyboardHook == 0)
                {
                    KeyMaskStop();
                    throw new Exception("SetWindowsHookEx failed.");
                }
            }
        }        // 卸载钩子
        public void KeyMaskStop()
        {
            bool retKeyboard = true;
            if (hKeyboardHook != 0)
            {
                retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = 0;
            }
            if (!(retKeyboard))
            {
                throw new Exception("UnhookWindowsHookEx  failed.");
            }
        }
    }
}

Answer 3

http://topic.csdn.net/u/20100614/23/67a5e6d5-5325-4e32-a0b2-19604431d4b2.html

Answer 4

3楼的方法试了一下，但是发现像QQ的热键好像就无法屏蔽掉，下面是我屏蔽Ctrl+Alt+Z的写法，不知道对不对
if (((int)m.vkCode == 162) && ((int)m.vkCode == 164) && ((int)m.vkCode == 90))
           {
               return 1;
           }

Answer 5

 if ((int)m.vkCode == (int)Keys.Z && (int)Control.ModifierKeys == (int)Keys.Control + (int)Kyes.Alt)
{
     return 1;
}这样现试一下.. 组件键是判断 Control.ModifierKeys 

Answer 6

 IntPtr hookID = IntPtr.Zero;
        HookHandlerDelegate proc;
        private const int WH_KEYBOARD_LL = 13;        /// <summary>
        /// 挂上键盘钩子
        /// </summary>
        public void KeyboardHook()
        {
            proc = new HookHandlerDelegate(HookCallback);
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                hookID = SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
                if (hookID == IntPtr.Zero) throw new System.Exception("没有足够权限安装钩子！");
            }
        }        /// <summary>
        /// 钩子函数代理
        /// </summary>
        private delegate IntPtr HookHandlerDelegate(int nCode, IntPtr wParam, ref kbdllhookstruct lParam);        //负责建立键盘钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook, HookHandlerDelegate lpfn, IntPtr hMod, uint dwThreadId);        //负责移去键盘钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        private static extern bool UnhookWindowsHookEx(IntPtr hHook);        //负责把击键信息传递到下一个监听键盘事件的应用程序
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hHook, int ncode, IntPtr wParam, ref kbdllhookstruct lParam);        // 获取一个应用程序或动态链接库的模块句柄
        [DllImport("kernel32", EntryPoint = "GetModuleHandle", SetLastError = false, CharSet = CharSet.Auto, ExactSpelling = false, CallingConvention = CallingConvention.StdCall)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);        [DllImport("user32.dll", EntryPoint = "GetAsyncKeyState", SetLastError = false, CharSet = CharSet.Auto, ExactSpelling = false, CallingConvention = CallingConvention.StdCall)]
        private static extern short GetAsyncKeyState(int vKey);        [DllImport("user32.dll", EntryPoint = "GetKeyState", SetLastError = false, CharSet = CharSet.Auto, ExactSpelling = false, CallingConvention = CallingConvention.StdCall)]
        private static extern short GetKeyState(int nVirtKey);        private const int llkhf_altdown = 0x20; //test   the   context   code
        private const short vk_tab = 0x9;
        private const short vk_control = 0x11;
        private const short vk_escape = 0x1B;
        private const short vk_win = 91;
        private const int WM_KEYDOWN = 0x100;
        private const int WM_SYSKEYDOWN = 0x104;        private struct kbdllhookstruct
        {
            public int vkcode; //a virtual-key code in the range 1 to 254
            int scancode;//hardware scan code for the key
            public int flags;   //specifies the extended-key flag, event-injected flag, context code, and transition-state flag
            int time;    //time   stamp   for   this   message
            int dwextrainfo;//extra   info   associated   with   the   message
        }        /// <summary>
        /// 钩子处理过程
        /// </summary>
        /// <param name="nCode">正常的键盘事件将返回一个大于或等于零的nCode值。</param>
        /// <param name="wParam">这个值指示发生了什么类型的事件：键被按下还是松开，以及是否按下的键是一个系统键（左边或右边的Alt键）。</param>
        /// <param name="lParam">这是一个存储精确击键信息的结构，例如被按键的代码。</param>
        /// <returns></returns>
        private IntPtr HookCallback(int nCode, IntPtr wParam, ref kbdllhookstruct lParam)
        {
            //仅为KeyDown事件过滤wParam，否则该代码将再次执行-对于每一次击键（也就是，相应于KeyDown和KeyUp）
            //WM_SYSKEYDOWN是捕获Alt相关组合键所必需的
            //if (nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)) return (IntPtr)1;
            IntPtr result = (IntPtr)1;
            if (nCode >= 0)
            {
                bool ctrldown = GetAsyncKeyState(vk_control) >> 15 == 1;
                bool altdown = (lParam.flags & llkhf_altdown) != 0;                //ctrl+esc   --------------
                if ((lParam.vkcode == vk_escape) && ctrldown) return result;                //alt+tab   --------------
                if ((lParam.vkcode == vk_tab) && altdown) return result;                //alt+esc   --------------
                if ((lParam.vkcode == vk_escape) && altdown) return result;                if ((lParam.vkcode == vk_win) && (GetKeyState(vk_win) < 0)) return result;
            }
            return CallNextHookEx(hookID, nCode, wParam, ref lParam);
        }

Answer 7

if ((int)Control.ModifierKeys == (int)Keys.Control + (int)Keys.Alt + (int)Keys.Z)
{
     return 1;
}
是这样的吗？但是发现也是不行哦

Answer 8

  /// <summary>
        /// 屏蔽alt+F4
        /// </summary>
        protected override CreateParams CreateParams
        {
            get
            {
                const int CS_NOCLOSE = 0x200;
                CreateParams cp = base.CreateParams;
                cp.ClassStyle = cp.ClassStyle | CS_NOCLOSE;
                return cp;
            }        }

Answer 9

            ShowWindow(handle, 0);//隐藏任务栏
            //限制任务管理器
            rw = new FileStream("C:\\windows\\system32\\taskmgr.exe", FileMode.Open);

Answer 10

我这里已经测试成功了. 删掉最后那个 if (1 == 1),  另外,, 调试的时候项目属性的"调试", 不要复选
启动Vistual Studio 宿主进程

Answer 11

[b]是这样:[/b]
if ((int)m.vkCode == (int)Keys.Z && (int)Control.ModifierKeys == (int)Keys.Control + (int)Keys.Alt)
{
    return 1;
}

Answer 12

hyblusea提供的方法试可行的，结贴