KeyPressEventArgs Classe

Definizione

public ref class KeyPressEventArgs : EventArgs

[System.Runtime.InteropServices.ComVisible(true)]
public class KeyPressEventArgs : EventArgs

public class KeyPressEventArgs : EventArgs

[<System.Runtime.InteropServices.ComVisible(true)>]
type KeyPressEventArgs = class
    inherit EventArgs

type KeyPressEventArgs = class
    inherit EventArgs

Public Class KeyPressEventArgs
Inherits EventArgs

Ereditarietà

Object

EventArgs

KeyPressEventArgs

Attributi

ComVisibleAttribute

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.

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

Costruttori

Proprietà

Metodi

Si applica a

Vedi anche

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