Blockieren von Tastenkombinationen mit C#

Question

Ich benutze den folgenden Code, um die Alt + Tab, Alt + Esc, Strg + Esc und Windows Key zu deaktivieren, aber irgendwie funktioniert es nicht. Bitte helfen Sie mir, es zu korrigieren.

namespace BlockShortcuts 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     private delegate int LowLevelKeyboardProcDelegate(int nCode, int 
      wParam, ref KBDLLHOOKSTRUCT lParam); 

     [DllImport("user32.dll", EntryPoint = "SetWindowsHookExA", CharSet = CharSet.Ansi)] 
     private static extern int SetWindowsHookEx(
      int idHook, 
      LowLevelKeyboardProcDelegate lpfn, 
      int hMod, 
      int dwThreadId); 

     [DllImport("user32.dll")] 
     private static extern int UnhookWindowsHookEx(int hHook); 

     [DllImport("user32.dll", EntryPoint = "CallNextHookEx", CharSet = CharSet.Ansi)] 
     private static extern int CallNextHookEx(
      int hHook, int nCode, 
      int wParam, ref KBDLLHOOKSTRUCT lParam); 

     const int WH_KEYBOARD_LL = 13; 
     private int intLLKey; 
     private KBDLLHOOKSTRUCT lParam; 

     private struct KBDLLHOOKSTRUCT 
     { 
      public int vkCode; 
      int scanCode; 
      public int flags; 
      int time; 
      int dwExtraInfo; 
     } 

     private int LowLevelKeyboardProc(
      int nCode, int wParam, 
      ref KBDLLHOOKSTRUCT lParam) 
     { 
      bool blnEat = false; 
      switch (wParam) 
      { 
       case 256: 
       case 257: 
       case 260: 
       case 261: 
        //Alt+Tab, Alt+Esc, Ctrl+Esc, Windows Key 
        if (((lParam.vkCode == 9) && (lParam.flags == 32)) || 
        ((lParam.vkCode == 27) && (lParam.flags == 32)) || ((lParam.vkCode == 
        27) && (lParam.flags == 0)) || ((lParam.vkCode == 91) && (lParam.flags 
        == 1)) || ((lParam.vkCode == 92) && (lParam.flags == 1)) || ((true) && 
        (lParam.flags == 32))) 
        { 
         blnEat = true; 
        } 
        break; 
      } 

      if (blnEat) 
       return 1; 
      else return CallNextHookEx(0, nCode, wParam, ref lParam); 

     } 

     private void KeyboardHook(object sender, EventArgs e) 
     { 
      intLLKey = SetWindowsHookEx(WH_KEYBOARD_LL,new LowLevelKeyboardProcDelegate(LowLevelKeyboardProc), 
         System.Runtime.InteropServices.Marshal.GetHINSTANCE(
         System.Reflection.Assembly.GetExecutingAssembly().GetModules()[0]).ToInt32(), 0); 
     } 

     private void ReleaseKeyboardHook() 
     { 
      intLLKey = UnhookWindowsHookEx(intLLKey); 
     } 

     private void checkBox1_CheckedChanged(object sender, EventArgs e) 
     { 
      if (checkBox1.Checked) 
       KeyboardHook(this, e); 
      else 
       ReleaseKeyboardHook(); 
     } 
    } 
} 

Answer 1

Der Code im Allgemeinen funktioniert gut. Der Effekt, den Sie gerade erleben, rührt daher, dass Sie unter dem Visual Studio-Debugger ausgeführt werden, was normalerweise bedeutet, dass Sie innerhalb des Visual Studio Hosting Process (vshost.exe) ausgeführt werden.

Dies bedeutet, dass der Aufruf an System.Reflection.Assembly.GetExecutingAssembly() innerhalb Ihrer KeyboardHook() Funktion vshost.exe anstelle Ihrer ausführbaren Datei zurückgibt, folglich kann der gewünschte Effekt der Installation eines Hooks für Ihre ausführbare Datei nicht erreicht werden.

So Ihr Code in der Tat sehen Sie einen der folgenden Schritte zu tun haben:

• laufen sie außerhalb von Visual Studio
• laufen sie in Visual Studio, sondern über das Menü ‚Debug'- > ‚Starten ohne Debuggen‘
• die Visual Studio-Hosting-Prozess deaktivieren, siehe unten

Beachten Sie, dass Sie konnte disable the Visual Studio Hosting Process, aber bitte beachten Sie die möglichen Nebenwirkungen, Zitat sein:

Wenn der Hosting-Prozess deaktiviert ist, mehrere Debugging-Funktionen sind nicht verfügbar oder Erfahrung verringert Leistung. Weitere Informationen finden Sie unter Debugging and the Hosting Process.

Answer 2

Sie können meine Antwort auf eine verwandte Frage über here überprüfen. Beachten Sie den Unterschied in der RegisterLowLevelHook Methode (Sie haben Ihre KeyboardHook genannt, damit Sie wissen, was zu vergleichen ist). Ich hatte auch beim Debuggen von VS keine Probleme damit. Grundsätzlich, wie andere gesagt haben, verwenden Sie nicht die GetExecutingAssembly Methode, sondern stattdessen, was ich in der anderen Antwort aufgeführt habe. Hier

ist der Ausschnitt für die eine Funktion für Sie von Interesse:

private IntPtr RegisterLowLevelHook(LowLevelKeyboardProc hook) 
{ 
    IntPtr handle = IntPtr.Zero; 

    using (Process currentProcess = Process.GetCurrentProcess()) 
    using (ProcessModule currentModule = currentProcess.MainModule) 
    { 
     IntPtr module = Kernel32.GetModuleHandle(currentModule.ModuleName); 
     handle = User32.SetWindowsHookEx(HookType.KEYBOARD_LL, hook, module, 0); 
    } 

    return handle; 
}