Jak wykryć aktualnie wciśnięty klawisz?

W Windows Forms możesz w każdej chwili poznać aktualne położenie kursora dzięki klasie Cursors .

Wydaje się, że ta sama rzecz nie jest dostępna dla klawiatury. Czy można wiedzieć, czy np. ShiftKlawisz jest wciśnięty?

Czy absolutnie konieczne jest śledzenie każdego powiadomienia z klawiatury (zdarzenia KeyDown i KeyUp)?

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

Będzie to również prawdą, jeśli Ctrl+ nie Shiftdziała. Jeśli chcesz sprawdzić, czy sam Shift jest wciśnięty,

if (Control.ModifierKeys == Keys.Shift)

Jeśli jesteś w klasie, która dziedziczy Control(na przykład formularz), możesz usunąć rozszerzenieControl.

Poniższy kod pokazuje, jak wykryć prawie wszystkie aktualnie wciśnięte klawisze, a nie tylko Shiftklawisz.

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

Jeśli odwołujesz się do System.Windows.Input, możesz również zapoznać się z poniższymi informacjami

if (Keyboard.Modifiers == ModifierKeys.Shift)

Przestrzeń nazw Keyboard może być również używana do sprawdzania stanu wciśnięcia innych klawiszy za pomocą Keyboard.IsKeyDown (Key), lub jeśli subskrybujesz zdarzenie KeyDownEvent lub podobne, argumenty zdarzenia zawierają listę aktualnie wciśniętych klawiszy.

Większość z tych odpowiedzi jest albo zbyt skomplikowana, albo wydaje mi się, że nie działają dla mnie (np. System.Windows.Input wydaje się nie istnieć). Potem znalazłem przykładowy kod, który działa dobrze: http://www.switchonthecode.com/tutorials/winforms-accessing-mouse-and-keyboard-state

W przypadku gdyby strona zniknęła w przyszłości, zamieszczam poniżej odpowiedni kod źródłowy:

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

Od wersji .NET Framework 3.0 możliwe jest użycie Keyboard.IsKeyDownmetody z nowej System.Windows.Inputprzestrzeni nazw. Na przykład:

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

Mimo że jest częścią WPF, ta metoda działa dobrze dla aplikacji WinForm (pod warunkiem, że dodasz odwołania do PresentationCore.dll i WindowsBase.dll ). Niestety, wersje 3.0 i 3.5 tej Keyboard.IsKeyDownmetody nie działały w aplikacjach WinForm. Dlatego, jeśli chcesz go używać w aplikacji WinForm, musisz być ukierunkowany na .NET Framework 4.0 lub nowszy, aby działał.

Możesz P / Invoke w dół do Win32 GetAsyncKeyState, aby przetestować dowolny klawisz na klawiaturze.

Do tej funkcji można przekazywać wartości z wyliczenia Keys (np. Keys.Shift), więc dodanie jej wymaga tylko kilku wierszy kodu.

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

Najlepszym sposobem, w jaki udało mi się zarządzać wprowadzaniem danych z klawiatury w formularzu Windows Forms, jest przetworzenie go po naciśnięciu klawisza i przed odebraniem zdarzenia przez aktywną kontrolkę. Firma Microsoft utrzymuje wbudowaną Formwłaściwość poziomu o nazwie .KeyPreview, aby ułatwić to precyzyjne:

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

Następnie zdarzenia _KeyDown, _KeyPress i / lub _KeyUp formularza można zorganizować w celu uzyskania dostępu do zdarzeń wejściowych, zanim skoncentrowana kontrolka formularza kiedykolwiek je zobaczy, i można zastosować logikę obsługi, aby przechwycić zdarzenie w tym miejscu lub zezwolić na przejście do skoncentrowanej kontrolki formularza .

Chociaż nie jest tak strukturalnie wdzięczny jak architektura routingu zdarzeń XAML, znacznie upraszcza zarządzanie funkcjami na poziomie formularza w WinForm. Zobacz uwagi MSDN dotyczące KeyPreview, aby poznać zastrzeżenia.

if (Form.ModifierKeys == Keys.Shift)

działa dla pola tekstowego, jeśli powyższy kod znajduje się w zdarzeniu keydown formularza i żadna inna kontrolka nie przechwytuje zdarzenia keydown dla klawisza w dół.

Można również chcieć zatrzymać dalsze przetwarzanie klucza za pomocą:

e.Handled = true;

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

Pozycja kursora x / y jest właściwością, a naciśnięcie klawisza (podobnie jak kliknięcie myszą / przesunięcie myszy) jest zdarzeniem. Najlepszą praktyką jest zazwyczaj pozwalanie, aby interfejs był sterowany zdarzeniami. Prawie jedyny przypadek, w którym będziesz potrzebować powyższego, to sytuacja, w której próbujesz wykonać zmianę + kliknięcie myszą.

W WinForms:

if( Form.ModifierKeys == Keys.Shift )

Brzmi to jak duplikat pytania o przepełnienie stosu Wykryj klawisz Shift został naciśnięty bez używania zdarzeń w Windows Forms? .