La finestre di dialogo comuni in VB .NET

Le finestre di dialogo comuni sono quelle finestre che, come dice il nome stesso, sono standard in tutte le applicazioni per Windows. Provate ad esempio ad avviare Blocco note e a selezionare i comandi Apri e Salva con nome del menu File: quelle che appariranno sono due delle finestre di dialogo comuni offerte da Windows; le altre sono le finestreStampaColore e Carattere. Visual Basic ha sempre offerto degli stramenti per utilizzare tali finestre nelle proprie applicazioni: fino alle versione 6 essi erano contenute in un controllo OCX aggiuntivo, che quindi doveva essere distribuito insieme ad ogni programma che ne faceva uso, mentre in VB .NET le finestre di dialogo comuni fanno parte del corredo di controlli standard e sono OpenFileDialog, SaveFileDialog, fontdialog, ColorDialog e Printdialog. In questo corso ci occuperemo delle finestre di dialogo per la gestione dei file.
I controlli OpenFileDialog e SaveFileDialog sono molto simili; cominceremo quindi ad analizzare le proprietà comuni. La proprietà più importante è Filter, che consente di stabilire quali tipi di file verranno visualizzati nella finestra di dialogo (in pratica va a modificare la ComboBox Tipo file nelle finestre Apri e Salva con nome). La sua sintassi è la seguente:

Descrizione tipo file|Tipo file|Descrizione tipo
file|Tipo file|…|…
Ad esempio:

File di testo|*.txt|Tutti i file|*.*

La proprietà Filter è formata da coppie in cui il primo elemento è la descrizione del tipo di file, mentre la seconda è il filtro corrispondente. E’ possibile specificare più filtri corrispondenti ad una stessa descrizione; in questo caso devono essere separati da un punto e virgola, senza spazi:

File immagine|*.bmp;*.jpg;*.gif|Tutti i file|*.*

Il carattere | (pipe) è usato per separare sia le varie coppie, sia la descrizione dal filtro in una stessa coppia. Quando si specificano più filtri per una finestra di dialogo, la proprietà FilterIndex consente di specificare il filtro predefinito. Le proprietà CheckFileExists e CheckPathExists, se impostate su true, visualizzano un messaggio di errore se, rispettivamente, il file o il percorso selezionato nella finestra non esiste; tali proprietà sono utili, ad esempio, quando si vuole aprire un file. InitialDirectory imposta la cartella che deve essere visualizzata quando si apre la finestra di dialogo.

Il controllo SaveFileDialog ha una proprietà molto importante: OverwritePrompt, che, se impostata su true, visualizza un messaggio di conferma qualora l’utente specifichi il nome di un file esistente per il salvataggio. Per visualizzare la finestra di dialogo è necessario richiamare il metodo ShowDialog. Tale metodo è disponibile in tutti i controlli comuni. Esso restituisce un valore che può essere utilizzato per sapere se l’utente ha effettivamente selezionato un file oppure ha premuto il pulsante Annulla, quindi ha interrotto l’operazione. Si consideri ad esempio il codice seguente:

If OpenFileDialog1.ShowDialog = DialogResult.OK Then
MsgBox(“File selezionato ” & OpenFileDialog1.FileName)
Else
MsgBox(“L’utente ha annullato la selezione.”)
End If

Se il valore restituito dal metodo ShowDialog è uguale a DialogResult.OK, significa che l’utente ha selezionato un file e premuto il pulsante OK: in questo caso la proprietà FileName del controllo contiene il nome del file, che viene mostrato in una MessageBox. Se, invece, l’utente ha premuto Annulla, ShowDialog varrà DialogResult.Cancel.

E’ da notare che i controlli OpenFileDialog e SaveFileDialog si limitano a fornire un’interfaccia comune per selezionare il file da aprire o salvare; le operazioni di apertura e salvataggio vere e proprie dovranno essere poi realizzate dal programmatore.

Ora abbiamo tutte le conoscenze teoriche per riprendere l’esempio della Lezione precedente ed estenderlo aggiungendo le funzionalità di gestione dei file. Innanzi tutto inseriamo i due controlli OpenFileDialog e SaveFileDialog nella form: essi si posizioneranno nella parte bassa della finestra di progettazione, andando ad affiancarsi agli oggetti che rappresentano i menu ed il tooltip.
Impostiamo anche i nomi dei controlli, rispettivamente dlgApri e dlgSalva. Nella seguente tabella sono elencate le proprietà da modificare:

Nome controllo (tipo) Proprietà Valore
dlgApri (OpenFileDialog) Filter File di testo (*.txt)|*.txt|Tutti i file (*.*)|*.*
dlgSalva (SaveFileDialog) FileName <vuoto>
Filter File di testo (*.txt)|*.txt|Tutti i file (*.*)|*.*

Riprendiamo la routine che gestisce i comandi del menu File e aggiungiamo il codice relativo ai comandi Apri e Salva. Abbiamo detto che per visualizzare la finestra di dialogo è necessario richiamare il metodo ShowDialog, quindi controllare il valore da esso restituito per sapere se l’utente ha effettivamente selezionato un file. Stando così le cose, basta aggiungere il codice seguente al Select Case che gestisce i comandi del menu File:

Case “&Apri…”
If dlgApri.ShowDialog = DialogResult.OK Then
ApriFile(dlgApri.FileName)
End If
Case “&Salva…”
If dlgSalva.ShowDialog = DialogResult.OK Then
SalvaFile(dlgSalva.FileName)
End If

Come si può vedere, aggiungere una finestra di dialogo comune alla propria applicazione è estremamente semplice. Se l’utente seleziona un file per l’apertura (cioè se il metodoShowDialog di dlgApri restituisce DialogResult.OK), viene richiamata la routine ApriFile (che dobbiamo ancora scrivere), la quale si occupa di aprire effettivamente il file e visualizzarne il contenuto nella casella di testo. Analogamente, se si seleziona un file per il salvataggio le operazioni necessarie verranno effettuate da SalvaFile.
Passiamo alla routine che si occupa di aprire un file. Allo scopo utilizziamo un oggetto del namespace System.IO, più precisamente lo StreamReader che, come dice il nome stesso, legge un flusso di dati dalla sorgente specificata. La routine ApriFile risulta dunque:

Private Sub ApriFile(ByVal NomeFile As String)
Dim Testo As String
Dim FileReader As New System.IO.StreamReader(NomeFile)
‘Legge l’intero file e lo salva nella variabile “Testo”.
Testo = FileReader.ReadToEnd
FileReader.Close()
‘Libera le risorse allocate con New.
FileReader = Nothing
txtTesto.Text = Testo
End Sub

L’oggetto StreamReader ha un costruttore polimorfico che, nella sua versione più semplice (quella da noi utilizzata), prende come argomento il nome del file che si vuole leggere. Dopo aver creato un oggetto di tipo StreamReader, richiamiamo il suo metodo ReadToEnd, che legge il contenuto del file dalla posizione corrente (in questo caso dall’inizio, poiché non abbiamo fatto altre operazioni sul file) sino alla fine. Al termine chiudiamo lo StreamReader richiamando il suo metodo Close.
L’ultima operazione svolta dalla routine è quella di visualizzare il testo letto all’interno della TextBox.
Anche per il salvataggio utilizziamo un oggetto del namespace System.IO, questa volta lo StreamWriter. Il codice della routine SalvaFile è semplicissimo:

Private Sub SalvaFile(ByVal NomeFile As String)
Dim FileWriter As New System.IO.StreamWriter(NomeFile)
‘Salva il contenuto di “txtTesto” nel file.
FileWriter.Write(txtTesto.Text)
FileWriter.Close()
‘Libera le risorse allocate con New.
FileWriter = Nothing
End Sub

Se avete capito il funzionamento di StreamReader, il funzionamento di StreamWriter dovrebbe essere altrettanto chiaro.

A questo punto l’applicazione è quasi terminata. Manca però ancora una cosa: la gestione degli errori; infatti, non abbiamo previsto i casi in cui l’apertura o il salvataggio di un file non vada a buon fine. La gestione degli errori in VB .NET sarà l’argomento della prossima Lezione.

Both comments and pings are currently closed.

Comments are closed.