Tratamento de eventos em XAML

Depois de criar sua 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 de entrada 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.

Nomeando elementos em uma página XAML

O código de manipulação de eventos freqüentemente 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 x:NameXAML . O x:Name atributo faz duas coisas:

• Ele adiciona um campo privado ao arquivo code-behind gerado que é mapeado para esse elemento. Use este campo em seu código para interagir com o elemento visual para definir propriedades de tempo de execução e manipular eventos.

• Ele torna o elemento conhecido para XAML por meio desse nome. Você pode fazer referência a esses elementos 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 x:Name atributo é 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, porque é 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 Label controle. Ele é chamado CounterLabel (este exemplo é retirado do aplicativo padrão gerado pelo modelo .NET MAUI):

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

No code-behind desta página, você pode fazer referência a esse controle através do CounterLabel campo 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 Clicked evento de um botão. Controles diferentes suportam conjuntos variados de eventos. Por exemplo, um Button controle pode responder a Clicked, Pressede Released eventos, enquanto um Entry controle 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 acionado. O método de evento deve atender aos seguintes requisitos de assinatura:

• Ele não pode retornar um valor; o método deve ser void.
• 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 é imposto, mas se você tornar público um manipulador de eventos, ele se tornará acessível para o mundo exterior, e uma ação diferente do evento esperado que está sendo acionado poderá invocá-lo.
• O manipulador de eventos pode ser async se precisar executar operações assíncronas.

O exemplo a seguir mostra a definição do manipulador de Clicked eventos para o botão no aplicativo de exemplo do modelo .NET MAUI. O nome do método segue uma convenção padrão; Em seguido pelo nome do controle (o botão é chamado Contador) e o nome do evento (Clicado). Esta convenção não é aplicada, mas é uma boa prática:

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

Separação de preocupações

Conectar eventos em XAML é conveniente, mas mistura o comportamento de 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. É mais fácil ver o que está ligado e onde o comportamento está mapeado. Esse método também torna mais difícil quebrar acidentalmente o código removendo um manipulador no XAML sem perceber. O compilador não pegará um manipulador removido e só se tornará um problema quando o código não executar esse comportamento corretamente.

Se você optar por conectar manipuladores de eventos usando XAML ou usando código, é uma questão de escolha pessoal.

Para conectar um manipulador de eventos no código, use o += operador para se inscrever no 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 assinatura dele do evento com o -= operador posteriormente em seu aplicativo:

Counter.Clicked -= OnCounterClicked;