Gewusst wie: Ändern von Tastatureingaben in ein Standardsteuerelement

Windows Forms bietet die Möglichkeit, Tastatureingaben zu konsumieren und zu ändern. Der Begriff "konsumieren" beschreibt die Behandlung einer Tastatureingabe innerhalb einer Methode oder eines Ereignishandlers, sodass andere Methoden und Ereignisse weiter unten in der Meldungswarteschlange den Tastenwert nicht empfangen. Der Begriff "ändern" bezieht sich auf das Ändern des Tastenwerts, sodass Methoden und Ereignishandler weiter unten in der Meldungswarteschlange einen anderen Tastenwert empfangen. In diesem Thema wird beschrieben, wie Sie diese Aufgaben ausführen.

So konsumieren Sie eine Tastatureingabe

• Legen Sie in einem KeyPress-Ereignishandler die Handled-Eigenschaft der KeyPressEventArgs-Klasse auf true fest.

  - oder -

  Legen Sie in einem KeyDown-Ereignishandler die Handled-Eigenschaft der KeyEventArgs-Klasse auf true fest.

  Tipp

  Wenn Sie die Handled-Eigenschaft im KeyDown-Ereignishandler festlegen, wird das Auslösen des KeyPress-Ereignisses und des KeyUp-Ereignisses für die aktuelle Tastatureingabe nicht verhindert. Verwenden Sie zu diesem Zweck die SuppressKeyPress-Eigenschaft.

  Das folgende Beispiel ist ein Auszug aus einer switch-Anweisung, durch die die KeyChar-Eigenschaft der KeyPressEventArgs-Klasse überprüft wird, die von einem KeyPress-Ereignishandler empfangen wird. Dieser Code konsumiert die Eingaben über die Zeichentasten 'A' und 'a'.

  ' Consume 'A' and 'a'.
  Case ChrW(65), ChrW(97)
      MessageBox.Show(("Control.KeyPress: '" + _
          e.KeyChar.ToString() + "' consumed."))
      e.Handled = True
  

  // Consume 'A' and 'a'.
  case (char)65:
  case (char)97:
      MessageBox.Show("Control.KeyPress: '" +
          e.KeyChar.ToString() + "' consumed.");
      e.Handled = true;
      break;
  

So ändern Sie den Standardwert einer Zeichentaste

• Legen Sie in einem KeyPress-Ereignishandler die KeyChar-Eigenschaft der KeyPressEventArgs-Klasse auf den Wert der neuen Zeichentaste fest.

  Das folgende Beispiel ist ein Auszug aus einer switch-Anweisung, durch die 'B' in 'A' und 'b' in 'a' geändert wird. Beachten Sie, dass die Handled-Eigenschaft des KeyPressEventArgs-Parameters auf false festgelegt wird, sodass der neue Tastenwert an andere Methoden und Ereignisse in der Meldungswarteschlange weitergegeben wird.

      ' Modify 'B' to 'A' and forward the key.
  Case ChrW(66)
      MessageBox.Show(("Control.KeyPress: '" + _
          e.KeyChar.ToString() + "' replaced by 'A'."))
      e.KeyChar = ChrW(65)
      e.Handled = False
  
      ' Modify 'b' to 'a' and forward the key.
  Case ChrW(98)
      MessageBox.Show(("Control.KeyPress: '" + _
          e.KeyChar.ToString() + "' replaced by 'a'."))
      e.KeyChar = ChrW(97)
      e.Handled = False
  

  // Detect 'B', modify it to 'A', and forward the key.
  case (char)66:
      MessageBox.Show("Control.KeyPress: '" +
          e.KeyChar.ToString() + "' replaced by 'A'.");
      e.KeyChar = (char)65;
      e.Handled = false;
      break;
  
  // Detect 'b', modify it to 'a', and forward the key.
  case (char)98:
      MessageBox.Show("Control.KeyPress: '" +
          e.KeyChar.ToString() + "' replaced by 'a'.");
      e.KeyChar = (char)97;
      e.Handled = false;
      break;
  

So ändern Sie den Wert einer Nichtzeichen-Taste

• Überschreiben Sie eine Control-Methode, durch die Windows-Meldungen verarbeitet werden, suchen Sie die Meldung WM_KEYDOWN oder WM_SYSKEYDOWN, und legen Sie die WParam-Eigenschaft des Message-Parameters auf den Keys-Wert fest, der den neuen Wert der Nichtzeichen-Taste darstellt.

  Im folgenden Codebeispiel wird veranschaulicht, wie Sie die PreProcessMessage-Methode eines Steuerelements überschreiben, um die Tasten F1 bis F9 zu erkennen und jede Betätigung der Taste F3 in F1 zu ändern. Weitere Informationen zu Control-Methoden, die Sie überschreiben können, um Tastaturmeldungen abzufangen, finden Sie unter Benutzereingabe in einer Windows Forms-Anwendung und Funktionsweise von Tastatureingaben.

  ' Detect F1 through F9 during preprocessing and modify F3.
  Public Overrides Function PreProcessMessage(ByRef m As Message) _
      As Boolean
  
      If m.Msg = WM_KEYDOWN Then
          Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode
  
          ' Detect F1 through F9.
          Select Case keyCode
              Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                   Keys.F6, Keys.F7, Keys.F8, Keys.F9
  
                  MessageBox.Show(("Control.PreProcessMessage: '" + _
                      keyCode.ToString() + "' pressed."))
  
                  ' Replace F3 with F1, so that ProcessKeyMessage will  
                  ' receive F1 instead of F3.
                  If keyCode = Keys.F3 Then
                      m.WParam = CType(Keys.F1, IntPtr)
                      MessageBox.Show(("Control.PreProcessMessage: '" + _
                          keyCode.ToString() + "' replaced by F1."))
                  End If
          End Select
      End If
  
      ' Send all other messages to the base method.
      Return MyBase.PreProcessMessage(m)
  End Function
  

  // Detect F1 through F9 during preprocessing and modify F3.
  public override bool PreProcessMessage(ref Message m)
  {
      if (m.Msg == WM_KEYDOWN)
      {
          Keys keyCode = (Keys)m.WParam & Keys.KeyCode;
  
          // Detect F1 through F9.
          switch (keyCode)
          {
              case Keys.F1:
              case Keys.F2:
              case Keys.F3:
              case Keys.F4:
              case Keys.F5:
              case Keys.F6:
              case Keys.F7:
              case Keys.F8:
              case Keys.F9:
  
                  MessageBox.Show("Control.PreProcessMessage: '" +
                    keyCode.ToString() + "' pressed.");
  
                  // Replace F3 with F1, so that ProcessKeyMessage will  
                  // receive F1 instead of F3.
                  if (keyCode == Keys.F3)
                  {
                      m.WParam = (IntPtr)Keys.F1;
                      MessageBox.Show("Control.PreProcessMessage: '" +
                          keyCode.ToString() + "' replaced by F1.");
                  }
                  break;
          }
      }
  
      // Send all other messages to the base method.
      return base.PreProcessMessage(ref m);
  }
  

Beispiel

Im folgenden Codebeispiel wird die vollständige Anwendung der Codebeispiele aus den vorherigen Abschnitten dargestellt. Die Anwendung verwendet ein benutzerdefiniertes von der TextBox-Klasse abgeleitetes Steuerelement, um Tastatureingaben zu konsumieren und zu ändern.

Imports System
Imports System.Drawing
Imports System.Security
Imports System.Security.Permissions
Imports System.Windows.Forms


Namespace KeyboardInput
<System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _ 
    Class Form1
        Inherits Form

        ' The following Windows message value is defined in Winuser.h.
        Private WM_KEYDOWN As Integer = &H100
        Private WithEvents CustomTextBox1 As New CustomTextBox()

        <STAThread()> _
        Public Shared Sub Main()
            Application.EnableVisualStyles()
            Application.Run(New Form1())
        End Sub

        Public Sub New()
            Me.AutoSize = True
            Me.Controls.Add(CustomTextBox1)
        End Sub

        ' Consume and modify several character keys.
        Sub CustomTextBox1_KeyPress(ByVal sender As Object, _
            ByVal e As KeyPressEventArgs) Handles CustomTextBox1.KeyPress

            Select Case e.KeyChar

                ' Consume 'A' and 'a'.
                Case ChrW(65), ChrW(97)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' consumed."))
                    e.Handled = True

                    ' Modify 'B' to 'A' and forward the key.
                Case ChrW(66)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' replaced by 'A'."))
                    e.KeyChar = ChrW(65)
                    e.Handled = False

                    ' Modify 'b' to 'a' and forward the key.
                Case ChrW(98)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' replaced by 'a'."))
                    e.KeyChar = ChrW(97)
                    e.Handled = False
            End Select
        End Sub
    End Class

<System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _ 
    Public Class CustomTextBox
        Inherits TextBox

        ' The following Windows message value is defined in Winuser.h.
        Private WM_KEYDOWN As Integer = &H100

        Public Sub New()
            Me.Size = New Size(100, 100)
            Me.AutoSize = False
        End Sub

        ' Detect F1 through F9 during preprocessing and modify F3.
        Public Overrides Function PreProcessMessage(ByRef m As Message) _
            As Boolean

            If m.Msg = WM_KEYDOWN Then
                Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode

                ' Detect F1 through F9.
                Select Case keyCode
                    Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                         Keys.F6, Keys.F7, Keys.F8, Keys.F9

                        MessageBox.Show(("Control.PreProcessMessage: '" + _
                            keyCode.ToString() + "' pressed."))

                        ' Replace F3 with F1, so that ProcessKeyMessage will  
                        ' receive F1 instead of F3.
                        If keyCode = Keys.F3 Then
                            m.WParam = CType(Keys.F1, IntPtr)
                            MessageBox.Show(("Control.PreProcessMessage: '" + _
                                keyCode.ToString() + "' replaced by F1."))
                        End If
                End Select
            End If

            ' Send all other messages to the base method.
            Return MyBase.PreProcessMessage(m)
        End Function

        ' Detect F1 through F9 during processing.
        Protected Overrides Function ProcessKeyMessage(ByRef m As Message) _
            As Boolean

            If m.Msg = WM_KEYDOWN Then
                Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode

                ' Detect F1 through F9.
                Select Case keyCode
                    Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                         Keys.F6, Keys.F7, Keys.F8, Keys.F9

                        MessageBox.Show(("Control.ProcessKeyMessage: '" + _
                            keyCode.ToString() + "' pressed."))
                End Select
            End If

            ' Send all messages to the base method.
            Return MyBase.ProcessKeyMessage(m)
        End Function

    End Class
End Namespace

using System;
using System.Drawing;
using System.Windows.Forms;

namespace KeyboardInput
{
[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")]
    class Form1 : Form
    {
        // The following Windows message value is defined in Winuser.h.
        private int WM_KEYDOWN = 0x100;
        CustomTextBox CustomTextBox1 = new CustomTextBox();

        [STAThread]
        public static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }

        public Form1()
        {
            this.AutoSize = true;
            this.Controls.Add(CustomTextBox1);
            CustomTextBox1.KeyPress +=
                new KeyPressEventHandler(CustomTextBox1_KeyPress);
        }

        // Consume and modify several character keys.
        void CustomTextBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            switch (e.KeyChar)
            {
                // Consume 'A' and 'a'.
                case (char)65:
                case (char)97:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' consumed.");
                    e.Handled = true;
                    break;

                // Detect 'B', modify it to 'A', and forward the key.
                case (char)66:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' replaced by 'A'.");
                    e.KeyChar = (char)65;
                    e.Handled = false;
                    break;

                // Detect 'b', modify it to 'a', and forward the key.
                case (char)98:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' replaced by 'a'.");
                    e.KeyChar = (char)97;
                    e.Handled = false;
                    break;
            }
        }
    }
[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")]
    public class CustomTextBox : TextBox
    {
        // The following Windows message value is defined in Winuser.h.
        private int WM_KEYDOWN = 0x100;

        public CustomTextBox()
        {
            this.Size = new Size(100, 100);
            this.AutoSize = false;
        }

        // Detect F1 through F9 during preprocessing and modify F3.
        public override bool PreProcessMessage(ref Message m)
        {
            if (m.Msg == WM_KEYDOWN)
            {
                Keys keyCode = (Keys)m.WParam & Keys.KeyCode;

                // Detect F1 through F9.
                switch (keyCode)
                {
                    case Keys.F1:
                    case Keys.F2:
                    case Keys.F3:
                    case Keys.F4:
                    case Keys.F5:
                    case Keys.F6:
                    case Keys.F7:
                    case Keys.F8:
                    case Keys.F9:

                        MessageBox.Show("Control.PreProcessMessage: '" +
                          keyCode.ToString() + "' pressed.");

                        // Replace F3 with F1, so that ProcessKeyMessage will  
                        // receive F1 instead of F3.
                        if (keyCode == Keys.F3)
                        {
                            m.WParam = (IntPtr)Keys.F1;
                            MessageBox.Show("Control.PreProcessMessage: '" +
                                keyCode.ToString() + "' replaced by F1.");
                        }
                        break;
                }
            }

            // Send all other messages to the base method.
            return base.PreProcessMessage(ref m);
        }

        // Detect F1 through F9 during processing.
        protected override bool ProcessKeyMessage(ref Message m)
        {
            if (m.Msg == WM_KEYDOWN)
            {
                Keys keyCode = (Keys)m.WParam & Keys.KeyCode;

                // Detect F1 through F9.
                switch (keyCode)
                {
                    case Keys.F1:
                    case Keys.F2:
                    case Keys.F3:
                    case Keys.F4:
                    case Keys.F5:
                    case Keys.F6:
                    case Keys.F7:
                    case Keys.F8:
                    case Keys.F9:

                        MessageBox.Show("Control.ProcessKeyMessage: '" +
                          keyCode.ToString() + "' pressed.");
                        break;
                }
            }

            // Send all messages to the base method.
            return base.ProcessKeyMessage(ref m);
        }
    }
}

Kompilieren des Codes

Für dieses Beispiel sind erforderlich:

• Verweise auf die Assemblys System, System.Drawing und System.Windows.Forms.

Informationen zum Erstellen dieses Beispiels über die Befehlszeile für Visual Basic oder Visual C# finden Sie unter Erstellen von der Befehlszeile aus (Visual Basic) oder unter Erstellen über die Befehlszeile mit csc.exe. Sie können dieses Beispiel auch in Visual Studio erstellen, indem Sie den Code in ein neues Projekt einfügen. Weitere Informationen finden Sie unter Gewusst wie: Kompilieren und Ausführen eines vollständigen Windows Forms-Codebeispiels mit Visual Studio und Gewusst wie: Kompilieren und Ausführen eines vollständigen Windows Forms-Codebeispiels mit Visual Studio und Gewusst wie: Kompilieren und Ausführen eines vollständigen Windows Forms-Codebeispiels mit Visual Studio und Gewusst wie: Kompilieren und Ausführen eines vollständigen Windows Forms-Codebeispiels mit Visual Studio und Gewusst wie: Kompilieren und Ausführen eines vollständigen Windows Forms-Codebeispiels mit Visual Studio.

Siehe auch

Konzepte

Benutzereingabe in einer Windows Forms-Anwendung

Funktionsweise von Tastatureingaben

Weitere Ressourcen

Tastatureingaben in einer Windows Forms-Anwendung