C#如何获取Ctrl+C 的值

Question

如题

Answer 1

if (e.KeyCode == Keys.F1 || e.KeyCode == Keys.F2)
            {
                if ((GetKeyState(0x70) & 0X80) == 0X80 && (GetKeyState(0x71) & 0X80) == 0X80)  
  MessageBox.Show("按下了F1和F2");
            }你去查查虚拟键码来替换

Answer 2

//在from窗体的事件中找到keydown 双击进入编辑键入如下代码
           /// <summary>
         /// 窗体键盘事件
          /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Control)//用户是否按下了Ctrl键
            {
                if (e.KeyCode == Keys.C)
                {
                   //用户按下了Ctrl+C.
                }
            }
        }
//改代码只有在改窗体获得焦点时可用.

Answer 3

先判断是否按了ctrl+c，如果按了，然后再FILE.COPY   
看下其他的答案。

Answer 4

键盘钩子事件 using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Windows.Forms;namespace Freemansoft.MeetingClient.Helps
{
    #region 定义结构    public enum WH_Codes : int
    {
        /// <summary>
        /// 底层键盘钩子
        /// </summary>
        WH_KEYBOARD_LL = 13,        /// <summary>
        /// 底层鼠标钩子
        /// </summary>
        WH_MOUSE_LL = 14
    }    public enum WM_MOUSE : int
    {
        /// <summary>
        /// 鼠标开始
        /// </summary>
        WM_MOUSEFIRST = 0x200,        /// <summary>
        /// 鼠标移动
        /// </summary>
        WM_MOUSEMOVE = 0x200,        /// <summary>
        /// 左键按下
        /// </summary>
        WM_LBUTTONDOWN = 0x201,        /// <summary>
        /// 左键释放
        /// </summary>
        WM_LBUTTONUP = 0x202,        /// <summary>
        /// 左键双击
        /// </summary>
        WM_LBUTTONDBLCLK = 0x203,        /// <summary>
        /// 右键按下
        /// </summary>
        WM_RBUTTONDOWN = 0x204,        /// <summary>
        /// 右键释放
        /// </summary>
        WM_RBUTTONUP = 0x205,        /// <summary>
        /// 右键双击
        /// </summary>
        WM_RBUTTONDBLCLK = 0x206,        /// <summary>
        /// 中键按下
        /// </summary>
        WM_MBUTTONDOWN = 0x207,        /// <summary>
        /// 中键释放
        /// </summary>
        WM_MBUTTONUP = 0x208,        /// <summary>
        /// 中键双击
        /// </summary>
        WM_MBUTTONDBLCLK = 0x209,        /// <summary>
        /// 滚轮滚动
        /// </summary>
        /// <res>WINNT4.0以上才支持此消息</res>
        WM_MOUSEWHEEL = 0x020A
    } public enum WM_KEYBOARD : int
{
/// <summary>
/// 非系统按键按下
/// </summary>
WM_KEYDOWN = 0x100, /// <summary>
/// 非系统按键释放
/// </summary>
WM_KEYUP = 0x101, /// <summary>
/// 系统按键按下
/// </summary>
WM_SYSKEYDOWN = 0x104, /// <summary>
/// 系统按键释放
/// </summary>
WM_SYSKEYUP = 0x105
}    /// <summary>
    /// 键盘钩子事件结构定义
    /// </summary>
    /// <res>详细说明请参考MSDN中关于 KBDLLHOOKSTRUCT 的说明</res>
    [StructLayout(LayoutKind.Sequential)]
    public struct KeyboardHookStruct
    {
        /// <summary>
        /// Specifies a virtual-key code. The code must be a value in the range 1 to 254. 
        /// </summary>
        public UInt32 VKCode;        /// <summary>
        /// Specifies a hardware scan code for the key.
        /// </summary>
        public UInt32 ScanCode;        /// <summary>
        /// Specifies the extended-key flag, event-injected flag, context code, 
        /// and transition-state flag. This member is specified as follows. 
        /// An application can use the following values to test the keystroke flags. 
        /// </summary>
        public UInt32 Flags;        /// <summary>
        /// Specifies the time stamp for this message. 
        /// </summary>
        public UInt32 Time;        /// <summary>
        /// Specifies extra information associated with the message. 
        /// </summary>
        public UInt32 ExtraInfo;
    }    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        public int X;
        public int Y;
    }    /// <summary>
    /// 鼠标钩子事件结构定义
    /// </summary>
    /// <res>详细说明请参考MSDN中关于 MSLLHOOKSTRUCT 的说明</res>
    [StructLayout(LayoutKind.Sequential)]
    public struct MouseHookStruct
    {
        /// <summary>
        /// Specifies a POINT structure that contains the x- and y-coordinates of the cursor, in screen coordinates.
        /// </summary>
        public POINT Point;
        public UInt32 MouseData;
        public UInt32 Flags;
        public UInt32 Time;
        public UInt32 ExtraInfo;
    }    #endregion    #region 委托声明    /// <summary>
    /// 钩子委托声明
    /// </summary>
    public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);    /// <summary>
    /// 无返回委托声明
    /// </summary>
    public delegate void VoidCallBack();    #endregion

Answer 5

    #region Win32API    class Win32API
    {
        /// <summary>
        /// 安装钩子
        /// </summary>
        [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
        public static extern IntPtr SetWindowsHookEx(WH_Codes idHook, HookProc lpfn, IntPtr pInstance, int threadId);        /// <summary>
        /// 卸载钩子
        /// </summary>
        [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(IntPtr pHookHandle);        /// <summary>
        /// 传递钩子
        /// </summary>
        [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(IntPtr pHookHandle, int nCodem, Int32 wParam, IntPtr lParam);        /// <summary>
        /// 获取按键状态
        /// </summary>
        /// <param name="pbKeyState"></param>
        /// <returns>非0表示成功</returns>
        [DllImport("user32.dll")]
        public static extern int GetKeyboardState(byte[] pbKeyState);        [DllImport("user32.dll")]
        public static extern int FineWindow(string strclassName, string strWindowName);        [DllImport("user32.dll")]
        public static extern int SendMessage(int hWnd, int msg, int wParam, int lParam);
    }    #endregion    #region 钩子类    public class Hook
    {
        private readonly byte[] m_KeyState = new byte[256];
        MouseHookStruct mouseInfo;        public MouseHookStruct MouseInfo
        {
            get { return mouseInfo; }
        }        /// <summary>
        /// 键盘钩子句柄
        /// </summary>
        private IntPtr m_pKetboardHook = IntPtr.Zero;
        /// <summary>
        /// 鼠标钩子句柄
        /// </summary>
        private IntPtr m_pMouseHook = IntPtr.Zero;
        /// <summary>
        /// 键盘钩子委托实例
        /// </summary>
        private HookProc m_KeyboardHookProcedure;
        /// <summary>
        /// 鼠标钩子委托实例
        /// </summary>
        private HookProc m_MouseHookProcedure;
        /// <summary>
        /// 鼠标更新事件委托声明
        /// </summary>
        /// <param name="x">x坐标</param>
        /// <param name="y">y坐标</param>
        public delegate void MouseUpdateEventHandler(int x, int y);
        
        /// <summary>
        /// 鼠标更新事件
        /// </summary>
        /// <res>当鼠标移动或者滚轮滚动时触发</res>
        public event MouseUpdateEventHandler OnMouseUpdate;
        //public event MouseEventHandler OnMouseChange;
        public event KeyEventHandler OnKeyDown;
        public event KeyPressEventHandler OnKeyPress;
        public event KeyEventHandler OnKeyUp;        /// <summary>
        /// 构造函数
        /// </summary>
        public Hook()
        {
            Win32API.GetKeyboardState(this.m_KeyState);
        }        ~Hook()
        {
            UnInstallHook();
        }        /// <summary>
        /// 键盘钩子处理函数
        /// </summary>
        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            if ((nCode >= 0) && (this.OnKeyDown != null || this.OnKeyPress != null || this.OnKeyUp != null))
            {
                KeyboardHookStruct KeyboardInfo = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));                if (this.OnKeyDown != null && (wParam == (Int32)WM_KEYBOARD.WM_KEYDOWN || wParam == (Int32)WM_KEYBOARD.WM_SYSKEYDOWN))
                {
                    Keys keyData = (Keys)KeyboardInfo.VKCode;
                    KeyEventArgs keyEvent = new KeyEventArgs(keyData);
                    this.OnKeyDown(this, keyEvent);
                }
            }
            return Win32API.CallNextHookEx(this.m_pKetboardHook, nCode, wParam, lParam);
        }        /// <summary>
        /// 鼠标钩子处理函数
        /// </summary>
        private int MouseHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            if ((nCode >= 0) && (this.OnMouseUpdate != null)
                && (wParam == (int)WM_MOUSE.WM_MOUSEWHEEL))
            {
                mouseInfo = (MouseHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));
                this.OnMouseUpdate(MouseInfo.Point.X, MouseInfo.Point.Y);
                //this.OnMouseChange(this,
            }            return Win32API.CallNextHookEx(this.m_pMouseHook, nCode, wParam, lParam);
        }        /// <summary>
        /// 安装钩子
        /// </summary>
        /// <returns></returns>
        public bool InstallHook()
        {
            IntPtr pInstance = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().ManifestModule);
            if (m_pKetboardHook == IntPtr.Zero)
            {
                this.m_KeyboardHookProcedure = new HookProc(this.KeyboardHookProc);
                this.m_pKetboardHook = Win32API.SetWindowsHookEx(WH_Codes.WH_KEYBOARD_LL, this.m_KeyboardHookProcedure, pInstance, 0);
                if (this.m_pKetboardHook == IntPtr.Zero)
                {
                    return false;
                }
            }
            if (this.m_pMouseHook == IntPtr.Zero)
            {
                this.m_MouseHookProcedure = new HookProc(this.MouseHookProc);
                this.m_pMouseHook = Win32API.SetWindowsHookEx(WH_Codes.WH_MOUSE_LL, this.m_MouseHookProcedure, pInstance, 0);
                if (this.m_pMouseHook == IntPtr.Zero)
                {
                    this.UnInstallHook();
                    return false;
                }
            }
            return true;
        }        /// <summary>
        /// 卸载钩子
        /// </summary>
        /// <returns></returns>
        public bool UnInstallHook()
        {
            bool result = true;
            if (this.m_pKetboardHook != IntPtr.Zero)
            {
                result = Win32API.UnhookWindowsHookEx(this.m_pKetboardHook) && result;
                this.m_pKetboardHook = IntPtr.Zero;
            }
            if (this.m_pMouseHook != IntPtr.Zero)
            {
                result = (Win32API.UnhookWindowsHookEx(this.m_pMouseHook) && result);
                this.m_pMouseHook = IntPtr.Zero;
            }
            return result;
        }
    }    #endregion
}