Blocage des touches de raccourci à l'aide de C#

Question

J'utilise le code ci-dessous pour désactiver les touches Alt + Tab, Alt + Echap, Ctrl + Echap et Windows, mais cela ne fonctionne pas. S'il vous plaît, aidez-moi à le rectifier.

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

Le code en général fonctionne très bien. L'effet dont vous êtes témoin provient probablement de l'exécution dans le débogueur Visual Studio, ce qui implique généralement que vous exécutez dans le Visual Studio Hosting Process (vshost.exe).

Cela signifie que l'appel à System.Reflection.Assembly.GetExecutingAssembly() au sein de votre fonction KeyboardHook() retourne vshost.exe plutôt que votre exécutable, par conséquent l'effet désiré d'installer un hook pour votre exécutable ne peut pas être atteint.

Donc, pour voir votre code en vigueur, vous devrez faire une des opérations suivantes:

• course à l'extérieur de l'exécution Visual Studio
• à l'intérieur de Visual Studio, mais via le menu « Debug'- > « Démarrer sans débogage »
• désactiver le processus d'hébergement Visual studio, voir ci-dessous

Notez que vous pouvez disable the Visual Studio Hosting Process, mais s'il vous plaît être conscient des effets secondaires potentiels, citation:

Lorsque le processus d'hébergement est désactivé, plusieurs fonctions de débogage sont indisponibles ou de l'expérience diminué performance. Pour plus d'informations, voir Debugging and the Hosting Process.

Answer 2

Vous pouvez consulter ma réponse à une question connexe sur here. Notez la différence dans la méthode RegisterLowLevelHook (vous avez appelé la vôtre KeyboardHook pour que vous sachiez quoi comparer). Je n'ai eu aucun problème à l'utiliser même lors du débogage de VS. Fondamentalement, comme d'autres l'ont indiqué, n'utilisez pas la méthode GetExecutingAssembly mais plutôt ce que j'ai énuméré dans l'autre réponse.

Voici l'extrait pour une fonction d'intérêt pour vous:

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; 
}