Cenni preliminari sulle finestre di dialogo
Comprimi il sommario
Espandi il sommario
Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Cenni preliminari sulle finestre di dialogo

 

Pubblicato: giugno 2016

Nelle applicazioni autonome è in genere presente una finestra principale in cui vengono visualizzati i dati principali su cui si basa il funzionamento dell'applicazione e in cui vengono esposte le funzionalità di elaborazione dei dati stessi attraverso meccanismi dell'interfaccia utente quali barre dei menu, barre degli strumenti e barre di stato. In un'applicazione più complessa sono inoltre disponibili finestre aggiuntive per l'esecuzione delle operazioni riportate di seguito:

  • Visualizzazione di informazioni specifiche agli utenti.

  • Raccolta delle informazioni immesse dagli utenti.

  • Visualizzazione e raccolta di informazioni.

Questi tipi di finestre, noti come finestre di dialogo, si suddividono in due tipi: modali e non modali.

Una finestra di dialogo modale viene visualizzata da una funzione quando tale funzione, per continuare, deve ricevere ulteriori dati dall'utente. Poiché la raccolta dei dati da parte della funzione dipende dalla finestra di dialogo modale, finché quest'ultima rimane aperta l'utente non potrà attivare altre finestre. Nella maggior parte dei casi, una finestra di dialogo modale può essere chiusa dall'utente tramite la pressione di un pulsante OK o Annulla. Se preme il pulsante OK, l'utente ha immesso dei dati che desidera vengano elaborati dalla funzione. Se preme il pulsante Annulla, l'utente desidera arrestare l'esecuzione della funzione. Gli esempi più comuni di finestre di dialogo modali sono dati dalle finestre di apertura, salvataggio e stampa dei dati.

Una finestra di dialogo non modale non impedisce a un utente di attivare altre finestre mentre è aperta. Ad esempio, se un utente desidera cercare occorrenze di una determinata parola in un documento, dalla finestra principale verrà spesso aperta una finestra di dialogo in cui l'utente dovrà immettere la parola che desidera cercare. Poiché la ricerca di una parola non impedisce all'utente di modificare il documento, la finestra di dialogo non deve essere modale. In una finestra di dialogo non modale è senz'altro disponibile un pulsante Chiudi per la sua chiusura ed eventualmente ulteriori pulsanti per l'esecuzione di funzioni specifiche, ad esempio un pulsante Trova successivo per cercare la parola successiva corrispondente ai criteri della ricerca.

Windows Presentation Foundation (WPF) consente di creare molti tipi di finestre di dialogo, incluse finestre di messaggio, finestre di dialogo comuni e finestre di dialogo personalizzate. In questo argomento vengono illustrati i diversi tipi di finestre di dialogo e in Esempio di finestra di dialogo (la pagina potrebbe essere in inglese) sono disponibili alcuni esempi.

Una finestra di messaggio è una finestra di dialogo che può essere utilizzata per visualizzare informazioni di testo e consentire agli utenti di prendere decisioni con i pulsanti. Di seguito è illustrata una finestra di messaggio in cui vengono visualizzate informazioni di testo, viene posta una domanda e in cui sono disponibili tre pulsanti per fornire una risposta.

Finestra di dialogo Elaboratore di testo

Per creare una finestra di messaggio, si utilizza la classe MessageBox, che consente di configurare il testo, il titolo, l'icona e i pulsanti della finestra tramite codice simile a quello riportato di seguito.

// Configure the message box to be displayed
string messageBoxText = "Do you want to save changes?";
string caption = "Word Processor";
MessageBoxButton button = MessageBoxButton.YesNoCancel;
MessageBoxImage icon = MessageBoxImage.Warning;

Per visualizzare una finestra di messaggio, chiamare il metodo static Show, come illustrato nel codice riportato di seguito.

// Display message box
MessageBox.Show(messageBoxText, caption, button, icon);

Quando il codice per la visualizzazione di una finestra di messaggio deve rilevare ed elaborare la decisione dell'utente (quale pulsante è stato premuto), può analizzare il risultato della finestra di messaggio, come illustrato nel codice riportato di seguito.

// Display message box
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, button, icon);

// Process message box results
switch (result)
{
    case MessageBoxResult.Yes:
        // User pressed Yes button
        // ...
        break;
    case MessageBoxResult.No:
        // User pressed No button
        // ...
        break;
    case MessageBoxResult.Cancel:
        // User pressed Cancel button
        // ...
        break;
}

Per ulteriori informazioni sull'utilizzo delle finestre di messaggio, vedere MessageBox, Esempio di finestra di messaggio ed Esempio di finestra di dialogo (le pagine potrebbero essere in inglese).

Sebbene MessageBox semplifichi l'utilizzo delle finestre di dialogo da parte dell'utente, MessageBox è il solo tipo di finestra visualizzabile dalle applicazioni eseguite in un sandbox di sicurezza con attendibilità parziale (vedere Sicurezza (WPF)), ad esempio le XAML browser applications (XBAPs).

Nella maggior parte delle finestre di dialogo vengono visualizzati e raggruppati dati più complessi del risultato di una finestra di messaggio, ad esempio testo, selezione (caselle di controllo), selezione a esclusione reciproca (pulsanti di opzione) e selezione in elenchi (caselle di riepilogo, caselle combinate, elenchi a discesa). Per questo motivo, Windows Presentation Foundation (WPF) fornisce molte finestre di dialogo comuni e consente di crearne di personalizzate, sebbene l'utilizzo di entrambe sia limitato ad applicazioni eseguite con attendibilità totale.

In Windows è implementata una varietà di finestre di dialogo riutilizzabili comuni a tutte le applicazioni, incluse le finestre di dialogo per l'apertura, il salvataggio e la stampa di file. Poiché queste finestre di dialogo sono implementate dal sistema operativo, possono essere condivise da tutte le applicazioni eseguite nel sistema operativo, con notevoli vantaggi in termini della coerenza di utilizzo: se un utente utilizza con frequenza una finestra di dialogo basata sul sistema operativo in un'applicazione, non dovrà imparare a utilizzare la stessa finestra in altre applicazioni. Poiché queste finestre di dialogo sono disponibili in tutte le applicazioni e poiché consentono un'esperienza utente coerente, sono note come finestre di dialogo comuni.

Windows Presentation Foundation (WPF) incapsula le finestre di dialogo comuni di apertura, salvataggio e stampa di file e le espone come classi gestite da utilizzare in applicazioni autonome. In questo argomento vengono forniti alcuni cenni preliminari su ognuna.

La finestra di dialogo Apri illustrata di seguito viene utilizzata dalla funzionalità di apertura file per recuperare il nome di un file da aprire.

Finestra di dialogo Apri

La finestra di dialogo Apri comune viene implementata come classe OpenFileDialog e inserita nello spazio dei nomi Microsoft.Win32. Nel codice riportato di seguito viene illustrato come creare, configurare e visualizzare questa finestra di dialogo e come elaborare il relativo risultato.

// Configure open file dialog box
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".txt"; // Default file extension
dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

// Show open file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process open file dialog box results
if (result == true)
{
    // Open document
    string filename = dlg.FileName;
}

Per ulteriori informazioni sulla finestra di dialogo Apri, vedere Microsoft.Win32.OpenFileDialog.

System_CAPS_noteNota

OpenFileDialog può essere utilizzato per il recupero sicuro di nomi file da parte di applicazioni eseguite con attendibilità parziale (vedere Sicurezza (WPF)).

La finestra di dialogo Salva con nome illustrata di seguito viene utilizzata dalla funzionalità di salvataggio file per recuperare il nome di un file da salvare.

Finestra di dialogo Salva con nome

La finestra di dialogo Salva con nome comune viene implementata come classe SaveFileDialog e inserita nello spazio dei nomi Microsoft.Win32. Nel codice riportato di seguito viene illustrato come creare, configurare e visualizzare questa finestra di dialogo e come elaborare il relativo risultato.

// Configure save file dialog box
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".text"; // Default file extension
dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

// Show save file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process save file dialog box results
if (result == true)
{
    // Save document
    string filename = dlg.FileName;
}

Per ulteriori informazioni sulla finestra di dialogo Salva con nome, vedere Microsoft.Win32.SaveFileDialog.

La finestra di dialogo Stampa illustrata di seguito viene utilizzata dalla funzionalità di stampa per la scelta e la configurazione della stampante su cui stampare dati.

Finestra di dialogo Stampa

La finestra di dialogo Stampa comune viene implementata come classe PrintDialog e inserita nello spazio dei nomi System.Windows.Controls. Nel codice riportato di seguito viene illustrato come creare, configurare e visualizzare una finestra di dialogo di questo tipo.

// Configure printer dialog box
System.Windows.Controls.PrintDialog dlg = new System.Windows.Controls.PrintDialog();
dlg.PageRangeSelection = PageRangeSelection.AllPages;
dlg.UserPageRangeEnabled = true;

// Show save file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process save file dialog box results
if (result == true)
{
    // Print document
}

Per ulteriori informazioni sulla finestra di dialogo Stampa, vedere System.Windows.Controls.PrintDialog. Per informazioni dettagliate sulla stampa in WPF, vedere Cenni preliminari sulla stampa.

Sebbene le finestre di dialogo comuni siano utili e debbano essere utilizzate quando possibile, non supportano i requisiti delle finestre di dialogo specifiche di vari domini. In questi casi, è necessario creare finestre di dialogo personalizzate. Come verrà illustrato in seguito, una finestra di dialogo è una finestra con particolari comportamenti. Poiché l'oggetto Window implementa tali comportamenti, utilizzarlo per creare finestre di dialogo modali e non modali personalizzate.

In questo argomento viene illustrato come utilizzare l'oggetto Window per creare un'implementazione tipica di finestra di dialogo modale, utilizzando come esempio la finestra di dialogo Margins; vedere a questo proposito Esempio di finestra di dialogo (la pagina potrebbe essere in inglese). Di seguito viene illustrata la finestra di dialogo Margins.

Finestra di dialogo Margini

L'interfaccia utente di una finestra di dialogo tipica include gli elementi riportati di seguito:

  • I diversi controlli necessari per raccogliere i dati desiderati.

  • Pulsante OK su cui l'utente fa clic per chiudere la finestra di dialogo, tornare alla funzione e continuare l'elaborazione.

  • Pulsante Annulla su cui l'utente fa clic per chiudere la finestra di dialogo e interrompere l'elaborazione da parte della funzione.

  • Pulsante Chiudi nella barra del titolo.

  • Icona.

  • Pulsanti di riduzione a icona, ingrandimento e ripristino.

  • Menu di sistema per ridurre a icona, ingrandire, ripristinare e chiudere la finestra di dialogo.

  • Apertura sopra e al centro della finestra da cui è stata aperta la finestra di dialogo.

  • Poiché le finestre di dialogo devono essere, per quanto possibile, ridimensionabili, per impedire che diventino troppo piccole e per fornire utili dimensioni predefinite, è necessario impostare sia dimensioni minime sia dimensioni predefinite.

  • Il tasto ESC dovrebbe essere configurato come tasto di scelta rapida per la pressione del pulsante Annulla. Questo risultato si ottiene impostando la proprietà IsCancel del pulsante Annulla su true.

  • Il tasto INVIO dovrebbe essere configurato come tasto di scelta rapida per la pressione del pulsante OK. Questo risultato si ottiene impostando la proprietà IsDefault del pulsante OK su true.

Nel codice riportato di seguito viene illustrata questa configurazione.

L'esperienza utente relativa all'utilizzo di una finestra di dialogo si estende anche alla barra dei menu della finestra da cui viene aperta la finestra di dialogo. Quando una voce di menu attiva una funzione la cui elaborazione richiede interazione da parte dell'utente tramite una finestra di dialogo, nell'intestazione della voce di menu saranno visibili dei puntini di sospensione, come illustrato di seguito.

Quando una voce di menu attiva una funzione che comporta la visualizzazione di una finestra di dialogo che non richiede interazione da parte dell'utente, ad esempio una finestra di dialogo Informazioni su, i puntini di sospensione non sono necessari.

Una finestra di dialogo viene in genere visualizzata in seguito alla selezione, da parte dell'utente, di una voce di menu per l'esecuzione di una funzione specifica di un dominio, ad esempio l'impostazione dei margini di un documento in un elaboratore di testo. La visualizzazione di una finestra come una finestra di dialogo è simile alla visualizzazione di una normale finestra, sebbene richieda operazioni di configurazione specifiche. L'intero processo di creazione di un'istanza, di configurazione e di apertura di una finestra di dialogo viene illustrato nel codice riportato di seguito.

In questo punto del codice, le informazioni predefinite (i margini correnti) vengono passate alla finestra di dialogo. Viene inoltre impostata la proprietà Window.Owner con un riferimento alla finestra da cui viene visualizzata la finestra di dialogo. In generale, è sempre opportuno impostare il proprietario di una finestra di dialogo per fornire i comportamenti correlati allo stato della finestra comuni a tutte le finestre di dialogo. Per ulteriori informazioni, vedere Cenni preliminari sulle finestre WPF.

System_CAPS_noteNota

È necessario fornire un proprietario per supportare l'automazione dell'interfaccia utente per le finestre di dialogo. Vedere Cenni preliminari su automazione interfaccia utente.

Dopo essere stata configurata, la finestra di dialogo viene visualizzata come modale chiamando il metodo ShowDialog.

Quando viene aperta una finestra di dialogo e l'utente fornisce i dati necessari, la finestra di dialogo deve garantire che i dati forniti siano validi per i motivi riportati di seguito:

  • Da un punto di vista della sicurezza, tutti gli input devono essere convalidati.

  • Da un punto di vista specifico del dominio, la convalida dei dati impedisce l'elaborazione di dati errati da parte del codice, che potrebbe potenzialmente generare eccezioni.

  • Da un punto di vista dell'esperienza utente, una finestra di dialogo può aiutare l'utente mostrandogli quali dati immessi non sono validi.

  • Da un punto di vista delle prestazioni, la convalida dei dati in un'applicazione a più livelli può ridurre il numero di sequenze di andata e ritorno tra il client e i livelli dell'applicazione, in particolare se l'applicazione è composta da servizi Web o database basati su server.

Per convalidare un controllo associato in WPF, è necessario definire una regola di convalida e abbinarla all'associazione. Una regola di convalida è una classe personalizzata che deriva da ValidationRule. Nell'esempio riportato di seguito viene illustrata una regola di convalida, MarginValidationRule, che consente di controllare che un valore associato sia Double e compreso in un intervallo specificato.

In questo codice, la logica di convalida di una regola viene implementata eseguendo l'override del metodo Validate che convalida i dati e restituisce un oggetto ValidationResult appropriato.

Per abbinare la regola di convalida al controllo associato, utilizzare il markup riportato di seguito.

Dopo essere stata abbinata, la regola di convalida verrà automaticamente applicata da WPF nel momento in cui verranno immessi dati nel controllo associato. Se un controllo contiene dati non validi, in WPF verrà visualizzato un bordo rosso intorno al controllo non valido, come illustrato di seguito.

Margine sinistro non valido

In WPF l'utente non rimane bloccato sul controllo non valido finché non vengono immessi dati validi. In questo modo, sarà libero di spostarsi tra i controlli della finestra di dialogo anche se i dati immessi non sono validi. Ciò significa, tuttavia, che un utente può immettere dati non validi e premere il pulsante OK. Per questo motivo, il codice deve anche prevedere la convalida di tutti i controlli di una finestra di dialogo quando viene premuto il pulsante OK gestendo l'evento Click.

Nel codice vengono enumerati tutti gli oggetti dipendenza di una finestra e, se ne vengono rilevati di non validi (come restituito dal metodo GetHasError, il controllo non valido riceve lo stato attivo, il metodo IsValid restituisce falsee la finestra viene considerata non valida.

Dopo essere stata ritenuta valida, la finestra di dialogo può essere chiusa. Questo processo deve inoltre prevedere la restituzione di un risultato alla funzione chiamante.

L'apertura di una finestra di dialogo tramite il metodo ShowDialog è sostanzialmente equivalente alla chiamata a un metodo: il codice che ha aperto la finestra di dialogo tramite il metodo ShowDialog attende la restituzione di un risultato da parte del metodo ShowDialog. Quando il metodo ShowDialog restituisce un risultato, il codice che lo ha chiamato deve decidere se continuare o arrestare l'elaborazione, a seconda che sia stato premuto il pulsante OK o il pulsante Annulla. Per facilitare questa decisione, la finestra di dialogo deve restituire la scelta dell'utente come un valore Boolean restituito dal metodo ShowDialog.

Quando l'utente fa clic sul pulsante OK, il metodo ShowDialog deve restituire true. A tale scopo, impostare la proprietà DialogResult della finestra di dialogo quando viene fatto clic sul pulsante OK.

Si noti che l'impostazione della proprietà DialogResult comporta la chiusura automatica della finestra, in seguito alla quale non è più necessario chiamare in modo esplicito il metodo Close.

Quando viene fatto clic sul pulsante Annulla, il metodo ShowDialog dovrebbe restituire false, risultato che richiede l'impostazione della proprietà DialogResult.

Quando la proprietà IsCancel di un pulsante viene impostata su true e l'utente preme il pulsante Annulla o il tasto ESC, la proprietà DialogResult viene impostata automaticamente su false. Con il markup riportato di seguito si ottiene lo stesso effetto del codice precedente, senza la necessità di gestire l'evento Click.

Una finestra di dialogo restituisce automaticamente false quando l'utente preme il pulsante Chiudi nella barra del titolo o sceglie la voce di menu Chiudi dal menu di sistema.

Quando la proprietà DialogResult viene impostata da una finestra di dialogo, la funzione che ne ha comportato l'apertura può ottenere il risultato della finestra di dialogo controllando la proprietà DialogResult quando il metodo ShowDialog restituisce un risultato.

Se il risultato della finestra di dialogo è true, la funzione utilizza tale risultato con un'indicazione per recuperare ed elaborare i dati forniti dall'utente.

System_CAPS_noteNota

Dopo la restituzione di un risultato da parte del metodo ShowDialog, una finestra di dialogo non può più essere riaperta. È invece necessario creare una nuova istanza.

Se il risultato della finestra di dialogo è false, l'elaborazione della funzione viene terminata in modo appropriato.

Una finestra di dialogo non modale, ad esempio la finestra di dialogo Trova illustrata di seguito, presenta sostanzialmente lo stesso aspetto di una finestra di dialogo modale.

Finestra di dialogo Trova

Il comportamento è invece leggermente diverso, come descritto nelle sezioni riportate di seguito.

Una finestra di dialogo non modale viene aperta chiamando il metodo Show.

A differenza di ShowDialog, il metodo Show restituisce immediatamente un risultato. Di conseguenza, la finestra chiamante non può stabilire quando la finestra di dialogo non modale viene chiusa e pertanto non sa quando verificare il risultato della finestra di dialogo o quando ottenere dati dalla finestra di dialogo per continuare l'elaborazione. La finestra di dialogo deve quindi disporre di un modo alternativo per restituire dati alla finestra chiamante.

In questo esempio, la FindDialogBox potrebbe restituire uno o più risultati di ricerca alla finestra principale, a seconda del testo cercato senza una frequenza specifica. Analogamente a una finestra di dialogo modale, una finestra di dialogo non modale può restituire risultati utilizzando le proprietà. La finestra proprietaria della finestra di dialogo deve, tuttavia, sapere quando controllare tali proprietà. A tal fine, la finestra di dialogo dovrebbe implementare un evento che viene generato ogni volta che viene trovato il testo. FindDialogBox implementa a questo scopo TextFoundEvent, che innanzitutto richiede un delegato.

Tramite il delegato TextFoundEventHandler, la finestra di dialogo FindDialogBox implementa TextFoundEvent.

Di conseguenza, Find può generare l'evento quando viene trovato un risultato di ricerca.

La finestra proprietaria deve quindi effettuare la registrazione e gestire questo evento.

Poiché non è necessario impostare DialogResult, una finestra di dialogo non modale può essere chiusa utilizzando i meccanismi forniti dal sistema, tra cui:

  • Pulsante Chiudi nella barra del titolo.

  • La combinazione di tasti ALT + F4.

  • Voce Chiudi del menu di sistema.

In alternativa, è possibile chiamare il metodo Close quando viene fatto clic sul pulsante Chiudi.

Mostra:
© 2016 Microsoft