KeyPressEventArgs Classe

Definizione

Fornisce i dati per l'evento KeyPress.Provides data for the KeyPress event.

public ref class KeyPressEventArgs : EventArgs
[System.Runtime.InteropServices.ComVisible(true)]
public class KeyPressEventArgs : EventArgs
type KeyPressEventArgs = class
    inherit EventArgs
Public Class KeyPressEventArgs
Inherits EventArgs
Ereditarietà
KeyPressEventArgs
Attributi

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del KeyPressEventArgs per conteggiare le chiavi quando vengono premuti e visualizzare i risultati dopo ogni pressione del tasto.The following example illustrates using the KeyPressEventArgs to count keys as they are pressed and to display the results after each key press. Handled viene quindi impostato su true per impedire all'ulteriore elaborazione della chiave da parte del sistema operativo.Handled is then set to true to keep the operating system from further processing the key. Nell'esempio si presuppone che sia presente un modulo con TextBox posizionata.The example assumes a form with a TextBox placed on it.

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

È necessario creare una nuova istanza di questa classe.You must create a new instance of this class. È anche necessario impostare il gestore eventi.You must also set the event handler. Questa operazione può essere eseguita nel costruttore della classe.You can do this in the constructor for your class.

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

Quando viene generato l'evento specificato nel controllo, viene chiamato il metodo associato e l'applicazione può eseguire il codice in risposta all'evento.When the specified event is raised in the control, the attached method is called and the application can execute code in response to the event.

Commenti

Un KeyPressEventArgs specifica il carattere che viene composto quando l'utente preme un tasto.A KeyPressEventArgs specifies the character that is composed when the user presses a key. Quando l'utente preme MAIUSC + K, ad esempio, la proprietà KeyChar restituisce una lettera K maiuscola.For example, when the user presses SHIFT + K, the KeyChar property returns an uppercase K.

Un evento KeyPress si verifica quando l'utente preme un tasto.A KeyPress event occurs when the user presses a key. Sono KeyUp e KeyDowndue eventi strettamente correlati all'evento KeyPress.Two events that are closely related to the KeyPress event are KeyUp and KeyDown. L'evento KeyDown precede ogni evento KeyPress quando l'utente preme un tasto e si verifica un evento KeyUp quando l'utente rilascia un tasto.The KeyDown event precedes each KeyPress event when the user presses a key, and a KeyUp event occurs when the user releases a key. Quando l'utente utilizza una chiave, gli eventi duplicati KeyDown e KeyPress si verificano ogni volta che il carattere si ripete.When the user holds down a key, duplicate KeyDown and KeyPress events occur each time the character repeats. Un evento KeyUp viene generato al rilascio.One KeyUp event is generated upon release.

Con ogni KeyPress evento, viene passato un KeyPressEventArgs.With each KeyPress event, a KeyPressEventArgs is passed. Viene passato un KeyEventArgs con ogni KeyDown e KeyUp evento.A KeyEventArgs is passed with each KeyDown and KeyUp event. Un KeyEventArgs specifica se sono stati premuti tasti di modifica (CTRL, MAIUSC o ALT) insieme a un'altra chiave.A KeyEventArgs specifies whether any modifier keys (CTRL, SHIFT, or ALT) were pressed along with another key. (Le informazioni sul modificatore possono essere ottenute anche tramite la proprietà ModifierKeys della classe Control).(This modifier information can also be obtained through the ModifierKeys property of the Control class.)

Impostare Handled su true per annullare l'evento di KeyPress.Set Handled to true to cancel the KeyPress event. Questa operazione impedisce al controllo di elaborare la pressione del tasto.This keeps the control from processing the key press.

Nota

Alcuni controlli elaborano alcuni tratti chiave in KeyDown.Some controls will process certain key strokes on KeyDown. RichTextBox, ad esempio, elabora il tasto invio prima che venga chiamato KeyPress.For example, RichTextBox processes the Enter key before KeyPress is called. In questi casi, non è possibile annullare l'evento KeyPress ed è necessario annullare il tratto della chiave da KeyDown.In such cases, you cannot cancel the KeyPress event, and must cancel the key stroke from KeyDown instead.

Per informazioni sul modello di eventi, vedere gestione e generazione di eventi.For information about the event model, see Handling and Raising Events.

Costruttori

KeyPressEventArgs(Char)

Inizializza una nuova istanza della classe KeyPressEventArgs.Initializes a new instance of the KeyPressEventArgs class.

Proprietà

Handled

Ottiene o imposta un valore che indica se l'evento KeyPress è stato gestito.Gets or sets a value indicating whether the KeyPress event was handled.

KeyChar

Ottiene o imposta il carattere corrispondente al tasto premuto.Gets or sets the character corresponding to the key pressed.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Vedi anche