KeyPressEventArgs Classe

Definizione

Spazio dei nomi:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Fornisce i dati per l'evento KeyPress.

public ref class KeyPressEventArgs : EventArgs

public class KeyPressEventArgs : EventArgs

type KeyPressEventArgs = class
    inherit EventArgs

Public Class KeyPressEventArgs
Inherits EventArgs

Ereditarietà

Object

EventArgs

KeyPressEventArgs

Esempio

Nell'esempio seguente viene illustrato l'utilizzo di KeyPressEventArgs per contare i tasti quando vengono premuti e per visualizzare i risultati dopo ogni pressione del tasto. Handled viene quindi impostato su true per impedire al sistema operativo di elaborare ulteriormente la chiave. Nell'esempio si presuppone un form con un oggetto posizionato su di TextBox esso.

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. È inoltre necessario impostare il gestore eventi. È possibile eseguire questa operazione nel costruttore per la classe.

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.

Commenti

Specifica KeyPressEventArgs il carattere composto quando l'utente preme un tasto. Ad esempio, quando l'utente preme MAIUSC + K, la KeyChar proprietà restituisce una K maiuscola.

Un KeyPress evento si verifica quando l'utente preme un tasto. Due eventi strettamente correlati all'evento KeyPress sono KeyUp e KeyDown. L'evento KeyDown precede ogni KeyPress evento quando l'utente preme un tasto e si verifica un KeyUp evento quando l'utente rilascia un tasto. Quando l'utente tiene premuto una chiave, si verificano eventi duplicati KeyDown e KeyPress ogni volta che il carattere viene ripetuto. Al rilascio viene generato un KeyUp evento.

Con ogni KeyPress evento viene passato un oggetto KeyPressEventArgs . Viene passato un KeyEventArgs oggetto con ogni KeyDown evento e KeyUp . Specifica KeyEventArgs se sono stati premuti tasti di modifica (CTRL, MAIUSC o ALT) insieme a un altro tasto. Queste informazioni sul modificatore possono essere ottenute anche tramite la ModifierKeys proprietà della Control classe .

Impostare Handled su true per annullare l'evento KeyPress . Ciò impedisce al controllo di elaborare la pressione del tasto.

Nota

Alcuni controlli elaborano determinati tratti chiave in KeyDown. Ad esempio, RichTextBox elabora la chiave Invio prima KeyPress di essere chiamata. In questi casi, non è possibile annullare l'evento KeyPress e annullare invece il tratto KeyDown della chiave.

Per informazioni sul modello di evento, vedere Gestione e generazione di eventi.

Costruttori

KeyPressEventArgs(Char)

Inizializza una nuova istanza della classe KeyPressEventArgs.

Proprietà

Handled	Ottiene o imposta un valore che indica se l'evento KeyPress è stato gestito.
KeyChar	Ottiene o imposta il carattere corrispondente al tasto premuto.

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

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