KeyPressEventArgs Klasse

Definition

Namespace:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Stellt Daten für das KeyPress-Ereignis bereit.

public ref class KeyPressEventArgs : EventArgs

public class KeyPressEventArgs : EventArgs

type KeyPressEventArgs = class
    inherit EventArgs

Public Class KeyPressEventArgs
Inherits EventArgs

Vererbung

Object

EventArgs

KeyPressEventArgs

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung von KeyPressEventArgs , um Tasten zu zählen, während sie gedrückt werden, und um die Ergebnisse nach jedem Tastendruck anzuzeigen. Handled wird dann auf TRUE festgelegt, damit das Betriebssystem den Schlüssel nicht weiter verarbeitet. Im Beispiel wird ein Formular mit einem TextBox darauf platzierten Formular angenommen.

public ref class myKeyPressClass
{
private:
   static long keyPressCount = 0;
   static long backspacePressed = 0;
   static long returnPressed = 0;
   static long escPressed = 0;
   TextBox^ textBox1;
   void myKeyCounter( Object^ sender, KeyPressEventArgs^ ex )
   {
      switch ( ex->KeyChar )
      {
            // Counts the backspaces.
         case '\b':
         backspacePressed = backspacePressed + 1;
         break;

            // Counts the ENTER keys.
         case '\r':
         returnPressed = returnPressed + 1;
         break;

            // Counts the ESC keys.  
         case (char)27:
         escPressed = escPressed + 1;
         break;
            
            // Counts all other keys.
         default:
         keyPressCount = keyPressCount + 1;
         break;
      }
      textBox1->Text = String::Concat( 
         backspacePressed, " backspaces pressed\r\n",
         escPressed, " escapes pressed\r\n",
         returnPressed, " returns pressed\r\n",
         keyPressCount, " other keys pressed\r\n" );
      ex->Handled = true;
   }
};

public class myKeyPressClass 
 {
     static long keyPressCount = 0 ;
     static long backspacePressed =  0;
     static long returnPressed = 0 ;
     static long escPressed = 0 ;
     private TextBox textBox1 = new TextBox();
     private void myKeyCounter(object sender, KeyPressEventArgs ex)
     {
     switch(ex.KeyChar)
     {
             // Counts the backspaces.
         case '\b':
         backspacePressed = backspacePressed + 1;
         break ;
             // Counts the ENTER keys.
         case '\r':
         returnPressed = returnPressed + 1 ;
         break ;
             // Counts the ESC keys.  
         case (char)27:
         escPressed = escPressed + 1 ;
         break ;
             // Counts all other keys.
         default:
         keyPressCount = keyPressCount + 1 ;
         break;
     }
     
     textBox1.Text = 
         backspacePressed + " backspaces pressed\r\n" + 
         escPressed + " escapes pressed\r\n" +
         returnPressed + " returns pressed\r\n" +
         keyPressCount + " other keys pressed\r\n" ;
     ex.Handled = true ;
     }
 }

Public Class myKeyPressClass
    Private Shared keyPressCount As Long = 0
    Private Shared backspacePressed As Long = 0
    Private Shared returnPressed As Long = 0
    Private Shared escPressed As Long = 0
    Private textBox1 As TextBox
    
    Private Sub myKeyCounter(sender As Object, ex As KeyPressEventArgs)
        Select Case ex.KeyChar
            ' Counts the backspaces.
            Case ControlChars.Back
                backspacePressed = backspacePressed + 1
            ' Counts the ENTER keys.
            Case ControlChars.Lf
                returnPressed = returnPressed + 1
            ' Counts the ESC keys.  
            Case Convert.ToChar(27)
                escPressed = escPressed + 1
            ' Counts all other keys.
            Case Else
                keyPressCount = keyPressCount + 1
        End Select
        
        textBox1.Text = backspacePressed & " backspaces pressed" & _
            ControlChars.Lf & ControlChars.Cr & escPressed & _
            " escapes pressed" & ControlChars.CrLf & returnPressed & _
            " returns pressed" & ControlChars.CrLf & keyPressCount & _
            " other keys pressed" & ControlChars.CrLf
        ex.Handled = True
    End Sub
End Class

Sie müssen eine neue instance dieser Klasse erstellen. Sie müssen auch den Ereignishandler festlegen. Dies können Sie im Konstruktor für Ihre Klasse tun.

public:
   myKeyPressClass^ myKeyPressHandler;

   Form1()
   {
      myKeyPressHandler = gcnew myKeyPressClass;

      InitializeComponent();

      textBox1->KeyPress += gcnew KeyPressEventHandler(
         myKeyPressHandler, &myKeyPressClass::myKeyCounter );
   }

myKeyPressClass myKeyPressHandler = new myKeyPressClass();
public Form1()
{
     InitializeComponent();
 
     textBox1.KeyPress += new KeyPressEventHandler(myKeyPressHandler.myKeyCounter);
}

Private myKeyPressHandler As New myKeyPressClass()

Public Sub New()
    InitializeComponent()
    
    AddHandler textBox1.KeyPress, AddressOf myKeyPressHandler.myKeyCounter
End Sub

Wenn das angegebene Ereignis im Steuerelement ausgelöst wird, wird die angefügte Methode aufgerufen, und die Anwendung kann Code als Reaktion auf das Ereignis ausführen.

Hinweise

Ein KeyPressEventArgs gibt das Zeichen an, das zusammengesetzt wird, wenn der Benutzer eine Taste drückt. Wenn der Benutzer beispielsweise UMSCHALT+ K drückt, gibt die KeyChar Eigenschaft ein Großbuchstaben K zurück.

Ein KeyPress Ereignis tritt auf, wenn der Benutzer eine Taste drückt. Zwei Ereignisse, die eng mit dem KeyPress Ereignis verbunden sind, sind KeyUp und KeyDown. Das KeyDown Ereignis geht jedem KeyPress Ereignis voran, wenn der Benutzer eine Taste drückt, und ein KeyUp Ereignis tritt auf, wenn der Benutzer einen Schlüssel freigibt. Wenn der Benutzer einen Schlüssel hält, treten bei jeder Wiederholung des Zeichens Duplikate KeyDown und KeyPress Ereignisse auf. Ein KeyUp Ereignis wird bei der Veröffentlichung generiert.

Bei jedem KeyPress Ereignis wird ein KeyPressEventArgs übergeben. Ein KeyEventArgs wird mit jedem KeyDown Und-Ereignis KeyUp übergeben. A KeyEventArgs gibt an, ob alle Modifizierertasten (STRG, UMSCHALT oder ALT) zusammen mit einer anderen Taste gedrückt wurden. (Diese Modifiziererinformationen können auch über die ModifierKeys -Eigenschaft der Control -Klasse abgerufen werden.)

Legen Sie Handled auf fest true , um das KeyPress Ereignis abzubrechen. Dadurch wird verhindert, dass das Steuerelement den Tastendruck verarbeitet.

Hinweis

Einige Steuerelemente verarbeiten bestimmte Tastenstriche auf KeyDown. Verarbeitet z. B. die Eingabetaste, RichTextBox bevor KeyPress aufgerufen wird. In solchen Fällen können Sie das KeyPress Ereignis nicht abbrechen und müssen stattdessen den Tastenstrich abbrechen KeyDown .

Informationen zum Ereignismodell finden Sie unter Behandeln und Auslösen von Ereignissen.

Konstruktoren

KeyPressEventArgs(Char)

Initialisiert eine neue Instanz der KeyPressEventArgs-Klasse.

Eigenschaften

Handled	Ruft einen Wert ab, der angibt, ob das KeyPress-Ereignis behandelt wurde, oder legt diesen fest.
KeyChar	Ruft das Zeichen ab, das der gedrückten Taste entspricht, oder legt dieses fest.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• OnKeyPress(KeyPressEventArgs)
• KeyPress
• KeyEventArgs
• KeyDown
• KeyUp
• ModifierKeys