Les événements en C# WinForms : Click, TextChanged, Load

Un événement est un signal qu'un objet envoie quand quelque chose se produit : un clic sur un bouton, une frappe au clavier, l'ouverture d'une fenêtre. La programmation événementielle consiste à écrire des méthodes, les gestionnaires d'événements, que le programme appelle quand ces signaux arrivent. C'est le changement de logique le plus important quand on passe de la console à une application graphique.

Un programme qui attend

Un programme console déroule ses instructions de haut en bas : il demande, attend la réponse, calcule, affiche, et se termine. Une application WinForms affiche sa fenêtre, puis attend. Elle ne fait rien tant que l'utilisateur n'agit pas. Chaque action produit un événement, et ton code y répond.

Concrètement, Windows place chaque action (clic, touche, déplacement de souris, demande de redessin) dans une file de messages. La méthode Application.Run, appelée dans Program.cs, tourne en boucle : elle retire un message de la file, trouve le contrôle concerné, et celui-ci déclenche l'événement correspondant. Si tu as abonné une méthode à cet événement, elle s'exécute. Puis la boucle reprend.

Retiens la conséquence de ce schéma, elle reviendra au chapitre 7 : un seul message est traité à la fois. Tant que ton gestionnaire travaille, la fenêtre ne peut ni se redessiner ni réagir aux clics. Un gestionnaire doit donc rendre la main vite.

Écrire un gestionnaire d'événement

Il y a trois façons d'abonner une méthode à un événement.

1. Le double-clic dans le concepteur. Double-clique sur un bouton : Visual Studio crée la méthode btnEnregistrer_Click dans FrmPatients.cs et l'abonne à l'événement par défaut du contrôle (Click pour un bouton, TextChanged pour une zone de texte, Load pour un formulaire).

2. La liste des événements. Sélectionne le contrôle, clique sur l'éclair dans la fenêtre Propriétés, puis double-clique sur l'événement voulu (KeyPress, Validating, CellDoubleClick…). C'est la façon de choisir un événement qui n'est pas celui par défaut.

3. Le code. L'opérateur += abonne une méthode, -= la désabonne :

public FrmPatients()
{
    InitializeComponent();
    btnActualiser.Click += btnActualiser_Click;
    txtRecherche.TextChanged += (sender, e) => Filtrer();   // une expression lambda
}

Dans les deux premiers cas, la ligne btnEnregistrer.Click += btnEnregistrer_Click; est écrite par le concepteur dans FrmPatients.Designer.cs. Le résultat est le même.

Un gestionnaire a toujours la même forme :

private void btnEnregistrer_Click(object? sender, EventArgs e)
{
    // ce qui doit se passer au clic
}

• sender est l'objet qui a déclenché l'événement : ici, le bouton.
• e contient les informations sur l'événement. Pour un clic, EventArgs ne contient rien ; pour d'autres événements, c'est une classe dérivée plus riche.

Selon la version de Visual Studio, le concepteur écrit object sender ou object? sender ; les deux fonctionnent. Le point d'interrogation dit que sender peut être null, ce qui correspond à la définition de l'événement quand les types nullables sont activés.

Utiliser sender : un gestionnaire pour plusieurs contrôles

Quand plusieurs contrôles font presque la même chose, un seul gestionnaire suffit. sender dit lequel a été cliqué. Sur un pavé de posologie, chaque bouton ajoute son texte à la zone de saisie :

public FrmOrdonnance()
{
    InitializeComponent();
    foreach (Button bouton in new[] { btnMatin, btnMidi, btnSoir })
    {
        bouton.Click += btnMoment_Click;
    }
}

private void btnMoment_Click(object? sender, EventArgs e)
{
    if (sender is Button bouton)
    {
        txtPosologie.AppendText(bouton.Text + " ");
    }
}

sender is Button bouton vérifie que l'expéditeur est bien un bouton et le range dans la variable bouton, en une seule expression.

Les EventArgs qui servent

Deux exemples tirés de GSB Ordonnances. Le premier n'accepte que des chiffres dans le numéro de sécurité sociale : mettre e.Handled à true empêche le caractère d'apparaître. Les touches de contrôle (retour arrière, Ctrl + V) restent permises.

private void txtSecu_KeyPress(object? sender, KeyPressEventArgs e)
{
    if (!char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar))
    {
        e.Handled = true;
    }
}

Le second ouvre la fiche du patient par un double-clic sur sa ligne. RowIndex vaut -1 quand on double-clique sur l'en-tête de colonne : il faut l'exclure.

private void dgvPatients_CellDoubleClick(object? sender, DataGridViewCellEventArgs e)
{
    if (e.RowIndex >= 0)
    {
        btnModifier.PerformClick();   // même action que le bouton Modifier
    }
}

Les événements courants

La vie d'un formulaire

Un formulaire passe par des étapes, chacune avec son événement. Savoir lequel utiliser évite bien des bugs.

FormClosing sert à protéger les saisies non enregistrées. e.CloseReason dit pourquoi la fenêtre se ferme : un clic sur la croix (UserClosing), l'arrêt de Windows (WindowsShutDown), etc.

private void FrmPatientEdition_FormClosing(object? sender, FormClosingEventArgs e)
{
    if (!_modifie || e.CloseReason != CloseReason.UserClosing) return;

    DialogResult reponse = MessageBox.Show(
        "Des modifications ne sont pas enregistrées. Fermer quand même ?",
        "GSB Ordonnances", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);

    if (reponse == DialogResult.No)
    {
        e.Cancel = true;   // la fenêtre reste ouverte
    }
}

Un événement qui revient régulièrement : le Timer

Le composant Timer de System.Windows.Forms déclenche Tick à intervalle régulier, sur le thread de l'interface : tu peux modifier les contrôles sans précaution. Il sert à afficher une horloge, à rafraîchir une liste toutes les minutes, ou à fermer une session inactive.

timerHorloge.Interval = 1000;   // en millisecondes
timerHorloge.Tick += (sender, e) => lblHeure.Text = DateTime.Now.ToString("HH:mm:ss");
timerHorloge.Start();

Créer ses propres événements

Les contrôles ne sont pas les seuls à déclencher des événements : tes classes peuvent en publier. Une fenêtre non modale qui doit prévenir la fenêtre principale qu'un patient a été enregistré peut déclarer un événement, que la fenêtre principale écoute :

public partial class FrmPatientEdition : Form
{
    public event EventHandler<Patient>? PatientEnregistre;

    private void Signaler(Patient patient)
    {
        PatientEnregistre?.Invoke(this, patient);   // ?. : seulement si quelqu'un écoute
    }
}

// dans FrmPatients
var fiche = new FrmPatientEdition();
fiche.PatientEnregistre += async (sender, patient) => await ChargerAsync();
fiche.Show(this);

C'est le même mécanisme que Click : event déclare le signal, += s'y abonne, Invoke le déclenche.

Les erreurs classiques

Le gestionnaire orphelin. Tu supprimes la méthode button1_Click dans FrmPatients.cs parce qu'elle ne sert plus. La compilation échoue avec l'erreur CS1061 : « 'FrmPatients' ne contient pas de définition pour 'button1_Click' ». La ligne d'abonnement est restée dans FrmPatients.Designer.cs. Double-clique sur l'erreur : Visual Studio ouvre le fichier sur la ligne button1.Click += button1_Click;, que tu peux supprimer. Pour éviter le problème, retire d'abord l'abonnement dans la liste des événements (éclair) de la fenêtre Propriétés, puis la méthode.

L'événement déclenché trop tôt. Remplir une ComboBox par DataSource, ou cocher une case par le code, déclenche SelectedIndexChanged ou CheckedChanged comme si l'utilisateur l'avait fait. Si ton gestionnaire recharge des données, il s'exécute pendant l'initialisation, parfois sur des données incomplètes. Deux parades : abonner le gestionnaire après le remplissage, ou poser un indicateur.

private bool _chargement;

private async void FrmOrdonnance_Load(object? sender, EventArgs e)
{
    _chargement = true;
    cboMedecin.DataSource = await _medecinService.ListerAsync();
    _chargement = false;
}

private void cboMedecin_SelectedIndexChanged(object? sender, EventArgs e)
{
    if (_chargement) return;
    // réagir au choix de l'utilisateur
}

Le gestionnaire jamais appelé. Tu as écrit btnSupprimer_Click, mais rien ne se passe au clic. La méthode existe, mais personne ne l'a abonnée : vérifie l'éclair de la fenêtre Propriétés, ou cherche btnSupprimer.Click += dans le Designer. Un point d'arrêt dans la méthode le confirme : il n'est jamais atteint.

Le gestionnaire appelé deux fois. À l'inverse, abonner la même méthode dans le concepteur et dans le constructeur l'exécute deux fois par clic : deux enregistrements, deux messages.

Exercices

private void txtObservation_TextChanged(object? sender, EventArgs e)
{
    lblCompteur.Text = $"{txtObservation.TextLength} / {txtObservation.MaxLength}";
}

public FrmOrdonnance(List<Medecin> medecins)
{
    InitializeComponent();
    cboMedecin.SelectedIndexChanged += cboMedecin_SelectedIndexChanged;
    cboMedecin.DataSource = medecins;
    cboMedecin.DisplayMember = nameof(Medecin.NomComplet);
}

private void cboMedecin_SelectedIndexChanged(object? sender, EventArgs e)
{
    Medecin medecin = (Medecin)cboMedecin.SelectedItem;
    Text = "Ordonnance – " + medecin.NomComplet;
}

public FrmOrdonnance(List<Medecin> medecins)
{
    InitializeComponent();
    cboMedecin.DisplayMember = nameof(Medecin.NomComplet);
    cboMedecin.DataSource = medecins;
    cboMedecin.SelectedIndexChanged += cboMedecin_SelectedIndexChanged;   // après le remplissage
}

private void cboMedecin_SelectedIndexChanged(object? sender, EventArgs e)
{
    if (cboMedecin.SelectedItem is Medecin medecin)
    {
        Text = "Ordonnance – " + medecin.NomComplet;
    }
}

private void FrmPatients_KeyDown(object? sender, KeyEventArgs e)
{
    if (e.Control && e.KeyCode == Keys.F)
    {
        txtRecherche.Focus();
        e.SuppressKeyPress = true;   // la touche n'est pas transmise au contrôle actif
    }
}