Come rilevare il tasto attualmente premuto?

In Windows Forms puoi conoscere, in ogni momento, la posizione corrente del cursore grazie alla classe Cursors .

La stessa cosa non sembra essere disponibile per la tastiera. È possibile sapere se, ad esempio, Shiftviene premuto il tasto?

È assolutamente necessario rintracciare ogni notifica da tastiera (eventi KeyDown e KeyUp)?

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

Questo sarà vero anche se Ctrl+ Shiftè in basso. Se vuoi controllare se è premuto Shift da solo,

if (Control.ModifierKeys == Keys.Shift)

Se ti trovi in ​​una classe che eredita Control(come un modulo), puoi rimuovere il fileControl.

Il codice seguente spiega come rilevare quasi tutti i tasti attualmente premuti, non solo il Shifttasto.

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

Puoi anche esaminare quanto segue se usi WPF o fai riferimento a System.Windows.Input

if (Keyboard.Modifiers == ModifierKeys.Shift)

Lo spazio dei nomi Keyboard può essere utilizzato anche per controllare lo stato premuto di altri tasti con Keyboard.IsKeyDown (Key) o, se ti stai iscrivendo a un evento KeyDownEvent o simile, gli argomenti dell'evento contengono un elenco dei tasti attualmente premuti.

La maggior parte di queste risposte sono troppo complicate o non sembrano funzionare per me (ad esempio System.Windows.Input non sembra esistere). Poi ho trovato un codice di esempio che funziona bene: http://www.switchonthecode.com/tutorials/winforms-accessing-mouse-and-keyboard-state

Nel caso in cui la pagina scompaia in futuro, inserisco il codice sorgente pertinente di seguito:

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

A partire da .NET Framework versione 3.0, è possibile utilizzare il Keyboard.IsKeyDownmetodo dal nuovo System.Windows.Inputspazio dei nomi. Per esempio:

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

Anche se fa parte di WPF, quel metodo funziona bene per le applicazioni WinForm (a condizione che si aggiungano riferimenti a PresentationCore.dll e WindowsBase.dll ). Sfortunatamente, tuttavia, le versioni 3.0 e 3.5 del Keyboard.IsKeyDownmetodo non funzionavano per le applicazioni WinForm. Pertanto, se si desidera utilizzarlo in un'applicazione WinForm, è necessario scegliere come target .NET Framework 4.0 o versioni successive affinché funzioni.

Puoi P / Invoke fino al GetAsyncKeyState Win32 per testare qualsiasi tasto sulla tastiera.

È possibile passare valori dall'enumerazione Keys (ad esempio Keys.Shift) a questa funzione, quindi sono necessarie solo un paio di righe di codice per aggiungerla.

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

Il modo migliore che ho trovato per gestire l'input da tastiera su un modulo Windows Form è elaborarlo dopo la sequenza di tasti e prima che il controllo focalizzato riceva l'evento. Microsoft mantiene una Formproprietà di livello incorporata denominata .KeyPreview per facilitare questa cosa precisa:

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

Quindi è possibile eseguire il marshalling degli eventi _KeyDown, _KeyPress e / o _KeyUp del modulo per accedere agli eventi di input prima che il controllo del modulo focalizzato li veda mai, e puoi applicare la logica del gestore per catturare l'evento lì o consentirne il passaggio al controllo del modulo focalizzato .

Sebbene non sia strutturalmente elegante come l' architettura di instradamento degli eventi di XAML , rende la gestione delle funzioni a livello di modulo in Winforms molto più semplice. Vedere le note di MSDN su KeyPreview per avvertenze.

if (Form.ModifierKeys == Keys.Shift)

funziona per una casella di testo se il codice precedente è nell'evento keydown del modulo e nessun altro controllo acquisisce l'evento keydown per il tasto down.

Inoltre si potrebbe desiderare di interrompere l'ulteriore elaborazione delle chiavi con:

e.Handled = true;

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

La posizione x / y del cursore è una proprietà e la pressione di un tasto (come un clic del mouse / mousemove) è un evento. La migliore pratica è di solito lasciare che l'interfaccia sia guidata dagli eventi. L'unica volta in cui avresti bisogno di quanto sopra è se stai cercando di fare una cosa Maiusc + clic del mouse.

In WinForms:

if( Form.ModifierKeys == Keys.Shift )

Suona come un duplicato della domanda Stack Overflow Rileva che il tasto Maiusc viene premuto senza utilizzare eventi in Windows Form? .