Gestione degli eventi in XAML
Dopo aver creato l'interfaccia utente XAML, è possibile aggiungere codice per rispondere alle interazioni che si verificano quando l'utente visita la pagina. .NET MAUI comunica all'applicazione l'input dell'utente e le interazioni tramite eventi .NET standard.
In questa unità si apprenderà come gestire questi eventi ed eseguire le operazioni previste dall'utente.
Denominazione degli elementi in una pagina XAML
Il codice di gestione degli eventi deve spesso fare riferimento a controlli specifici e alle relative proprietà in una pagina. È possibile assegnare un nome univoco a ogni controllo. A tale scopo, usare l'attributo XAML x:Name. L'attributo x:Name consente di ottenere due risultati:
Viene aggiunto un campo privato al file code-behind generato che è associato all'elemento. Usare questo campo nel codice per interagire con l'elemento visivo in modo da impostare le proprietà di runtime e gestire gli eventi.
Ciò rende noto l'elemento a XAML tramite questo nome. È possibile fare riferimento a questi elementi da altri elementi definiti nello stesso file XAML.
Quando si assegna un nome all'elemento, non è possibile usare una stringa arbitraria qualsiasi. Il valore assegnato all'attributo x:Name viene usato per creare un campo nel codice. Il nome deve essere conforme alle convenzioni di denominazione usate per una variabile. Inoltre il nome deve essere univoco perché viene compilato nella definizione del code-behind.
Dopo aver specificato un nome per un elemento, è possibile interagire con tale elemento nel file code-behind. Il frammento XAML seguente definisce un controllo Label. Il controllo si chiama CounterLabel. Questo esempio è tratto dall'app predefinita generata dal modello .NET MAUI:
<Label Text="Current count: 0"
...
x:Name="CounterLabel"
... />
Nel code-behind di questa pagina è possibile fare riferimento a questo controllo tramite il campo CounterLabel e modificarne le proprietà:
count++;
CounterLabel.Text = $"Current count: {count}";
Importante
Il campo non verrà inizializzato finché non verrà eseguito il metodo InitializeComponent della pagina. Questo metodo fa parte dell'analisi XAML e del processo di creazione delle istanze degli oggetti. Inserire qualsiasi elemento di codice che interagisca con un elemento definito in XAML dopo questa chiamata. L'eccezione a questa regola è costituita dalla classe ContentPage stessa. È possibile accedere a tutte le proprietà sulla classe, prima dell'esecuzione del metodo InitializeComponent. Se tuttavia si impostano proprietà su questa classe in XAML, i valori delle proprietà impostati sovrascriveranno gli eventuali valori impostati prima dell'esecuzione di InitializeComponent.
Usare un attributo per collegare gli eventi
Molti controlli espongono proprietà che corrispondono agli eventi a cui questi controlli possono rispondere, ad esempio l'evento Clicked per un pulsante. Controlli diversi supportano set di eventi diversi. Ad esempio, un controllo Button può rispondere agli eventi Clicked, Pressed e Released, mentre un controllo Entry ha eventi come TextChanged. È possibile inizializzare la proprietà di un evento nel markup XAML di una pagina e specificare il nome del metodo da eseguire quando viene attivato l'evento. Il metodo dell'evento deve soddisfare i requisiti di firma seguenti:
- Non può restituire un valore. Il metodo deve essere
void. - Deve accettare due parametri: un riferimento
objectche indica l'oggetto che ha generato l'evento (noto come mittente) e un parametroEventArgsche contiene gli argomenti passati al gestore eventi dal mittente. - Il gestore eventi dovrebbe essere
private. Questa impostazione non è obbligatoria, ma se un gestore eventi viene reso pubblico, diventerà accessibile al mondo esterno e potrebbe essere richiamato da un'azione diversa dall'evento previsto. - Il gestore eventi può essere
asyncse è necessario eseguire operazioni asincrone.
L'esempio seguente mostra la definizione del gestore eventi Clicked per il pulsante nell'app di esempio dal modello .NET MAUI. Il nome del metodo segue una convenzione standard: On seguito dal nome del controllo (il pulsante Counter) e dal nome dell'evento (Clicked). Questa convenzione non è obbligatoria, ma è buona norma seguirla:
private void OnCounterClicked(object sender, EventArgs e)
{
...
}
Separazione delle problematiche
Collegare gli eventi in XAML è comodo, ma combina il comportamento del controllo con la definizione dell'interfaccia utente. Molti sviluppatori preferiscono mantenere distinti questi due elementi ed eseguire tutte le sottoscrizioni dei gestori degli eventi nel code-behind per gli elementi denominati. In questo modo è più facile vedere quali elementi sono collegati e a quali elementi è associato il comportamento. Inoltre, con questo metodo si corre meno il rischio di interrompere accidentalmente il codice rimuovendo un gestore XAML senza rendersene conto. Il compilatore non intercetta un gestore rimosso e ciò diventa un problema solo quando il codice non esegue correttamente tale comportamento.
La scelta di collegare gestori eventi tramite XAML o tramite codice è una questione di scelta personale.
Per collegare un gestore eventi nel codice, usare l'operatore += per sottoscrivere l'evento. In genere si esegue questa operazione nel costruttore relativo alla pagina, dopo la chiamata a InitializeComponent:
public partial class MainPage : ContentPage, IPage
{
public MainPage()
{
InitializeComponent();
Counter.Clicked += OnCounterClicked;
}
...
private void OnCounterClicked(object sender, EventArgs e)
{
...
}
}
Nota
È possibile adottare questo approccio per sottoscrivere più metodi di gestione degli eventi per lo stesso evento. Ogni metodo viene eseguito quando si verifica l'evento, anche se non si deve presupporre che gli eventi vengano eseguiti in un ordine particolare. È pertanto opportuno non introdurre dipendenze tra di essi.
Analogamente, è possibile rimuovere un gestore eventi annullando la sottoscrizione dall'evento con l'operatore -= in un secondo momento nell'applicazione:
Counter.Clicked -= OnCounterClicked;