[C#] Traduzione codice VB.NET per implementazione "hook" di tastiera

[Zero-2]

Salve a tutti,
c'è qualche anima pia che può darmi una mano nella traduzione del seguente codice VB nel corrispondente codice C#?

' Form1.frm
Option Explicit

Implements KeyboardHook

Private Sub Form_Load()
  Set KeyboardHandler.KeyboardHook = Me
  HookKeyboard
End Sub

Private Sub Form_Unload(Cancel As Integer)
  UnhookKeyboard
End Sub


Private Function KeyboardHook_BlockAltEscape() As Boolean

End Function

Private Function KeyboardHook_BlockAltTab() As Boolean

End Function

Private Function KeyboardHook_BlockControlEscape() As Boolean
  KeyboardHook_BlockControlEscape = True
End Function

' Keyboardhandler.bas - Demonstrates low-level keyboard hooks
' Copyright (c) 2002. All Rights Reserved
' By Paul Kimmel. pkimmel@softconcepts.com

'http://msdn.microsoft.com/library/default.asp?url=
'/library/en-us/winui/WinUI/WindowsUserInterface
'/Windowing/Hooks/HookReference/HookFunctions/LowLevelKeyboardProc.asp

Option Explicit

Public Declare Function UnhookWindowsHookEx Lib "user32" _
  (ByVal hHook As Long) As Long

Public Declare Function SetWindowsHookEx Lib "user32" _
  Alias "SetWindowsHookExA" (ByVal idHook As Long, _
                             ByVal lpfn As Long, _
                             ByVal hmod As Long, _
                             ByVal dwThreadId As Long) As Long

Private Declare Sub CopyMemory Lib "kernel32" _
   Alias "RtlMoveMemory" _
  (pDest As Any, _
   pSource As Any, _
   ByVal cb As Long)

Private Declare Function GetAsyncKeyState Lib "user32" _
  (ByVal vKey As Long) As Integer

Private Declare Function CallNextHookEx Lib "user32" _
   (ByVal hHook As Long, _
   ByVal nCode As Long, _
   ByVal wParam As Long, _
   ByVal lParam As Long) As Long


Private Type KBDLLHOOKSTRUCT
  vkCode As Long
  scanCode As Long
  flags As Long
  time As Long
  dwExtraInfo As Long
End Type

' Low-Level Keyboard Constants
Private Const HC_ACTION = 0
Private Const LLKHF_EXTENDED = &H1
Private Const LLKHF_INJECTED = &H10
Private Const LLKHF_ALTDOWN = &H20
Private Const LLKHF_UP = &H80

' Virtual Keys
Public Const VK_TAB = &H9
Public Const VK_CONTROL = &H11
Public Const VK_ESCAPE = &H1B
Public Const VK_DELETE = &H2E

Private Const WH_KEYBOARD_LL = 13&
Public KeyboardHandle As Long


Public KeyboardHook As KeyboardHook


' Implement this function to block as many key combinations as
' you'd like
Public Function IsHooked(ByRef Hookstruct As KBDLLHOOKSTRUCT) _
            As Boolean

  If (KeyboardHook Is Nothing) Then
    IsHooked = False
    Exit Function
  End If

  If (Hookstruct.vkCode = VK_ESCAPE) And _
    CBool(GetAsyncKeyState(VK_CONTROL) _
    And &H8000) Then

    IsHooked = KeyboardHook.BlockControlEscape

    Call HookedState(IsHooked, "Ctrl + Esc blocked")
    Exit Function
  End If

  If (Hookstruct.vkCode = VK_TAB) And _
    CBool(Hookstruct.flags And _
    LLKHF_ALTDOWN) Then

    IsHooked = KeyboardHook.BlockAltTab

    Call HookedState(IsHooked, "Alt + Tab blocked")
    Exit Function
  End If


  If (Hookstruct.vkCode = VK_ESCAPE) And _
    CBool(Hookstruct.flags And _
      LLKHF_ALTDOWN) Then

    IsHooked = KeyboardHook.BlockAltEscape

    Call HookedState(IsHooked, "Alt + Escape blocked")
    Exit Function
  End If

End Function

Private Sub HookedState(ByVal Hooked As Boolean, _
                        ByVal Text As String)
If (Hooked) Then Debug.Print Text
End Sub


Public Function KeyboardCallback(ByVal Code As Long, _
  ByVal wParam As Long, ByVal lParam As Long) As Long

  Static Hookstruct As KBDLLHOOKSTRUCT

  If (Code = HC_ACTION) Then
    ' Copy the keyboard data out of the lParam (which is a pointer)
    Call CopyMemory(Hookstruct, ByVal lParam, Len(Hookstruct))

    If (IsHooked(Hookstruct)) Then
      KeyboardCallback = 1
      Exit Function
    End If

  End If

  KeyboardCallback = CallNextHookEx(KeyboardHandle, _
    Code, wParam, lParam)

End Function

Public Sub HookKeyboard()
  KeyboardHandle = SetWindowsHookEx( _
    WH_KEYBOARD_LL, AddressOf KeyboardCallback, _
    App.hInstance, 0&)

  Call CheckHooked
End Sub

Public Sub CheckHooked()
  If (Hooked) Then
    Debug.Print "Keyboard hooked"
  Else
    Debug.Print "Keyboard hook failed: " & Err.LastDllError
  End If
End Sub

Private Function Hooked()
  Hooked = KeyboardHandle <> 0
End Function

Public Sub UnhookKeyboard()
  If (Hooked) Then
    Call UnhookWindowsHookEx(KeyboardHandle)
  End If
End Sub

' KeyboardHook.cls
Public Function BlockControlEscape() As Boolean

End Function

Public Function BlockAltEscape() As Boolean

End Function

Public Function BlockAltTab() As Boolean

End Function

Alcune cose sono riuscito a tradurle, ma altre, non conoscendo il VB, no
Grazie anticipatamente a chiunque

[power.mobile]

se dici quali parti non sei riuscito a convertire viene più semplice anzichè farlo tutto

[Zero-2]

Diciamo che in questo frangente di tempo ho tradotto una buona parte, ho solo problemi con questo metodo.

' Implement this function to block as many key combinations as
' you'd like
Public Function IsHooked(ByRef Hookstruct As KBDLLHOOKSTRUCT) _
            As Boolean

  If (KeyboardHook Is Nothing) Then
    IsHooked = False
    Exit Function
  End If

  If (Hookstruct.vkCode = VK_ESCAPE) And _
    CBool(GetAsyncKeyState(VK_CONTROL) _
    And &H8000) Then

    IsHooked = KeyboardHook.BlockControlEscape

    Call HookedState(IsHooked, "Ctrl + Esc blocked")
    Exit Function
  End If

  If (Hookstruct.vkCode = VK_TAB) And _
    CBool(Hookstruct.flags And _
    LLKHF_ALTDOWN) Then

    IsHooked = KeyboardHook.BlockAltTab

    Call HookedState(IsHooked, "Alt + Tab blocked")
    Exit Function
  End If


  If (Hookstruct.vkCode = VK_ESCAPE) And _
    CBool(Hookstruct.flags And _
      LLKHF_ALTDOWN) Then

    IsHooked = KeyboardHook.BlockAltEscape

    Call HookedState(IsHooked, "Alt + Escape blocked")
    Exit Function
  End If

End Function

O meglio con il Cbool, non riesco a venirne a capo.
Il metodo l'ho tradotto così

public bool isHooked(ref KBDLLHOOKSTRUCT HookStruct) {
            if (keyboardHook == null)
            {
                return false;
            }
            if (HookStruct.vkCode == VK_ESCAPE && (GetAsyncKeyState(VK_CONTROL) & 0x8000)) {
                return keyboardHook.BlockControlEscape();
            }
            if (HookStruct.vkCode == VK_TAB && (HookStruct.flags & LLKHF_ALTDOWN))
            {
                return keyboardHook.BlockAtlTab();
            }
            if (HookStruct.vkCode == VK_ESCAPE && (HookStruct.flags & LLKHF_ALTDOWN))
            {
                return keyboardHook.BlockAltEscape();
            }
        }

però l'&& non va bene in quanto il primo membro è un bool ed il secondo un int.

[Zero-2]

Risolto
Di seguito la conversione per chi dovesse servire
Per come è stata scritta blocca le seguenti combinazioni :
ALT+Tab, ma è sufficiente modificare i return dei metodi della classe KeyboardHookClass.

Classe TestHook

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

namespace TestHook
{
    public delegate long KeyboardCallbackDelegation(int code, Int32 wParam, IntPtr lParam);

    public struct KBDLLHOOKSTRUCT{
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
        public int dwExtraInfo;
    }
    class Hook
    {
        [DllImport("user32")]
        public static extern short GetAsyncKeyState(int vKey);

        [DllImport("user32.dll", CharSet = CharSet.Auto,
            CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, KeyboardCallbackDelegation lpfn, IntPtr hInstance, int threadId);

        //Import for UnhookWindowsHookEx.
        //Call this function to uninstall the hook.
        [DllImport("user32.dll", CharSet = CharSet.Auto,
             CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);

        //Import for CallNextHookEx.
        //Use this function to pass the hook information to next hook procedure in chain.
        [DllImport("user32.dll", CharSet = CharSet.Auto,
             CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode,Int32 wParam, IntPtr lParam);

        //Low-Level Keyboard Constants
        private const int HC_ACTION = 0x0;
        private const int LLKHF_EXTENDED = 0x1;
        private const int LLKHF_INJECTED = 0x10;
        private const int LLKHF_ALTDOWN = 0x20;
        private const int LLKHF_UP = 0x80;

        // Virtual Keys
        public const int VK_TAB = 0x9;
        public const int VK_CONTROL = 0x11;
        public const int VK_ESCAPE = 0x1B;
        public const int VK_DELETE = 0x2E;

        private const int WH_KEYBOARD_LL = 13;

        public int keyboardHandle;

        public KeyboardHook keyboardHook;

        public Hook(KeyboardHook keyboardHook)
        {
            this.keyboardHook = keyboardHook;
        }

        public bool isHooked(ref KBDLLHOOKSTRUCT HookStruct) {
            if (keyboardHook == null)
            {
                return false;
            }
            if (HookStruct.vkCode == VK_ESCAPE && GetAsyncKeyState(VK_CONTROL)==VK_CONTROL) {
                return keyboardHook.BlockControlEscape();
            }
            if (HookStruct.vkCode == VK_TAB && (HookStruct.flags== LLKHF_ALTDOWN))
            {
                return keyboardHook.BlockAtlTab();
            }
            if (HookStruct.vkCode == VK_ESCAPE && (HookStruct.flags == LLKHF_ALTDOWN))
            {
                return keyboardHook.BlockAltEscape();
            }
            return false;
        }
        public long KeyboardCallback(int code, Int32 wParam, IntPtr lParam)
        {


            //KBDLLHOOKSTRUCT Hookstruct = new KBDLLHOOKSTRUCT();
            if (code == HC_ACTION) {
                //CopyMemory(Hookstruct, lParam.ToInt32(), 5);
                KBDLLHOOKSTRUCT Hookstruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
                if (isHooked(ref Hookstruct)) {
                    return 1;
                }
            }
            return CallNextHookEx(keyboardHandle, code, wParam, lParam);
        }
        public void HookKeyboard() {
            KeyboardCallbackDelegation keyCallbackDeleg = new KeyboardCallbackDelegation(KeyboardCallback);
            keyboardHandle = SetWindowsHookEx(WH_KEYBOARD_LL, keyCallbackDeleg, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
            if (keyboardHandle != 0)
            {
                MessageBox.Show("Keyboard hooked");
            }
            else {
                MessageBox.Show("Keyboard hooked failed");
            }
        }
        public void UnookKeyboard() {
            if (keyboardHandle != 0) {
                UnhookWindowsHookEx(keyboardHandle);
            }
        }
    }
}

Interfaccia KeyboardHook

using System;
using System.Collections.Generic;
using System.Text;

namespace TestHook
{
    interface KeyboardHook
    {
        bool BlockControlEscape();
        bool BlockAltEscape();
        bool BlockAtlTab();
    }
}

classe KeyboardHookClass

using System;
using System.Collections.Generic;
using System.Text;

namespace TestHook
{
    class KeyboardHookClass :KeyboardHook
    {
        #region KeyboardHook Membri di

        public bool BlockControlEscape()
        {
            return false;
        }

        public bool BlockAltEscape()
        {
            return false;
        }

        public bool BlockAtlTab()
        {
            return true;
        }
        #endregion

        public KeyboardHookClass () {
            
        }
    }
}

Per utilizzarla

Hook hook = new Hook(new KeyboardHookClass());
//Per bloccare la tastiera
hook.HookKeyboard();
hook.UnookKeyboard();

[Zero-2]

C'è una correzione da fare nella classe TestHook. L'oggetto delegate va impostato come membro della classe, altrimenti può portare ad un eccezione di Callback dopo l'esecuzione del Garbage Collector

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

namespace TestHook
{
public delegate long KeyboardCallbackDelegation(int code, Int32 wParam, IntPtr lParam);
private KeyboardCallbackDelegation keyCallbackDeleg = new KeyboardCallbackDelegation(KeyboardCallback);

public struct KBDLLHOOKSTRUCT{
public int vkCode;
public int scanCode;
public int flags;
public int time;
public int dwExtraInfo;
}
class Hook
{
[DllImport("user32")]
public static extern short GetAsyncKeyState(int vKey);

[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
public static extern int SetWindowsHookEx(int idHook, KeyboardCallbackDelegation lpfn, IntPtr hInstance, int threadId);

//Import for UnhookWindowsHookEx.
//Call this function to uninstall the hook.
[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
public static extern bool UnhookWindowsHookEx(int idHook);

//Import for CallNextHookEx.
//Use this function to pass the hook information to next hook procedure in chain.
[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
public static extern int CallNextHookEx(int idHook, int nCode,Int32 wParam, IntPtr lParam);

//Low-Level Keyboard Constants
private const int HC_ACTION = 0x0;
private const int LLKHF_EXTENDED = 0x1;
private const int LLKHF_INJECTED = 0x10;
private const int LLKHF_ALTDOWN = 0x20;
private const int LLKHF_UP = 0x80;

// Virtual Keys
public const int VK_TAB = 0x9;
public const int VK_CONTROL = 0x11;
public const int VK_ESCAPE = 0x1B;
public const int VK_DELETE = 0x2E;

private const int WH_KEYBOARD_LL = 13;

public int keyboardHandle;

public KeyboardHook keyboardHook;

public Hook(KeyboardHook keyboardHook)
{
this.keyboardHook = keyboardHook;
}

public bool isHooked(ref KBDLLHOOKSTRUCT HookStruct) {
if (keyboardHook == null)
{
return false;
}
if (HookStruct.vkCode == VK_ESCAPE && GetAsyncKeyState(VK_CONTROL)==VK_CONTROL) {
return keyboardHook.BlockControlEscape();
}
if (HookStruct.vkCode == VK_TAB && (HookStruct.flags== LLKHF_ALTDOWN))
{
return keyboardHook.BlockAtlTab();
}
if (HookStruct.vkCode == VK_ESCAPE && (HookStruct.flags == LLKHF_ALTDOWN))
{
return keyboardHook.BlockAltEscape();
}
return false;
}
public long KeyboardCallback(int code, Int32 wParam, IntPtr lParam)
{


//KBDLLHOOKSTRUCT Hookstruct = new KBDLLHOOKSTRUCT();
if (code == HC_ACTION) {
//CopyMemory(Hookstruct, lParam.ToInt32(), 5);
KBDLLHOOKSTRUCT Hookstruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
if (isHooked(ref Hookstruct)) {
return 1;
}
}
return CallNextHookEx(keyboardHandle, code, wParam, lParam);
}
public void HookKeyboard() {
keyboardHandle = SetWindowsHookEx(WH_KEYBOARD_LL, keyCallbackDeleg, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly ().GetModules()[0]), 0);
if (keyboardHandle != 0)
{
MessageBox.Show("Keyboard hooked");
}
else {
MessageBox.Show("Keyboard hooked failed");
}
}
public void UnookKeyboard() {
if (keyboardHandle != 0) {
UnhookWindowsHookEx(keyboardHandle);
}
}
}
}