Press "Enter" to skip to content

Creare un’applicazione WPF per gestire Dati su un database SqlServer – parte 3 Apriamo MainWindow

Prima di scrivere il codice per aprire la MainWindow del nostro programma, torniamo un attimo nel codice di OnStartup per fare un paio di osservazioni, un paio di modifiche e soprattutto per implementare il metodo che acquisisce la connection string se questa non esiste, inoltre, vediamo come si testa l’uso dei Command Line Arguments.

 

List<stringcommandLineArguments = null;
if (e.Args != null && e.Args.Length > 0)
{
	commandLineArguments = new List<string>(e.Args);
}
 
bool existConfigArgument = commandLineArguments != null &&
	commandLineArguments.Any(x => x.ToLower() == "-config");

Esaminiamo questo pezzetto di codice che verifica l’esistenza dei parametri da linea di comando e li recepisce, inoltre verifica se è presente all’interno di tali comandi il comando -config che forza l’apertura della finestra di acquisizione della stringa di connessione.

e.Args è un’array di stringhe fornito dall’event handler di Startup, contiene i parametri passati da linea di comando all’applicazione. Ma come si fa a debuggare l’esistenza e la forma dei parametri? Molto semplice: Posizionatevi sul nodo di progetto WpfPubs e premete tasto destro, sul menu contestuale scegliete Properties.

Oppure dal Solution Explorer selezionate la cartella Properties posta sotto al progetto e fate doppio click.

Verrà aperta la finestra per la gestione dei parametri di progetto e dei parametri di configurazione dell’applicazione e del compilatore per il debug o per la release.

Questa è la finestra delle property dell’applicazione non l’abbiamo ancora vista e sviscerata, ma lo faremo molto presto, intanto, sulla lista presente a sinistra andremo a selezionare l’opzione Debug che ci permetterà di configurare il comportamento in Debug della nostra applicazione.

In questa parte delle property di progetto ci sono vari parametri che ci permettono di configurare il comportamento del Debugger, in questo caso, l’unico che ci interessa è il contenuto della Textbox Command Line Arguments, che ci permette di inserire i parametri da linea di comando da passare allo Startup dell’applicazione.

Proviamo ad inserirne alcune e vedere cosa succede se lanciamo l’applicazione e ci fermiamo sullo startup sul codice che le elabora.

Inseriamo un Breakpoint sulla riga 72 dell’App.xaml.cs nel codice dell’event handler di OnStartup in questo modo lanciando l’applicazione, il debugger si fermerà dopo il codice che legge i parametri di configurazione. Per guardare il contenuto della variabile commandLineArguments, basterà posizionarvi sopra il cursore, ma siccome non mi è possibile catturare i tooltip che li mostrano, utilizzo la seconda modalità per guardare le variabili. Premete Tasto destro con il cursore posizionato sul nome della variabile e sul menu contestuale, selezionate “Add Watch”.

Cliccando questa opzione, si apre la finestra di “Watch”.

Cliccando sulla freccetta a inizio riga si apre la lista del contenuto della collection.

E come vedete ci sono tutti i parametri che ho inserito per il test.

Eseguiamo anche l’istruzione successiva premendo il tasto F10.

 

Premiamo Add Watch anche sulla variabile existConfigArgument e possiamo notare che è true perché -config esiste nella lista degli argomenti.

A questo punto possiamo realizzare il metodo OpenConfigWindow per aprire la WIndow di richiesta della connection string.

private bool OpenConfigWindow()
{
	bool ret = false;
	try
	{
		ConfigWindow win = new ConfigWindow();
		win.Icon = BitmapFrame.Create(new Uri("pack://application:,,,/wpfpubs.ico"UriKind.RelativeOrAbsolute));
		win.Init(ConfigFullName);
		bool? getConfig = win.ShowDialog();
		if (getConfig.HasValue && getConfig.Value)
		{
			CnString = win.CnString;
			ret = true;
		}
	}
	catch (Exception)
	{
		//In caso di Exception evitiamo l'esplosione
		//Ma verrà chiuso il programma con messaggio di errore
		ret = false;
	}
	return ret;
}

Qui sopra il codice che apre la Window di configurazione della stringa di connessione e ne gestisce il risultato o le eventuali Exception. in questo metodo effettuiamo le seguenti operazioni:

  • Creiamo un istanza della Window di configurazione.
  • Assegnamo all’icona della window, l’icona personalizzata che ho creato per il programma, per evitare che venga usata l’icona standard di windows che in un programma serio non deve essere usata.
  • Eseguiamo il metodo Init passandogli il nome del file di configurazione (vedremo subito come lo abbiamo generato).
  • Eseguiamo come Modale (dialog) la window e in base al valore ritornato inizializziamo la Connection string e ritorniamo un OK o un Errore (True=OK False=Errore).
win.Icon = BitmapFrame.Create(new 
    Uri("pack://application:,,,/wpfpubs.ico"
        UriKind.RelativeOrAbsolute));

Per creare l’icona, utilizzando l’icona del programma che viene inglobata nell’eseguibile, utilizziamo un URI (Unique Resource Identifier) che viene costruito in modo standard. la dicitura:

pack://application:,,,/

E’ un metodo deciso da Microsoft quando ha progettato WPF che dice in lingua italiana:
L’icona si trova all’interno dell’applicazione sulla cartella Root del progetto.

public string ConfigFullName
{
	get
	{
		string directoryName = Path.Combine(
                  Environment.GetFolderPath(
		    Environment.SpecialFolder.CommonDocuments)
                  , CONFIGFOLDER);
		if (!Directory.Exists(directoryName))
		{
			Directory.CreateDirectory(directoryName);
		}
		return Path.Combine(directoryNameCONFIGFILE);
	}
}

Vediamo ora come compongo il nome del file di configurazione. Ho deciso di metterlo nella cartella Public Documents (Documenti Pubblici), .Net possiede una classe Helper per rilevare i dati principali di configurazione del progetto. La classe Environment contiene molte informazioni e ausili per varie operazioni legate al computer. In questo caso utilizzo il metodo GetFolderPath e l’enumerazione SpecialFolder, che permettono di accedere alle cartelle di sistema in modo indipendente dall’utente collegato e dalla configurazione della macchina. La chiamata che faccio, mi restituisce CommonDocuments che è il nome usato per identificare la cartella chiamata Public Documents o Documenti pubblici.

Al nome della cartella, aggiungo una sottocartella che ho arbitrariamente deciso e inserito in una costante chiamata CONFIGFOLDER ed è:

private const string CONFIGFOLDER = "WpfPubs";

Una volta composto il nome della cartella, utilizzo un altra classe Helper, la classe Directory che mi fornisce i metodi per verificare se esiste e se non fosse così, mi permette di generare la cartella.

A questo punto, utilizzo un ulteriore helper ovvero la classe Path che fornisce alcuni metodi per gestire i percorsi ed i nomi dei file che poi andiamo a leggere o scrivere su disco.

private const string CONFIGFILE = "WpfPubs.nscnf";

Alla fine ottengo il nome del mio file di configurazione, a cui ho assegnato una estensione arbitraria per renderlo mio.

Come potete vedere, il file verrà generato sotto la cartella da me decisa. 

Ora possiamo procedere ed aprire la finestra di configurazione per acquisire la stringa di connessione a database.

Possiamo vedere in azione la Window generata nello scorso articolo provando ad inserire la stringa di connessione a database.

Testando la connessione è tutto OK.

Pertanto adesso andiamo a creare il metodo per aprire la MainWindow.

private void OpenMainWindow()
{
	try
	{
		MainWindow win = new MainWindow();
		win.CnString = CnString;
		this.MainWindow = win;
		win.Show();
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message);
	}
}

Per aprire la window non faccio praticamente nulla, salvo inizializzare una property che ho predisposto appositamente con la Connection string in modo tale che la Main Window abbia il suo valore. In realtà vi farò vedere anche come leggere la property che abbiamo definito in App.xaml.cs che è visibile tramite uno dei dati di sistema forniti dalla classe Application.

A questo punto rientro sulle Property del progetto ed elimino i parametri da linea di comando che avevo inserito per i test.

A questo punto, togliendo il breakpoint, facciamo partire l’applicazione e otterremo la nostra MainWindow, che è ancora molto vuota ma almeno abbiamo una applicazione funzionante.

Ci fermiamo qui per ora, nella prossima puntata vedremo come usare la MainWindow per il nostro progetto primario visto che ora il progetto compila e funziona allego il codice sorgente, che contiene anche il backup del database Pubs creato con SqlServer 2012 pertanto compatibile con 2012 e le versioni successive.