C# 如何在VSTO Word加载项中访问KeyUp和KeyDown事件？

我的问题很简单，你可以说它是重复的，但它不是这样的，因为我想在VisualStudio2015中使用C进行开发时检测VSTO Word插件中的按键事件，如

KeyUp

，

KeyDown

，并按照

KeyCode

运行其他功能

根据MSDN文档，VSTO插件没有此类事件，但它们提供了一些与之类似的其他事件，如

Document.SelectionChange事件

和

ApplicationEvents 4\u事件。Windows选择更改

事件，但它们不符合要求

那么，是否有任何方法可以使用C#…？，以简单的方式按照我的问题来实现呢

我读到的：

关于StackOverflow有许多相关问题，但没有一个与我的问题一致

我正在尝试的：

我正在尝试以下在共享的代码，此代码工作正常，但仅在Microsoft Word外部单击时捕获事件。它在键入Word时未捕获事件。我还想在事件上捕获并运行自己的函数，而不想解释自己的函数，比如键入字母等

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using Word = Microsoft.Office.Interop.Word;
using Office = Microsoft.Office.Core;
using Microsoft.Office.Tools.Word;
// Added Extra Namespaces
using System.Windows.Forms;
using Utilities;

namespace WordAddIn1
{
    public partial class ThisAddIn
    {
        globalKeyboardHook gkh = new globalKeyboardHook();

        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            gkh.HookedKeys.Add(Keys.A);
            gkh.HookedKeys.Add(Keys.B);
            gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
            gkh.KeyUp += new KeyEventHandler(gkh_KeyUp);
        }

        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {                
            gkh.KeyDown -= new KeyEventHandler(gkh_KeyDown);
            gkh.KeyUp -= new KeyEventHandler(gkh_KeyUp);
        }        

        void gkh_KeyUp(object sender, KeyEventArgs e)
        {
            MessageBox.Show("Up\t" + e.KeyCode.ToString());
            e.Handled = true;
        }

        void gkh_KeyDown(object sender, KeyEventArgs e)
        {
            MessageBox.Show("Down\t" + e.KeyCode.ToString());
            e.Handled = true;
        }

        #region VSTO generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }

        #endregion
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Xml.Linq；
使用Word=Microsoft.Office.Interop.Word；
使用Office=Microsoft.Office.Core；
使用Microsoft.Office.Tools.Word；
//添加了额外的名称空间
使用System.Windows.Forms；
使用公用设施；
名称空间WordAddIn1
{
公共部分类ThisAddIn
{
globalKeyboardHook gkh=新的globalKeyboardHook（）；
私有void ThisAddIn_启动（对象发送方，System.EventArgs e）
{
gkh.HookedKeys.Add（键A）；
gkh.HookedKeys.Add（图例B）；
gkh.KeyDown+=新的KeyEventHandler（gkh_KeyDown）；
gkh.KeyUp+=新的KeyEventHandler（gkh_KeyUp）；
}
私有void ThisAddIn_关闭（对象发送方，System.EventArgs e）
{                
gkh.KeyDown-=新的KeyEventHandler（gkh_KeyDown）；
gkh.KeyUp-=新的KeyEventHandler（gkh_KeyUp）；
}        
void gkh_KeyUp（对象发送方，KeyEventArgs e）
{
Show（“Up\t”+e.KeyCode.ToString（））；
e、 已处理=正确；
}
void gkh_KeyDown（对象发送器，KeyEventArgs e）
{
Show（“Down\t”+e.KeyCode.ToString（））；
e、 已处理=正确；
}
#区域VSTO生成的代码
/// 
///设计器支持所需的方法-不修改
///此方法的内容与代码编辑器一起使用。
/// 
私有void InternalStartup（）
{
this.Startup+=new System.EventHandler（ThisAddIn\u启动）；
this.Shutdown+=new System.EventHandler（ThisAddIn\u Shutdown）；
}
#端区
}
}

我的主要类文件是

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace Utilities
{
    /// <summary>
    /// A class that manages a global low level keyboard hook
    /// </summary>
    class globalKeyboardHook
    {
        #region Constant, Structure and Delegate Definitions
        /// <summary>
        /// defines the callback type for the hook
        /// </summary>
        public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);

        public struct keyboardHookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }

        const int WH_KEYBOARD_LL = 13;
        const int WM_KEYDOWN = 0x100;
        const int WM_KEYUP = 0x101;
        const int WM_SYSKEYDOWN = 0x104;
        const int WM_SYSKEYUP = 0x105;
        #endregion

        #region Instance Variables
        /// <summary>
        /// The collections of keys to watch for
        /// </summary>
        public List<Keys> HookedKeys = new List<Keys>();
        /// <summary>
        /// Handle to the hook, need this to unhook and call the next hook
        /// </summary>
        IntPtr hhook = IntPtr.Zero;
        #endregion

        #region Events
        /// <summary>
        /// Occurs when one of the hooked keys is pressed
        /// </summary>
        public event KeyEventHandler KeyDown;
        /// <summary>
        /// Occurs when one of the hooked keys is released
        /// </summary>
        public event KeyEventHandler KeyUp;
        #endregion

        #region Constructors and Destructors
        /// <summary>
        /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
        /// </summary>
        public globalKeyboardHook()
        {
            hook();
        }

        /// <summary>
        /// Releases unmanaged resources and performs other cleanup operations before the
        /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
        /// </summary>
        ~globalKeyboardHook()
        {
            unhook();
        }
        #endregion

        #region Public Methods
        /// <summary>
        /// Installs the global hook
        /// </summary>
        public void hook()
        {
            IntPtr hInstance = LoadLibrary("User32");
            hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
        }

        /// <summary>
        /// Uninstalls the global hook
        /// </summary>
        public void unhook()
        {
            UnhookWindowsHookEx(hhook);
        }

        /// <summary>
        /// The callback for the keyboard hook
        /// </summary>
        /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
        /// <param name="wParam">The event type</param>
        /// <param name="lParam">The keyhook event information</param>
        /// <returns></returns>
        public int hookProc(int code, int wParam, ref keyboardHookStruct lParam)
        {
            if (code >= 0)
            {
                Keys key = (Keys)lParam.vkCode;
                if (HookedKeys.Contains(key))
                {
                    KeyEventArgs kea = new KeyEventArgs(key);
                    if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
                    {
                        KeyDown(this, kea);
                    }
                    else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null))
                    {
                        KeyUp(this, kea);
                    }
                    if (kea.Handled)
                        return 1;
                }
            }
            return CallNextHookEx(hhook, code, wParam, ref lParam);
        }
        #endregion

        #region DLL imports
        /// <summary>
        /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
        /// </summary>
        /// <param name="idHook">The id of the event you want to hook</param>
        /// <param name="callback">The callback.</param>
        /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
        /// <param name="threadId">The thread you want to attach the event to, can be null</param>
        /// <returns>a handle to the desired hook</returns>
        [DllImport("user32.dll")]
        static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);

        /// <summary>
        /// Unhooks the windows hook.
        /// </summary>
        /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
        /// <returns>True if successful, false otherwise</returns>
        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hInstance);

        /// <summary>
        /// Calls the next hook.
        /// </summary>
        /// <param name="idHook">The hook id</param>
        /// <param name="nCode">The hook code</param>
        /// <param name="wParam">The wparam.</param>
        /// <param name="lParam">The lparam.</param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);

        /// <summary>
        /// Loads the library.
        /// </summary>
        /// <param name="lpFileName">Name of the library</param>
        /// <returns>A handle to the library</returns>
        [DllImport("kernel32.dll")]
        static extern IntPtr LoadLibrary(string lpFileName);
        #endregion
    }
}

使用系统；
使用System.Collections.Generic；
使用系统文本；
使用System.Runtime.InteropServices；
使用System.Windows.Forms；
命名空间实用程序
{
/// 
///管理全局低级键盘挂钩的类
/// 
类globalKeyboardHook
{
#区域常量、结构和委托定义
/// 
///定义钩子的回调类型
/// 
公共委托int keyboardHookProc（int代码、int wParam、ref keyboardHookStruct lParam）；
公共结构keyboardHookStruct
{
公共int-vkCode；
公共int扫描码；
公共国旗；
公共整数时间；
公共信息；
}
const int WH_键盘LL=13；
常量int WM_KEYDOWN=0x100；
常量int WM_KEYUP=0x101；
常量int WM_SYSKEYDOWN=0x104；
常量int WM_SYSKEYUP=0x105；
#端区
#区域实例变量
/// 
///要监视的密钥集合
/// 
public List HookedKeys=新列表（）；
/// 
///钩子的句柄，需要这个来解开钩子并调用下一个钩子
/// 
IntPtr hhook=IntPtr.Zero；
#端区
#地区活动
/// 
///在按下其中一个钩形键时发生
/// 
公共事件KeyEventHandler KeyDown；
/// 
///释放其中一个挂钩键时发生
/// 
公共事件KeyEventHandler KeyUp；
#端区
#区域构造函数和析构函数
/// 
///初始化类的新实例并安装键盘挂钩。
/// 
公共globalKeyboardHook（）
{
钩子（）；
}
/// 
///释放非托管资源并在
///由垃圾回收回收并卸载键盘挂钩。
/// 
~globalKeyboardHook（）
{
解开钩（）；
}
#端区
#区域公共方法
/// 
///安装全局钩子
/// 
公共空钩（）
{
IntPtr hInstance=LoadLibrary（“User32”）；
hhook=SetWindowsHookEx（WH_-KEYBOARD，hookProc，hInstance，0）；
}
/// 
///卸载全局钩子
/// 
公共空间取消挂钩（）
{
脱钩（hhook）；
}
/// 
///键盘挂钩的回调
/// 
///钩子代码，如果它不是>=0，函数不应该做任何事情
///事件类型
///keyhook事件信息
/// 
public int hookProc（int代码、int wParam、ref keyboardHookStruct lParam）
{
如果（代码>=0）
{
Keys key=（Keys）lParam.vkCode；
如果（胡克基）