1

可能重复:
检测到 globalKeyboardHook 中的 CallbackOnCollectedDelegate

我遇到了一个异常,将我的主要(也是唯一的)表单从不可见状态中调用回来。我有一个钥匙钩来观察一个让它再次可见的钥匙。但是,问题是,当按下键并加载表单时,我遇到了这个异常

对“MyProgram!Utilities.globalKeyboardHook+keyboardHookProc::Invoke”类型的垃圾收集委托进行了回调。这可能会导致应用程序崩溃、损坏和数据丢失。将委托传递给非托管代码时,托管应用程序必须使它们保持活动状态,直到保证它们永远不会被调用。

因为这是我第一次处理关键钩子,或者在不使用其他表单的情况下带回一个表单,所以我在这里有点茫然。我不确定它想要达到什么目的。我是否应该将表单的不透明度设置为 0,以防止程序尝试关闭表单?

公共部分类Form1:Form {

    //Variables

    globalKeyboardHook gkh = new globalKeyboardHook();

    public Form1()
    {
        InitializeComponent();
    }

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

    private void OpacityBar_ValueChanged(object sender, EventArgs e)
    {
        //Do stuff


    private void VisibleTSMI_Click(object sender, EventArgs e)
    {
        //Do more un-important stuff
    }

    void gkh_KeyUp(object sender, KeyEventArgs e)
    {
        if (KeyDown == true)
        {
            this.Visible = true;
        }

        e.Handled = true;
    }

    void gkh_KeyDown(object sender, KeyEventArgs e)
    {
        KeyDown = true;
        e.Handled = true;
    }


    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
    }


}

请注意; 没有更多的 Utilities 命名空间,因为我在将它与我的 Form1 代码合并后对其进行了刮擦。

4

2 回答 2

0

我认为您在删除对实例的引用后试图访问您的Utilities实例,例如:

Utilities utilities = new Utilities();
SomeMethodDelegate method = utilities.SomeMethod();
// ...
utilities = someOtherUtilitiesInstanceOrNull;
method(); // This is referencing a method that is now probably collected by the garbage collector.

Utilities当然,根据您的模型,将类设为静态可能是一个更好的主意。

于 2012-12-15T21:42:32.027 回答
0

问题

您的问题是您将委托传递给非托管代码,但未在托管代码中保留对它的引用。由于您没有对它的引用,GC 假定它是安全的收集。

我无法在您的代码中查明它,因为您尚未发布任何内容,但这是一种可能性。

您可以隐式创建委托:

SomeUnmanagedMethod(someCallback);

这转化为这样的东西:

SomeUnmanagedMethod(new SomeDelegate(someCallback));

如您所见,委托的新实例从未被引用,因此超出范围并被收集。


解决方案

您需要在托管代码中维护对您的委托的引用。一种方法是在您的Utilities类中创建一个静态变量:

static SomeDelegate callback;

然后,您可以存储对委托的引用,替换原始代码。:

callback = someCallback;
SomeUnmanagedMethod(callback);

不幸的是,我无法给出更具体的答案,因为您还没有发布任何代码。

另请参阅此答案

于 2012-12-15T21:59:37.307 回答