KeyPressEventArgs Klasa

Definicja

Przestrzeń nazw:

System.Windows.Forms

Zestaw:

System.Windows.Forms.dll

Źródło:

KeyPressEventArgs.cs

Udostępnia dane dla zdarzenia KeyPress.

public ref class KeyPressEventArgs : EventArgs

public class KeyPressEventArgs : EventArgs

type KeyPressEventArgs = class
    inherit EventArgs

Public Class KeyPressEventArgs
Inherits EventArgs

Dziedziczenie

Object

EventArgs

KeyPressEventArgs

Przykłady

Poniższy przykład ilustruje użycie KeyPressEventArgs klawiszy do zliczanie klawiszy podczas ich naciśnięcia i wyświetlanie wyników po każdym naciśnięciu klawisza. Handled następnie ustawiono wartość true, aby system operacyjny nie przetwarzał klucza. W przykładzie założono, że formularz z umieszczonym na nim formularzem TextBox .

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

Musisz utworzyć nowe wystąpienie tej klasy. Należy również ustawić procedurę obsługi zdarzeń. Możesz to zrobić w konstruktorze dla klasy.

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

Po wywołaniu określonego zdarzenia w kontrolce dołączona metoda jest wywoływana, a aplikacja może wykonywać kod w odpowiedzi na zdarzenie.

Uwagi

Element KeyPressEventArgs określa znak, który składa się, gdy użytkownik naciska klawisz. Na przykład gdy użytkownik naciska klawisze SHIFT + K, KeyChar właściwość zwraca wielkie litery K.

Zdarzenie KeyPress występuje, gdy użytkownik naciska klawisz. Dwa zdarzenia, które są ściśle związane ze zdarzeniem KeyPress , to KeyUp i KeyDown. Zdarzenie KeyDown poprzedza każde KeyPress zdarzenie, gdy użytkownik naciska klawisz, a KeyUp zdarzenie występuje, gdy użytkownik zwolni klucz. Gdy użytkownik przytrzymuje klucz, zduplikowane KeyDown i KeyPress zdarzenia występują za każdym razem, gdy znak się powtarza. Jedno KeyUp zdarzenie jest generowane po wydaniu.

Po każdym KeyPress zdarzeniu przekazywana jest wartość KeyPressEventArgs . Element A KeyEventArgs jest przekazywany z każdym KeyDown zdarzeniem i KeyUp . A KeyEventArgs określa, czy wszystkie klawisze modyfikatora (CTRL, SHIFT lub ALT) zostały naciśnięci wraz z innym klawiszem. (Te informacje modyfikujące można również uzyskać za pomocą ModifierKeys właściwości Control klasy).

Ustaw wartość Handled , aby anulować trueKeyPress zdarzenie. Dzięki temu kontrolka nie przetwarza naciśnięcia klawisza.

Uwaga

Niektóre kontrolki będą przetwarzać pewne pociągnięcia klawiszy na .KeyDown Na przykład RichTextBox przetwarza klucz Enter przed KeyPress wywołaniami. W takich przypadkach nie można anulować KeyPress zdarzenia i zamiast tego anulować pociągnięcie KeyDown klucza.

Aby uzyskać informacje o modelu zdarzeń, zobacz Obsługa i podnoszenie zdarzeń.

Konstruktory

KeyPressEventArgs(Char)

Inicjuje nowe wystąpienie klasy KeyPressEventArgs.

Właściwości

Handled	Pobiera lub ustawia wartość wskazującą, czy KeyPress zdarzenie zostało obsłużone.
KeyChar	Pobiera lub ustawia znak odpowiadający naciśnięciu klawisza.

Zobacz też

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