可能重复：
CallbackOnCollectedDelegate in globalKeyboardHook was detected
我遇到一个异常，因为我的主要（和唯一）表单是不可见的。我有一个钥匙钩，可以看到一个能让它再次可见的钥匙。但问题是，当按下键并且表单加载时，我遇到了这个异常
对“MyProgram！Utilities.globalKeyboardHook + keyboardHookProc :: Invoke”类型的垃圾收集委托进行了回调。这可能会导致应用程序崩溃，损坏和数据丢失。将委托传递给非托管代码时，托管应用程序必须将它们保持活动状态，直到确保它们永远不会被调用为止。
由于这是我第一次处理关键钩子，或者在没有使用其他形式的情况下将表格带回来，我在这里有点不知所措。我不确定它想要达到的目的。我应该只是将窗体的不透明度设置为0，以防止程序试图关闭窗体吗？
公共部分类Form1：表单 {
//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代码合并它之后就抓了它。
答案 0 :(得分：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类保持静态。
答案 1 :(得分：0)
您的问题是您将委托传递给非托管代码，但未在托管代码中保留对它的引用。由于您没有对它的引用，因此GC认为收集它是安全的。
我无法在你的代码中找到它，因为你还没有发布任何内容，但这是有可能的。
您可以隐式创建委托：
SomeUnmanagedMethod(someCallback);
这意味着：
SomeUnmanagedMethod(new SomeDelegate(someCallback));
正如您所看到的，委托的新实例从未被引用，因此超出了范围并被收集。
您需要在托管代码中维护对代理的引用。一种方法是在Utilities类中创建一个静态变量：
static SomeDelegate callback;
然后，您可以存储对委托的引用，替换原始代码。：
callback = someCallback;
SomeUnmanagedMethod(callback);
不幸的是，由于您尚未发布任何代码，我无法给出更具体的答案。
另见this answer。