想实现当用户输入一串字母后弹出一个窗口，用于后台配置，用什么方法检测用户任意时刻输入一串字母

Question

如题：“做一个Debug窗口，当用户输入一串字母后弹出一个窗口，用于后台配置”，对于任意时刻，检测用户输入一串特定的字母，用什么方法做最简单？我知道键盘钩子可以实现，有没有什么其它简单的方法？

Answer 1

不知道propertychanged怎么样，绑定一个事件，当值改变的时候触发某一函数（错了勿喷）

Answer 2

呵呵，我是新手，刚开始学这个。就是在看数据绑定的时候有一个propertychanged属性，比如这个<TextBox Height="32" " Name="textBox1" Width="194"   Text="{Binding ElementName=textBlock1, Path=Text, Mode=OneWayToSource, UpdateSourceTrigger=PropertyChanged}" />  我也只是猜的，不知道能实现不

Answer 3

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics;namespace WebClick_Tool
{
    public class KeyPress_o
    {
        [StructLayout(LayoutKind.Sequential)]
        public class KeyBoardHookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
        //委托 
        public delegate int HookProc(int nCode, int wParam, IntPtr lParam);
        static int hHook = 0;
        public const int WH_KEYBOARD_LL = 13;
        //LowLevel键盘截获，如果是WH_KEYBOARD＝2，并不能对系统键盘截取，Acrobat Reader会在你截取之前获得键盘。 
        static HookProc KeyBoardHookProcedure;        //设置钩子 
        [DllImport("user32.dll")]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        //抽掉钩子 
        public static extern bool UnhookWindowsHookEx(int idHook);
        [DllImport("user32.dll")]
        //调用下一个钩子 
        public static extern int CallNextHookEx(int idHook, int nCode, int wParam, IntPtr lParam);
        [DllImport("kernel32.dll")]
        public static extern int GetCurrentThreadId();
        [DllImport("kernel32.dll")]
        public static extern IntPtr GetModuleHandle(string name);        public static void Hook_Start()
        {
            if (hHook == 0)
            {
                KeyBoardHookProcedure = new HookProc(KeyBoardHookProc);
                hHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyBoardHookProcedure,
                        GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);
                //如果设置钩子失败. 
                if (hHook == 0)
                {
                    Hook_Clear();
                }
            }
        }        /// <summary>
        /// 取消钩子事件
        /// </summary>
        public static void Hook_Clear()
        {
            bool retKeyboard = true;
            if (hHook != 0)
            {
                retKeyboard = UnhookWindowsHookEx(hHook);
                hHook = 0;
            }
        }        public static int KeyBoardHookProc(int nCode, int wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                KeyBoardHookStruct kbh = (KeyBoardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyBoardHookStruct));
                Keys k = (Keys)Enum.Parse(typeof(Keys), kbh.vkCode.ToString());
                switch (k)
                {
                    case Keys.F2:
                        if (kbh.flags == 0)
                        {
                            // 这里写按下后做什么事
                            //Main.GB = true;
                            MainForm.Fs(FormBorderStyle.FixedSingle);
                            MainForm.StopAll = true;
                            MainForm.DisMes("停止...");
                            MainForm.Enb(true);
                        }
                        else if (kbh.flags == 128)
                        {
                            //放开后做什么事
                        }
                        return 1;
                }
            }
            return CallNextHookEx(hHook, nCode, wParam, lParam);
        }
    }
}

Answer 4

KeyPress_o.Hook_Start();
使用方法

Answer 5

  /// <summary>
    /// 键盘Hook管理类
    /// </summary>
    public class KeyHook
    {
        private const int WH_KEYBOARD_LL = 13; //键盘
        private const int WM_KEYDOWN = 0x0108;
        private const int WM_SYSKEYDOWN = 0x0104;
        //键盘处理事件委托.
        private delegate int HookHandle(int nCode, int wParam, IntPtr lParam);
        //客户端键盘处理事件
        public delegate void ProcessKeyHandle(HookStruct param, out bool handle);
        //接收SetWindowsHookEx返回值
        private static int _hHookValue = 0;
        //勾子程序处理事件
        private static HookHandle _KeyBoardHookProcedure;
        //Hook结构
        [StructLayout(LayoutKind.Sequential)]
        public class HookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
        //设置钩子
        [DllImport("user32.dll")]
        private static extern int SetWindowsHookEx(int idHook, HookHandle lpfn, IntPtr hInstance, int threadId);
        //取消钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        private static extern bool UnhookWindowsHookEx(int idHook);
        //调用下一个钩子
        [DllImport("user32.dll")]
        private static extern int CallNextHookEx(int idHook, int nCode, int wParam, IntPtr lParam);
        //获取当前线程ID
        [DllImport("kernel32.dll")]
        private static extern int GetCurrentThreadId();
        //Gets the main module for the associated process.
        [DllImport("kernel32.dll")]
        private static extern IntPtr GetModuleHandle(string name);
        private IntPtr _hookWindowPtr = IntPtr.Zero;
        //外部调用的键盘处理事件
        private static ProcessKeyHandle _clientMethod = null;
        /// <summary>
        /// 安装勾子
        /// <summary>
        /// <param name="hookProcess">外部调用的键盘处理事件</param>
        public void InstallHook(ProcessKeyHandle clientMethod)
        {
            _clientMethod = clientMethod;
            // 安装键盘钩子
            if (_hHookValue == 0)
            {
                _KeyBoardHookProcedure = new HookHandle(GetHookProc);
                _hookWindowPtr = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
                _hHookValue = SetWindowsHookEx(WH_KEYBOARD_LL, _KeyBoardHookProcedure, _hookWindowPtr, 0);
                //如果设置钩子失败.
                if (_hHookValue == 0)
                    UninstallHook();
            }
        }
        //取消钩子事件
        public void UninstallHook()
        {
            if (_hHookValue != 0)
            {
                bool ret = UnhookWindowsHookEx(_hHookValue);
                if (ret) _hHookValue = 0;
            }
        }
        //钩子事件内部调用,调用_clientMethod方法转发到客户端应用。
        private static int GetHookProc(int nCode, int wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                //转换结构
                HookStruct hookStruct = (HookStruct)Marshal.PtrToStructure(lParam, typeof(HookStruct));
                if (_clientMethod != null)
                {
                    bool handle = false;
                    //调用客户提供的事件处理程序。
                    _clientMethod(hookStruct, out handle);
                    if (handle) return 1; //1:表示拦截键盘,return 退出
                }
            }
            return CallNextHookEx(_hHookValue, nCode, wParam, lParam);
        }
    }

Answer 6

可以使用winform的消息队列 。。

Answer 7

protected override void WndProc(ref System.Windows.Forms.Message e)

Answer 8

网上很多啊 收一下wndproc
 http://www.cnblogs.com/zeroone/archive/2010/03/31/1701084.html

Answer 9

不好意思，这么久才回，我今天试了一下，有一个问题，需求是在用户按下debug回车后弹出一个对话框，显示是可以显示，但是，MessageBox显示大概几秒钟后会自动消失，这是什么原因啊？ switch (k)
                {
                    //case Keys.F2:
                    //    if (kbh.flags == 0)
                    //    {
                    //        // 这里写按下后做什么事
                    //        //Main.GB = true;
                    //        MainForm.Fs(FormBorderStyle.FixedSingle);
                    //        MainForm.StopAll = true;
                    //        MainForm.DisMes("停止...");
                    //        MainForm.Enb(true);
                    //    }
                    //    else if (kbh.flags == 128)
                    //    {
                    //        //放开后做什么事
                    //    }            
                    case Keys.D:
                        i = 0;
                        i++;
                        break;
                    case Keys.E:
                        if (i == 1) i++;
                        break;
                    case Keys.B:
                        if (i == 2) i++;
                        break;
                    case Keys.U:
                        if (i == 3) i++;
                        break;
                    case Keys.G:
                        if (i == 4) i++;
                        break;
                    case Keys.Enter:
                        if (i == 5)
                        {
                            i = 0;
                            MessageBox.Show("1"); 
                            return 1;                  
                        }
                        break;
                    default:
                        i = 0;
                        break;               
                }

Answer 10

同上问。
其实我不是很明白if (handle) return 1; //1:表示拦截键盘,return 退出这句，注释掉之后还是能再截获键盘的。

Answer 11

可以用的。
就是如果弹出MessageBox显示大概几秒钟后会自动消失，但是一般的WinForm窗口就不会。觉得很奇怪。

Answer 12

为什么一定要用委托啊？我用委托了，MessageBox消失得还要快。

Answer 13

贴码看看
错了勿喷。
键盘钩子：/// <summary>
    /// 键盘Hook管理类
    /// </summary>
    public class KeyHook
    {
        private const int WH_KEYBOARD_LL = 13; //键盘
        //private const int WM_KEYDOWN = 0x0108;
        //private const int WM_SYSKEYDOWN = 0x0104;        //键盘处理委托.
        private delegate int HookHandle(int nCode, int wParam, IntPtr lParam);
        //接收SetWindowsHookEx返回值
        private static int _hHookValue = 0;
        //勾子程序处理委托
        private static HookHandle _KeyBoardHookProcedure;
        //Hook结构
        [StructLayout(LayoutKind.Sequential)]
        public class HookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
        //设置钩子
        [DllImport("user32.dll")]
        private static extern int SetWindowsHookEx(int idHook, HookHandle lpfn, IntPtr hInstance, int threadId);
        //取消钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        private static extern bool UnhookWindowsHookEx(int idHook);
        //调用下一个钩子
        [DllImport("user32.dll")]
        private static extern int CallNextHookEx(int idHook, int nCode, int wParam, IntPtr lParam);
        //获取当前线程ID
        [DllImport("kernel32.dll")]
        private static extern int GetCurrentThreadId();
        //Gets the main module for the associated process.
        [DllImport("kernel32.dll")]
        private static extern IntPtr GetModuleHandle(string name);
        private IntPtr _hookWindowPtr = IntPtr.Zero;        //客户端键盘处理委托
        public delegate void ProcessKeyHandle(HookStruct param, out bool handle);  //委托
        //外部调用的键盘处理委托
        private static ProcessKeyHandle _clientMethod = null;  //委托的实例    
        static int i = 0;        public delegate void ShowFormDebugDelegate();
        public static ShowFormDebugDelegate sfDel;
        public static FormDebug formDebug = null;        /// <summary>
        /// 和委托具有相同签名的方法
        /// </summary>
        /// <param name="param"></param>
        /// <param name="handle"></param>
        public static void ProcessKeyHandleProc(HookStruct param, out bool handle)  
        {
            Keys k = (Keys)Enum.Parse(typeof(Keys), param.vkCode.ToString());
            handle = false;
            switch(k)
            {
                case Keys.D:
                    i = 0;
                    i++;
                    break;
                case Keys.E:
                    if (i == 1) i++;
                    break;
                case Keys.B:
                    if (i == 2) i++;
                    break;
                case Keys.U:
                    if (i == 3) i++;
                    break;
                case Keys.G:
                    if (i == 4) i++;
                    break;
                case Keys.Enter:
                    if (i == 5)
                    {
                        i = 0;
                        //MessageBox.Show("1");
                 
                        //formDebug = FormDebug.GetFormDebug();
                        //formDebug.Show();                        KeyHook.sfDel = new ShowFormDebugDelegate(KeyHook.ShowFormDebug);
                        sfDel();
                        handle = true;
                    }
                    break;
                default:
                    i = 0;
                    break;
            }       
        }        static void ShowFormDebug()
        {
            //formDebug = FormDebug.GetFormDebug();  //单例模式
            //formDebug.Show();
            if (formDebug==null || formDebug.IsDisposed)
            {
                formDebug = new FormDebug();
                formDebug.Show();
            }
            //MessageBox.Show("1");
        }        /// <summary>
        /// 安装勾子
        /// <summary>
        /// <param name="hookProcess">外部调用的键盘处理委托</param>
        public void InstallHook(ProcessKeyHandle clientMethod)
        {
            _clientMethod = clientMethod;
            // 安装键盘钩子
            if (_hHookValue == 0)
            {
                _KeyBoardHookProcedure = new HookHandle(GetHookProc);
                _hookWindowPtr = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
                _hHookValue = SetWindowsHookEx(WH_KEYBOARD_LL, _KeyBoardHookProcedure, _hookWindowPtr, 0);
                //如果设置钩子失败.
                if (_hHookValue == 0)
                    UninstallHook();
            }
        }        //取消钩子
        public void UninstallHook()
        {
            if (_hHookValue != 0)
            {
                bool ret = UnhookWindowsHookEx(_hHookValue);
                if (ret) _hHookValue = 0;
            }
        }        //钩子事件内部调用,调用_clientMethod方法转发到客户端应用。
        private static int GetHookProc(int nCode, int wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                //转换结构
                HookStruct hookStruct = (HookStruct)Marshal.PtrToStructure(lParam, typeof(HookStruct));
                if (_clientMethod != null)
                {
                    bool handle = false;            
                    _clientMethod(hookStruct, out handle);   //调用客户提供的处理程序
                    if (handle) return 1; //1:表示拦截键盘,return 退出
                }
            }
            return CallNextHookEx(_hHookValue, nCode, wParam, lParam);
        }
    }调用： KeyHook keyhook = new KeyHook();
            KeyHook.ProcessKeyHandle clientMethod = new KeyHook.ProcessKeyHandle(KeyHook.ProcessKeyHandleProc);  //初始化委托
            keyhook.InstallHook(clientMethod);