Tratamento de eventos no XAML

Depois de criar uma interface do usuário XAML, você pode adicionar código para responder às interações que ocorrem quando o usuário visita a página. O .NET MAUI notifica o aplicativo das entradas e interações do usuário por meio de eventos .NET padrão.

Nesta unidade, você aprenderá como lidar com esses eventos e realizar as operações esperadas pelo usuário.

Nomenclatura dos elementos em uma página XAML

O código de manipulação de eventos muitas vezes precisa se referir a controles específicos e suas propriedades em uma página. Você pode atribuir um nome exclusivo a cada controle. Para fazer isso, use o atributo XAML x:Name. O atributo x:Name executa duas ações:

• Adiciona um campo privado ao arquivo code-behind gerado que é mapeado para esse elemento. Use esse campo no seu código para interagir com o elemento visual, definir as propriedades de runtime e manipular eventos.

• Isso torna o elemento conhecido para o XAML por meio desse nome. Você pode consultar esses elementos a partir de outros elementos definidos no mesmo arquivo XAML.

Não é possível usar nenhuma cadeia de caracteres arbitrária ao nomear o elemento. O valor atribuído ao atributo x:Name é usado para criar um campo no código. Em vez disso, ele deve estar em conformidade com as convenções de nomenclatura para uma variável. O nome também deve ser exclusivo, pois é compilado na definição code-behind.

Depois de fornecer um nome para um elemento, você pode interagir com esse elemento no arquivo code-behind. O fragmento XAML a seguir define um controle Label. Ele se chama CounterLabel (este exemplo é obtido do aplicativo padrão gerado pelo modelo MAUI do .NET):

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

No code-behind dessa página, você pode mencionar esse controle por meio do campo CounterLabel e modificar suas propriedades:

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

Usar um atributo para conectar eventos

Muitos controles expõem propriedades que correspondem aos eventos aos quais esses controles podem responder, como o evento Clicked de um botão. Controles diferentes dão suporte a conjuntos de eventos variados. Por exemplo, um controle Button pode responder a eventos Clicked, Pressed e Released, enquanto um controle Entry tem eventos como TextChanged. Você pode inicializar uma propriedade de evento na marcação XAML de uma página e especificar o nome do método a ser executado quando o evento for disparado. O método de evento precisa atender aos seguintes requisitos de assinatura:

• Ele não pode retornar um valor; o método deve ser void.
• Ele deve ter dois parâmetros; uma object referência que indica o objeto que disparou o evento (conhecido como remetente) e um EventArgs parâmetro que contém quaisquer argumentos passados para o manipulador de eventos pelo remetente.
• O manipulador de eventos deve ser private. Isso não é implementado, mas se você tornar um manipulador de eventos público, ele ficará acessível para o mundo exterior e uma ação que não seja o evento esperado sendo disparado poderá invocá-lo.
• O manipulador de eventos poderá ser async se precisar executar operações assíncronas.

O exemplo a seguir mostra a definição do manipulador de eventos Clicked para o botão na amostra de aplicativo do modelo do .NET MAUI. O nome do método segue uma convenção padrão: On, seguido pelo nome do controle (o botão se chama Contador) e pelo nome do evento (Clicado). Essa convenção não é imposta, mas é uma boa prática:

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

Separação de interesses

Conectar eventos no XAML é conveniente, mas mistura o comportamento do controle com a definição da interface do usuário. Muitos desenvolvedores preferem manter esses elementos distintos e fazer todas as assinaturas do manipulador de eventos no code-behind para elementos nomeados. Esse método torna mais fácil ver o que está conectado e para onde o comportamento está sendo mapeado. Também torna mais difícil quebrar o código acidentalmente removendo um manipulador no XAML sem perceber. O compilador não detectará um manipulador removido, e isso só se tornará um problema quando o código não executar esse comportamento corretamente.

A opção por conectar manipuladores de eventos usando o XAML ou usando código é uma questão de preferência pessoal.

Para conectar um manipulador de eventos no código, use o operador += para assinar o evento. Normalmente, você executa essa operação no construtor da página, após a chamada para InitializeComponent:

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

    ...

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

Da mesma forma, você pode remover um manipulador de eventos cancelando a respectiva assinatura no evento com o operador -= mais à frente no seu aplicativo:

Counter.Clicked -= OnCounterClicked;