Gestion des événements dans le XAML

Après avoir créé votre interface utilisateur XAML, vous pouvez ajouter du code pour répondre aux interactions qui se produisent lorsque l’utilisateur visite la page. .NET MAUI avertit l’application d’entrées utilisateur et d’interactions par le biais d’événements .NET standard.

Dans cette unité, vous apprendrez à gérer ces événements et à effectuer les opérations attendues par l'utilisateur(-trice).

Nommer des éléments dans une page XAML

Le code de gestion des événements doit fréquemment faire référence à des contrôles spécifiques et à leurs propriétés sur une page. Vous pouvez attribuer un nom unique à chaque contrôle. Pour ce faire, utilisez l’attribut XAML x:Name. L’attribut x:Name effectue deux opérations :

• Il ajoute un champ privé au fichier code-behind généré mappé à cet élément. Utilisez ce champ dans votre code pour interagir avec l’élément visuel pour définir les propriétés d’exécution et gérer les événements.

• Ce nom permet à XAML de connaître l'élément. Vous pouvez référencer ces éléments à partir d’autres éléments définis dans le même fichier XAML.

Vous ne pouvez pas utiliser n’importe quelle chaîne lorsque vous nommez l’élément. La valeur affectée à l’attribut x:Name est utilisée pour créer un champ dans le code. Cependant, elle doit être conforme aux conventions de nommage d’une variable. Le nom doit également être unique, car il est compilé dans la définition du code-behind.

Une fois que vous fournissez un nom à un élément, vous pouvez interagir avec cet élément dans le fichier code-behind. Le fragment XAML suivant définit un contrôle Label. Il est nommé CounterLabel (cet exemple est extrait de l’application par défaut générée par le modèle MAUI .NET) :

    <Label Text="Current count: 0"
        ...
        x:Name="CounterLabel"
        ... />

Dans le code-behind de cette page, vous pouvez référencer ce contrôle via le champ CounterLabel et modifier ses propriétés :

count++;
CounterLabel.Text = $"Current count: {count}";

Utiliser un attribut pour relier les événements

De nombreux contrôles exposent des propriétés qui correspondent aux événements auxquels ces contrôles peuvent répondre, tels que l’événement Clicked pour un bouton. Différents contrôles prennent en charge divers ensembles d’événements. Par exemple, un contrôle Button peut répondre à des événements Clicked, Pressed et Released, tandis qu’un contrôle Entry a des événements tels que TextChanged. Vous pouvez initialiser une propriété d’événement dans le balisage XAML d’une page et spécifier le nom de la méthode à exécuter lorsque l’événement est déclenché. La méthode d’événement doit répondre aux exigences de signature suivantes :

• Elle ne peut pas retourner de valeur. Elle doit être void.
• Elle doit prendre deux paramètres : une référence object indiquant l’objet qui a déclenché l’événement (appelé expéditeur) et un paramètre EventArgs contenant tous les arguments passés au gestionnaire d’événements par l’expéditeur.
• Le gestionnaire d’événements devrait être private. Cela n’est pas appliqué, mais si vous rendez un gestionnaire d’événements public, il devient accessible au monde extérieur, et une action autre que l’événement attendu déclenché peut l’appeler.
• Le gestionnaire d’événements peut être async s’il a besoin d’exécuter des opérations asynchrones.

L’exemple suivant montre la définition du gestionnaire d’événements Clicked pour le bouton dans l’exemple d’application à partir du modèle MAUI .NET. Le nom de la méthode suit une convention standard ; On suivi du nom du contrôle (le bouton est nommé Counter), et le nom de l’événement (Clicked). Cette convention n’est pas appliquée, mais constitue une bonne pratique :

private void OnCounterClicked(object sender, EventArgs e)
{
    ...
}

Séparation des responsabilités

Le câblage d’événements en XAML est pratique, mais il combine le comportement du contrôle avec la définition de l’interface utilisateur. De nombreux développeurs préfèrent conserver ces éléments distincts et effectuer tous les abonnements de gestionnaire d’événements dans le code-behind pour les éléments nommés. Il est plus facile de voir ce qui est branché et où le comportement est mappé. Cette méthode rend également plus difficile de briser accidentellement le code en supprimant un gestionnaire dans le code XAML sans le réaliser. Le compilateur ne détectera pas un gestionnaire supprimé, et le problème ne se posera que lorsque le code n'exécutera pas ce comportement correctement.

Il vous appartient de choisir de relier les gestionnaires d’événements à l’aide du langage XAML ou de code.

Pour relier un gestionnaire d’événements dans le code, utilisez l’opérateur += pour vous abonner à l’événement. Vous effectuez généralement cette opération dans le constructeur de la page, après l’appel à InitializeComponent :

public partial class MainPage : ContentPage, IPage
{
    public MainPage()
    {
        InitializeComponent();
        Counter.Clicked += OnCounterClicked;
    }

    ...

    private void OnCounterClicked(object sender, EventArgs e)
    {
        ...
    }
}

De même, vous pouvez supprimer un gestionnaire d’événements en le désabonnant de l’événement avec l’opérateur -=, plus loin dans votre application :

Counter.Clicked -= OnCounterClicked;