Como detectar a tecla atualmente pressionada?

No Windows Forms , você pode saber, a qualquer momento, a posição atual do cursor graças aos Cursores classe .

A mesma coisa não parece estar disponível para o teclado. É possível saber se, por exemplo, oShift tecla está pressionada?

É absolutamente necessário rastrear todas as notificações do teclado (eventos KeyDown e KeyUp)?

if ((Control.ModifierKeys & Keys.Shift) != 0) 

Isso também será verdadeiro se Ctrl+ Shiftestiver desativado. Se você quiser verificar se Shift sozinho está pressionado,

if (Control.ModifierKeys == Keys.Shift)

Se você estiver em uma classe que herda Control(como um formulário), você pode remover oControl.

O código abaixo é como detectar quase todas as teclas atualmente pressionadas, não apenas a Shifttecla.

private KeyMessageFilter m_filter = new KeyMessageFilter();

private void Form1_Load(object sender, EventArgs e)
{
    Application.AddMessageFilter(m_filter);
}


public class KeyMessageFilter : IMessageFilter
{
    private const int WM_KEYDOWN = 0x0100;
    private const int WM_KEYUP = 0x0101;
    private bool m_keyPressed = false;

    private Dictionary<Keys, bool> m_keyTable = new Dictionary<Keys, bool>();

    public Dictionary<Keys, bool> KeyTable
    {
        get { return m_keyTable; }
        private set { m_keyTable = value; }
    }

    public bool IsKeyPressed()
    {
        return m_keyPressed;
    }

    public bool IsKeyPressed(Keys k)
    {
        bool pressed = false;

        if (KeyTable.TryGetValue(k, out pressed))
        {
            return pressed;
        }

        return false;
    }

    public bool PreFilterMessage(ref Message m)
    {
        if (m.Msg == WM_KEYDOWN)
        {
            KeyTable[(Keys)m.WParam] = true;

            m_keyPressed = true;
        }

        if (m.Msg == WM_KEYUP)
        {
            KeyTable[(Keys)m.WParam] = false;

            m_keyPressed = false;
        }

        return false;
    }
}

Você também pode observar o seguinte se fizer referência a System.Windows.Input

if (Keyboard.Modifiers == ModifierKeys.Shift)

O espaço para nome do teclado também pode ser usado para verificar o estado pressionado de outras teclas com Keyboard.IsKeyDown (Key) ou, se você estiver assinando um KeyDownEvent ou evento semelhante, os argumentos do evento exibem uma lista de teclas pressionadas no momento.

A maioria dessas respostas é muito complicada ou parece não funcionar para mim (por exemplo, System.Windows.Input parece não existir). Então encontrei um código de exemplo que funciona bem: http://www.switchonthecode.com/tutorials/winforms-accessing-mouse-and-keyboard-state

Caso a página desapareça no futuro, estou postando o código-fonte relevante abaixo:

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace MouseKeyboardStateTest
{
  public abstract class Keyboard
  {
    [Flags]
    private enum KeyStates
    {
      None = 0,
      Down = 1,
      Toggled = 2
    }

    [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
    private static extern short GetKeyState(int keyCode);

    private static KeyStates GetKeyState(Keys key)
    {
      KeyStates state = KeyStates.None;

      short retVal = GetKeyState((int)key);

      //If the high-order bit is 1, the key is down
      //otherwise, it is up.
      if ((retVal & 0x8000) == 0x8000)
        state |= KeyStates.Down;

      //If the low-order bit is 1, the key is toggled.
      if ((retVal & 1) == 1)
        state |= KeyStates.Toggled;

      return state;
    }

    public static bool IsKeyDown(Keys key)
    { 
      return KeyStates.Down == (GetKeyState(key) & KeyStates.Down);
    }

    public static bool IsKeyToggled(Keys key)
    { 
      return KeyStates.Toggled == (GetKeyState(key) & KeyStates.Toggled);
    }
  }
}

Desde o .NET Framework versão 3.0, é possível usar o Keyboard.IsKeyDownmétodo no novo System.Windows.Inputespaço para nome. Por exemplo:

if (((Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)) && Keyboard.IsKeyDown(Key.F))
{
    // CTRL + F is currently pressed
}

Embora faça parte do WPF, esse método funciona bem para aplicativos WinForm (desde que você adicione referências ao PresentationCore.dll e WindowsBase.dll ). Infelizmente, no entanto, as versões 3.0 e 3.5 do Keyboard.IsKeyDownmétodo não funcionaram para aplicativos WinForm. Portanto, se você quiser usá-lo em um aplicativo WinForm, precisará direcionar o .NET Framework 4.0 ou posterior para que ele funcione.

Você pode P / Invoke até o Win32 GetAsyncKeyState para testar qualquer tecla do teclado.

Você pode passar valores da enumeração Keys (por exemplo, Keys.Shift) para essa função, portanto, são necessárias apenas algumas linhas de código para adicioná-lo.

if ((ModifierKeys == Keys.Control) && ((e.KeyChar & (char)Keys.F) != 0))
{
     // CTRL+F pressed !
}

A melhor maneira que encontrei para gerenciar a entrada do teclado em um formulário do Windows Forms é processá-la após o pressionamento de tecla e antes do controle focado receber o evento. A Microsoft mantém uma Formpropriedade interna de nível chamada .KeyPreview para facilitar esta coisa precisa:

public frmForm()
{
    // ...
    frmForm.KeyPreview = true;
    // ...
}

Os eventos _KeyDown, _KeyPress e / ou _KeyUp do formulário podem ser empacotados para acessar eventos de entrada antes que o controle de formulário focado os veja, e você pode aplicar a lógica do manipulador para capturar o evento ou permitir que ele passe para o controle de formulário focado .

Embora não seja tão estruturalmente elegante quanto a arquitetura de roteamento de eventos do XAML , ela simplifica muito o gerenciamento de funções no nível do formulário no Winforms. Veja as notas do MSDN no KeyPreview para obter advertências.

if (Form.ModifierKeys == Keys.Shift)

funciona para uma caixa de texto se o código acima estiver no evento de pressionamento de tecla do formulário e nenhum outro controle captura o evento de pressionamento de tecla da tecla pressionada.

Também pode-se desejar interromper o processamento de chaves com:

e.Handled = true;

if (Control.ModifierKeys == Keys.Shift)
    //Shift is pressed

A posição x / y do cursor é uma propriedade e um pressionamento de tecla (como um clique do mouse / mouse) é um evento. A melhor prática é geralmente permitir que a interface seja orientada a eventos. A única vez em que você precisaria do descrito acima é se você está tentando fazer algo com o turno + clique com o mouse.

No WinForms:

if( Form.ModifierKeys == Keys.Shift )

Parece que uma duplicata da pergunta Stack Overflow Detect Shift é pressionada sem o uso de eventos no Windows Forms? .