KeyPressEventArgs Clase

Definición

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

Herencia

Object

EventArgs

KeyPressEventArgs

Atributos

ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se muestra el uso de las KeyPressEventArgs teclas para contar a medida que se presionan y para mostrar los resultados después de cada pulsación de tecla. Handled a continuación, se establece en true para evitar que el sistema operativo procese aún más la clave. En el ejemplo se supone que hay un formulario con un TextBox elemento colocado en él.

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

Debe crear una nueva instancia de esta clase. También debe establecer el controlador de eventos. Puede hacerlo en el constructor de la clase .

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

Cuando se genera el evento especificado en el control , se llama al método adjunto y la aplicación puede ejecutar código en respuesta al evento.

Comentarios

Un KeyPressEventArgs especifica el carácter que se compone cuando el usuario presiona una tecla. Por ejemplo, cuando el usuario presiona MAYÚS + K, la KeyChar propiedad devuelve una K mayúscula.

Un KeyPress evento se produce cuando el usuario presiona una tecla. Dos eventos que están estrechamente relacionados con el KeyPress evento son KeyUp y KeyDown. El KeyDown evento precede a cada KeyPress evento cuando el usuario presiona una tecla y se produce un KeyUp evento cuando el usuario libera una tecla. Cuando el usuario mantiene presionada una clave, se duplican KeyDown y KeyPress se producen eventos cada vez que se repite el carácter. Se genera un KeyUp evento tras la versión.

Con cada KeyPress evento, se pasa un KeyPressEventArgs . KeyEventArgs Se pasa con cada KeyDown evento y KeyUp . Un KeyEventArgs especifica si se presionaron las teclas modificadoras (CTRL, MAYÚS o ALT) junto con otra tecla. (Esta información del modificador también se puede obtener a través de la ModifierKeys propiedad de la Control clase ).

Establézcalo Handled en true para cancelar el KeyPress evento. Esto evita que el control procese la tecla.

Para obtener información sobre el modelo de eventos, consulte Control y generación de eventos.

Constructores

Propiedades

Métodos

Se aplica a

Consulte también

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