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.
O elemento é dado a conhecer ao XAML através deste 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}";
Importante
O campo não será inicializado até que o InitializeComponent método da página seja executado. Esse método faz parte do processo de análise e instanciação de objeto XAML. Coloque qualquer código que interaja com um elemento definido em XAML após esta chamada. A exceção a esta regra é a ContentPage própria classe. Você pode acessar todas as propriedades na classe, antes de executar o InitializeComponent método. No entanto, se você definir quaisquer propriedades nessa classe em XAML, esses valores de propriedade substituirão quaisquer valores que você possa ter definido antes de executar InitializeComponent.
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 controle pode responder a , e Released eventos, Pressedenquanto um EntryButton controle tem eventos como TextChanged.Clicked 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
objectreferência que indica o objeto que disparou o evento (conhecido como remetente) e umEventArgsparâ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
asyncse 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; Ativado 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 mostrará como 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)
{
...
}
}
Nota
Você pode usar essa abordagem para se inscrever em vários métodos de manipulação de eventos para o mesmo evento. Cada método de manipulação de eventos é executado quando o evento ocorre, embora você não deva presumir que eles serão executados em qualquer ordem específica, portanto, não introduza dependências entre eles.
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;