Passa ai contenuti principali

Appunti di WPF – Sesta Puntata – Gestire l’applicazione

Un’applicazione WPF, in maniera analoga a quanto accade per un’applicazione Windows Forms, ha un ben determinato ciclo di vita.

Come già visto nei tutorial precedenti, in un progetto WPF troviamo un file denominato Application.xaml (e relativo code behind Application.xaml.vb). Questo file descrive la classe che incapsula il comportamento e le proprietà della nostra applicazione WPF.

In particolare in questo file xaml possono trovare posto quelle risorse che utilizzeremo all’interno dell’applicazione e nel file di code behind possiamo gestire quegli eventi caratteristici del ciclo di vita dell’applicazione.

Prima di analizzare in dettaglio quali sono gli eventi che abbiamo a disposizione nella nostra applicazione WPF, vediamo come è definito il codice XAML del file Application:

  1. <Application x:Class="Application"
  2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4.     StartupUri="MainWindow.xaml" >
  5.     <Application.Resources>
  6.         
  7.     </Application.Resources>
  8. </Application>

Possiamo vedere che :

· la nostra classe Application deriva dalla classe Application di WPF;

· è impostata la proprietà StartupUri con l’indicazione della finestra principale dell’applicazione;

· prevede una collezione di risorse (vuota nell’esempio riportato).

Vediamo, ora, cosa accade alla nostra classe Application nel momento in cui compiliamo. Se apriamo la cartella dei file obj del progetto WPF (visibile solo se abbiamo attivato l’opzione di visualizzazione di tutti i file di progetto), possiamo osservare la presenza di un file particolare denominato Application.g.vb.

WPF_06_Application_Fig1

Questo file è generato dall’ambiente di sviluppo e, in buona sostanza riporta il seguente codice:

  1. '''<summary>
  2. '''Application
  3. '''</summary>
  4. <System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")>  _
  5. Partial Public Class Application
  6.     Inherits System.Windows.Application
  7.     
  8.     '''<summary>
  9.     '''InitializeComponent
  10.     '''</summary>
  11.     <System.Diagnostics.DebuggerNonUserCodeAttribute()>  _
  12.     Public Sub InitializeComponent()
  13.         
  14.         #ExternalSource("..\..\..\Application.xaml",4)
  15.         Me.StartupUri = New System.Uri("MainWindow.xaml", System.UriKind.Relative)
  16.         
  17.         #End ExternalSource
  18.     End Sub
  19.     
  20.     '''<summary>
  21.     '''Application Entry Point.
  22.     '''</summary>
  23.     <System.STAThreadAttribute(),  _
  24.      System.Diagnostics.DebuggerNonUserCodeAttribute()>  _
  25.     Public Shared Sub Main()
  26.         Dim app As Application = New Application()
  27.         app.InitializeComponent
  28.         app.Run
  29.     End Sub
  30. End Class

Di fatto, questo codice fornisce l’entry point di avvio dell’applicazione (metodo statico Main) e il metodo nel quale si definisce quale è la finestra iniziale (InitializeComponent).

Inoltre possiamo osservare che la classe definita è di tipo parziale, infatti verrà fusa con la classe definita nel code behind Application.xaml.vb.

L’immagine seguente ci mostra quali sono i possibili eventi che possiamo gestire nella classe Application:

WPF_06_Application_Fig2

Tralasceremo, in questo contesto tutti gli eventi di navigazione (tipo Navigated, Navigating, etc., etc.) e ci concentreremo sui rimanenti, decisamente più interessanti in questa fase di apprendimento dell’infrastruttura applicativa:

· Activated : invocato quando una delle finestre dell’applicazione viene attivata, ad esempio se ci spostiamo da un’altra applicazione nella nostra;

· Deactivated : invocato quando, ad esempio, ci spostiamo su di un’altra applicazione facendo perdere il “focus” alla nostra;

· DisptacherUnhandledException : invocato quando una eccezione occorsa all’interno dell’applicazione non viene gestita. Utile per collezionare i dati delle eccezioni e, soprattutto, per non far terminare l’applicazione in maniera poco pulita;

· Exit : invocato nel momento in cui si chiude l’applicazione. Non è possibile, in questo evento annullare la chiusura dell’applicazione stessa ma possiamo scrivere il metodo Main per rilanciare (tramite il metodo Run della classe application) l’applicazione stessa. Nel gestore di questo evento possiamo impostare il codice di uscita dell’applicazione;

· SessionEnding : viene invocato nel momento in cui un utente di windows si disconnette dalla sessione (ad esempio per uno shutdown del sistema);

· Startup : viene invocato nel momento in cui viene eseguito il metodo Run della classe Application.

Per quanto riguarda la modalità con cui un applicazione può essere chiusa, abbiamo a disposizione la proprietà ShutdownMode della classe application che può assumere i seguenti valori:

· OnLastWindowClose : l’applicazione viene chiusa quando l’ultima finestra viene chiusa;

· OnMainWindowClose : l’applicazione viene chiusa quando la finestra principale viene chiusa (è l’impostazione di default);

· OnExplicitShutdown : la chiusura dell’applicazione deve essere effettuata tramite il metodo Shutdown della classe Application.

All’interno del nostro codice possiamo interagire con l’applicazione in esecuzione attraverso la proprietà statica (di sola lettura) Current della classe Application. Ad esempio, vogliamo recuperare la finestra principale dell’applicazione possiamo utilizzare la proprietà Application.Current.MainWindow.

Infine, per concludere, possiamo gestire, all’avvio della nostra applicazione, eventuali argomenti passati all’eseguibile. Gli argomenti sono contenuti nell’array di stringhe Args dell’oggetto StartupEventArgs passato nell’evento di startup dell’applicazione.


Scarica la versione PDF dell'articolo. Scarica la versione Amazon Kindle dell'articolo.

Commenti

Post popolari in questo blog

VB.NET: Convertire un file DOC in RTF e PDF con office interop

In questo post vorrei proporvi del codice per poter convertire un file .doc in un file .rtf oppure .pdf utilizzando le API di interoperabilità di Office.Creeremo una classe, DocConverter, che esporrà le due funzionalità sopra citate.Cominciamo con il prevedere un attributo privato della classe che rappresenterà l’applicazione Word che utilizzeremo per la conversione. Creeremo l’istanza dell’attributo privato all’interno del costruttore della classe:PublicSubNew()
IfNot CreateWordApp() Then
ThrowNew ApplicationException("Assembly di interoperabilità con Office non trovato!")
EndIf
EndSub
Private _wordApp As Word.ApplicationClass
ProtectedFunction CreateWordApp() AsBoolean
Dim retval = True
Try
_wordApp = New Word.ApplicationClass()
_wordApp.Visible = False
Catch ex As System.Exception
_wordApp = Nothing
retval = False
EndTry
Return retval
EndFunction

La conversione del file doc sarà effettuata aprendo il file stesso ed eseguendo un’operazione di SaveAs:

Pr…

VB.NET for Dummies: Gli Eventi

Vorrei iniziare con questo post una serie dedicata ad aspetti di VB.NET di base che possono essere utile a coloro che si avvicinano al mondo .NET e che, in genere, non vengono trattati a livello base.La serie di post non ha la pretesa di essere assolutamente esaustivi sugli argomenti che tratteròIn questo primo post parleremo degli eventi.Cosa sono e a cosa servonoUn evento è la “notifica” dell’accadimento di qualcosa.Quando, ad esempio, premiamo un bottone della finestra di un’applicazione, dietro le quinte, il bottone stesso “notifica” al mondo circostante che qualcuno, in quell’istante, lo ha premuto.Sta, poi, al mondo circostante preoccuparsi di “intercettare” l’evento stesso per gestirlo (tramite un gestore di evento).Attenzione a non confondere la pressione del tasto con la “notifica” della pressione del tasto: l’evento è la “notifica” dell’accadimento, non l’accadimento stesso.Ma a cosa serve tutto ciò?Utilizzare gli eventi è un modo per disaccoppiare due o più attori del nostr…

Creare uno shortcut con VB.NET

Prendendo spunto da un post comparso sul forum MSDN vorrei proporvi un tip su come creare uno shortcut utilizzando VB.NET.Per poter creare uno shortcut possiamo procedere in due modi: o ci studiamo la struttura del file .lnk e scriviamo una classe che è in grado di ricreare tale struttura oppure utilizziamo Windows Scripting Host.La prima soluzione è percorribile ma laboriosa perchè la struttura di un file lnk non è banale. Chi fosse interessato a vedere come è composto, internamente, un file lnk può scaricare la seguente reference guide (link).Io vorrei proporvi la seconda strada e realizzerò una classe che incapsula l’utilizzo di Windows Scripting Host.L’object model di Windows Scripting Host è contenuto nella dll IWshRuntimeLibrary che può essere referenziata, nel nostro progetto, utilizzando il tab COM della finestra di aggiunta delle reference:Tra gli oggetti che troviamo all’interno della libreria utilizzeremo la classe WshShell e la classe WshShortcut.La prima delle due rappres…