KeyPressEventArgs KeyPressEventArgs KeyPressEventArgs KeyPressEventArgs Class

Définition

Fournit des données pour l'événement 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
Héritage
KeyPressEventArgsKeyPressEventArgsKeyPressEventArgsKeyPressEventArgs
Attributs

Exemples

L’exemple suivant illustre l’utilisation de la KeyPressEventArgs pour compter les touches dès qu’elles sont activées et pour afficher les résultats après chaque appui sur une touche.The following example illustrates using the KeyPressEventArgs to count keys as they are pressed and to display the results after each key press. Handled puis la valeur True pour conserver le système d’exploitation à partir d’autres traite la clé.Handled is then set to true to keep the operating system from further processing the key. L’exemple suppose un formulaire avec un TextBox placé dessus.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 'myKeyCounter
End Class 'myKeyPressClass

Vous devez créer une nouvelle instance de cette classe.You must create a new instance of this class. Vous devez également définir le Gestionnaire d’événements.You must also set the event handler. Ce faire, dans le constructeur pour votre 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 'New

Lorsque l’événement spécifié est déclenché dans le contrôle, la méthode attachée est appelée et l’application peut exécuter du code en réponse à l’événement.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.

Remarques

Un KeyPressEventArgs Spécifie le caractère qui est composé lorsque l’utilisateur appuie sur une touche.A KeyPressEventArgs specifies the character that is composed when the user presses a key. Par exemple, lorsque l’utilisateur appuie sur MAJ + K, le KeyChar propriété retourne un k en majuscule.For example, when the user presses SHIFT + K, the KeyChar property returns an uppercase K.

Un KeyPress événement se produit lorsque l’utilisateur appuie sur une touche.A KeyPress event occurs when the user presses a key. Deux événements sont étroitement liées à la KeyPress événement sont KeyUp et KeyDown.Two events that are closely related to the KeyPress event are KeyUp and KeyDown. Le KeyDown événement précède chaque KeyPress événement lorsque l’utilisateur appuie sur une touche et un KeyUp événement se produit lorsque l’utilisateur relâche une touche.The KeyDown event precedes each KeyPress event when the user presses a key, and a KeyUp event occurs when the user releases a key. Lorsque l’utilisateur appuie sur une touche enfoncée, dupliquer KeyDown et KeyPress se produisent chaque fois que le caractère se répète.When the user holds down a key, duplicate KeyDown and KeyPress events occur each time the character repeats. Un seul KeyUp événement est généré dès son lancement.One KeyUp event is generated upon release.

Avec chaque KeyPress événement, un KeyPressEventArgs est passé.With each KeyPress event, a KeyPressEventArgs is passed. Un KeyEventArgs est passée avec chaque KeyDown et KeyUp événement.A KeyEventArgs is passed with each KeyDown and KeyUp event. Un KeyEventArgs Spécifie si des touches de modification (MAJ, CTRL ou ALT) ont été enfoncées en même temps que d’une autre clé.A KeyEventArgs specifies whether any modifier keys (CTRL, SHIFT, or ALT) were pressed along with another key. (Informations de ce modificateur peuvent également être obtenues via la ModifierKeys propriété de la Control classe.)(This modifier information can also be obtained through the ModifierKeys property of the Control class.)

Définissez Handled à true pour annuler le KeyPress événement.Set Handled to true to cancel the KeyPress event. Cela permet de conserver le contrôle de traiter la touche enfoncée.This keeps the control from processing the key press.

Notes

Certains contrôles traiteront des séquences de touches sur KeyDown.Some controls will process certain key strokes on KeyDown. Par exemple, RichTextBox traite la touche entrée avant KeyPress est appelée.For example, RichTextBox processes the Enter key before KeyPress is called. Dans ce cas, vous ne pouvez pas annuler la KeyPress événement et vous devez annuler la séquence de touches de KeyDown à la place.In such cases, you cannot cancel the KeyPress event, and must cancel the key stroke from KeyDown instead.

Pour plus d’informations sur le modèle d’événement, consultez gestion et déclenchement d’événements.For information about the event model, see Handling and Raising Events.

Constructeurs

KeyPressEventArgs(Char) KeyPressEventArgs(Char) KeyPressEventArgs(Char) KeyPressEventArgs(Char)

Initialise une nouvelle instance de la classe KeyPressEventArgs.Initializes a new instance of the KeyPressEventArgs class.

Propriétés

Handled Handled Handled Handled

Obtient ou définit une valeur indiquant si l'événement KeyPress a été géré.Gets or sets a value indicating whether the KeyPress event was handled.

KeyChar KeyChar KeyChar KeyChar

Obtient ou définit le caractère correspondant à la touche activée.Gets or sets the character corresponding to the key pressed.

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

S’applique à

Voir aussi