Comment appuyer sur une touche et la relâcher en utilisant C#?

Question

J'écris un programme C# qui capture les signaux d'un périphérique externe et envoie des frappes à une autre application. J'utilise SendKeys et ça marche bien.

SendKeys appuie sur une touche en la maintenant et en la relâchant immédiatement. Je voudrais faire pousser la clé et la relâcher à volonté.

Ma question est: "existe-t-il un moyen d'envoyer un signal" push "à une touche, puis un signal" release "après un certain laps de temps?"

Je ne suis pas sûr que SendKeys est capable de faire cela. Une idée?

Answer 1

Je ne pense pas qu'il soit possible de .NET directement Vous pouvez essayer d'utiliser l'appel natif keybd_event par p/appeler la fonction comme décrit ici: http://pinvoke.net/default.aspx/user32.keybd_event

Le MSDN pour keybd_event est ici: http://msdn.microsoft.com/en-us/library/ms646304(VS.85).aspx

J'espère que cela pourra aider!

Answer 2

Vous pouvez utiliser SendInput ou keyb_event, les deux sont des fonctions API natives. SendInput a quelques avantages par rapport à keybd_event, mais SendInput n'est disponible qu'à partir de XP.

Voici le lien msdn http://msdn.microsoft.com/en-us/library/ms646310.aspx

Hope this helps

Answer 3

Une fois, je cherchais à faire la même chose sur powerpoint, pour cacher le curseur, et plus tard pour arrêter le diaporama. Mais c'est difficile et délicat car il y a beaucoup de fenêtres de haut niveau dans powerpoint, aussi il est difficile de savoir quelle partie de l'émulation a échoué si ça ne marche pas. Après avoir regardé dans la file d'attente de messages en utilisant Spy ++, je remarque que la commande d'accélération a été envoyée après la pression de touche, donc à la place, j'ai émulé la commande d'accélération, et cela fonctionne comme charme. Donc, vous pourriez vouloir regarder dans une alternative comme celle-ci.

Answer 4

La réponse acceptée utilise keybd_event qui est obsolète. L'API officielle est maintenant SendInput. Il y a aussi un bon emballage pour cela au http://inputsimulator.codeplex.com.

Toutefois, rien de ce qui précède ne répond entièrement au scénario de "gestion des clés". Cela est dû au fait que le fait de maintenir une touche génère plusieurs messages WM_KEYDOWN, suivis d'un seul message WM_KEYUP lors de la libération (vous pouvez vérifier ceci avec Spy ++).

La fréquence des messages WM_KEYDOWN dépend du matériel, des paramètres du BIOS et de quelques paramètres Windows: KeyboardDelay et KeyboardSpeed. Ces derniers sont accessibles à partir de Windows Forms (SystemInformation.KeyboardDelay, SystemInformation.KeyboardSpeed). En utilisant la bibliothèque Input Simulator mentionnée ci-dessus, j'ai implémenté une méthode de maintien de clé qui imite le comportement réel. C'est await/async prêt, et prend en charge l'annulation.

static Task SimulateKeyHold(VirtualKeyCode key, int holdDurationMs, 
          int repeatDelayMs, int repeatRateMs, CancellationToken token) 
{ 
    var tcs = new TaskCompletionSource<object>(); 
    var ctr = new CancellationTokenRegistration(); 
    var startCount = Environment.TickCount; 
    Timer timer = null; 
    timer = new Timer(s =>   
    { 
     lock (timer) 
     { 
      if (Environment.TickCount - startCount <= holdDurationMs) 
       InputSimulator.SimulateKeyDown(key); 
      else if (startCount != -1) 
      { 
       startCount = -1; 
       timer.Dispose(); 
       ctr.Dispose();      
       InputSimulator.SimulateKeyUp(key); 
       tcs.TrySetResult(null); 
      } 
     } 
    }); 
    timer.Change(repeatDelayMs, repeatRateMs); 

    if (token.CanBeCanceled) 
     ctr = token.Register(() => 
         { 
          timer.Dispose(); 
          tcs.TrySetCanceled(); 
         }); 
    return tcs.Task; 
}