Cenni preliminari sulla gestione di applicazioni

Aggiornamento: Luglio 2008

In questo argomento viene fornita una panoramica dei servizi Windows Presentation Foundation (WPF) per la creazione e gestione di applicazioni. Il kernel di un'applicazione WPF è la classe Application, che supporta diversi servizi di base dell'applicazione. Nell'argomento viene fornita un'introduzione ai servizi più importanti.

Nel presente argomento sono contenute le seguenti sezioni.

• Classe Application
• Definizione di applicazione
• Ottenere l'applicazione corrente
• Durata dell'applicazione
• Altri servizi dell'applicazione
• Argomenti correlati

Classe Application

Un'applicazione è costituita da diversi elementi specifici della stessa, inclusi interfaccia utente, regola business, logica di accesso ai dati, controlli e dati. In genere questi elementi differiscono da un'applicazione all'altra. Tuttavia, tutte le applicazioni tendono a condividere un insieme comune di funzionalità che ne facilita l'implementazione e la gestione. In WPF queste funzionalità comuni con ambito di applicazione vengono incapsulate dalla classe Application, che fornisce i seguenti servizi:

• Creazione e gestione dell'infrastruttura di applicazioni comuni.

• Controllo della durata di un'applicazione e interazione con la stessa.

• Recupero ed elaborazione dei parametri della riga di comando.

• Condivisione di proprietà e risorse con ambito di applicazione.

• Rilevamento e risposta a eccezioni non gestite.

• Restituzione di codici di uscita.

• Gestione di finestre in applicazioni autonome (vedere Cenni preliminari sulle finestre WPF).

• Rilevamento e gestione dello spostamento (vedere Cenni preliminari sull'esplorazione).

Per utilizzare questi servizi nell'applicazione, è necessario utilizzare la classe Application per implementare una definizione di applicazione.

Definizione di applicazione

Una definizione di applicazione WPFè una classe che deriva da Application ed è configurata con un'impostazione Microsoft Build Engine (MSBuild) speciale.

Implementazione di una definizione di applicazione

Una definizione di applicazione WPF tipica viene implementata mediante markup e code-behind. In questo modo è possibile utilizzare il markup per impostare in modo dichiarativo le proprietà dell'applicazione, le risorse e registrare gli eventi, gestendo al contempo gli eventi e implementando il comportamento specifico dell'applicazione nel code-behind.

Nell'esempio seguente viene illustrato come implementare una definizione di applicazione tramite markup e code-behind:

<Application 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" 
  x:Class="SDKSample.App" />

using System.Windows;  // Application

namespace SDKSample
{
    public partial class App : Application { }
}

Per consentire il funzionamento congiunto di un file di markup e un file code-behind, è necessario soddisfare le seguenti condizioni:

• Nel markup, l'elemento Application deve includere l'attributo x:Class. Quando l'applicazione viene compilata, l'esistenza di x:Class nel file di markup fa sì che MSBuild crei una classe partial derivante da Page e avente il nome specificato dall'attributo x:Class. Questo richiede l'aggiunta di una dichiarazione dello spazio dei nomi XML per lo schema XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml").

• Nel code-behind, la classe deve essere una classe partial con lo stesso nome specificato dall'attributo x:Class nel markup e deve derivare da Application. In questo modo il file code-behind può essere associato alla classe partial generata per il file di markup durante la compilazione dell'applicazione (vedere Compilazione di un'applicazione WPF).

Questo codice è il requisito minimo necessario per implementare una definizione di applicazione. È tuttavia necessario creare una configurazione MSBuild aggiuntiva per la definizione di applicazione prima di compilare ed eseguire l'applicazione.

Configurazione della definizione di applicazione per MSBuild

L'esecuzione delle applicazioni autonome e delle applicazione browser XAML (XBAP) richiede l'implementazione di un determinato livello di infrastruttura. La parte più importante di questa infrastruttura è il punto di ingresso. Quando un'applicazione viene avviata da un utente, il sistema operativo chiama il punto di ingresso, una funzione nota per l'avvio di applicazioni.

In precedenza, occorreva che gli sviluppatori scrivessero personalmente l'intero codice o parte di esso, a seconda della tecnologia. WPF genera invece questo codice quando il file di markup della definizione di applicazione viene configurato come elemento ApplicationDefinition MSBuild, come illustrato nel seguente file di progetto MSBuild:

<Project 
  DefaultTargets="Build"
  xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  ...
  <ApplicationDefinition Include="App.xaml" />
  <Compile Include="App.xaml.cs" />
  ...
</Project>

Poiché il file code-behind contiene codice, viene contrassegnato come elemento Compile MSBuild, come vuole la prassi.

L'applicazione di queste configurazioni MSBuild ai file di markup e code-behind di una definizione di applicazione fa sì che MSBuild generi codice analogo a quello riportato di seguito:

using System; // STAThread
using System.Windows; // Application

namespace SDKSample
{
    public class App : Application
    {
        public App() { }
        [STAThread]
        public static void Main()
        {
            // Create new instance of application subclass
            App app = new App();

            // Code to register events and set properties that were
            // defined in XAML in the application definition
            app.InitializeComponent();

            // Start running the application
            app.Run();
        }

        public void InitializeComponent()
        {


...


        }
    }
}

Il codice risultante integra la definizione di applicazione con un codice di infrastruttura aggiuntivo, il quale include il metodo del punto di ingresso Main. L'attributo STAThreadAttribute viene applicato al metodo Main per indicare che il thread principale dell'interfaccia utente per l'applicazione WPF è un thread STA, necessario nel caso di applicazioni WPF. Quando viene chiamato, Main crea una nuova istanza di App prima di chiamare il metodo InitializeComponent per registrare gli eventi e impostare le proprietà implementate nel markup. Poiché InitializeComponent viene generato da WPF, non sarà necessario chiamarlo in modo esplicito da una definizione di applicazione, come avviene invece per le implementazioni di Page e Window. Infine viene chiamato il metodo Run per avviare l'applicazione.

Ottenere l'applicazione corrente

Poiché i servizi della classe Application vengono condivisi nell'ambito di un'applicazione, può esistere un'unica istanza della suddetta classe per AppDomain. Per fare in modo che questo accada, la classe Application viene implementata come classe Singleton (vedere Implementing Singleton in C# - informazioni in lingua inglese), la quale crea un'unica istanza di se stessa e ne fornisce l'accesso condiviso mediante la proprietà Current static.

Nel codice riportato di seguito viene illustrato come acquisire un riferimento all'oggetto Application per AppDomain corrente.

// Get current application
Application current = App.Current;

Current restituisce un riferimento a un'istanza della classe Application. Per ottenere un riferimento alla classe derivata Application è necessario eseguire il cast del valore della proprietà Current, come illustrato nell'esempio che segue.

// Get strongly-typed current application
App app = (App)App.Current;

Il valore di Current può essere controllato in qualsiasi momento nel corso della durata di un oggetto Application. Tuttavia, è necessario prestare attenzione. Una volta creata un'istanza della classe Application, lo stato dell'oggetto Application diventa incoerente per un determinato periodo di tempo. Durante questo periodo, Application esegue le varie attività di inizializzazione richieste dal codice per l'esecuzione, incluso stabilire l'infrastruttura dell'applicazione, impostare le proprietà e registrare gli eventi. Se si tenta di utilizzare l'oggetto Application durante questo periodo, il codice potrebbe avere risultati imprevisti, in particolare se dipende dalle varie proprietà di Application impostate.

Nel momento in cui Application completa le operazioni di inizializzazione, ha inizio la reale durata.

Durata dell'applicazione

La durata di un'applicazione WPF è segnata da diversi eventi generati da Application, grazie ai quali è possibile sapere quando l'applicazione è stata avviata, attivata e disattivata, nonché chiusa.

Schermata iniziale

A partire da .NET Framework 3.5 SP1, è possibile specificare un'immagine da utilizzare in una finestra di avvio o schermata iniziale. La classe SplashScreen agevola la visualizzazione di una finestra di avvio mentre l'applicazione viene caricata. La finestra SplashScreen viene creata e visualizzata prima che venga chiamato Run. Per ulteriori informazioni, vedere Tempo di avvio delle applicazioni e Procedura: aggiungere una schermata iniziale in un'applicazione WPF.

Avvio di un'applicazione

Una volta chiamato Run e inizializzata l'applicazione, questa è pronta per essere eseguita. Questo momento corrisponde al momento in cui viene generato l'evento Startup:

using System.Windows; // Application, StartupEventArgs, WindowState

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Application is running


...


        }
    }
}

A questo punto della durata di un'applicazione, l'operazione più comune da eseguire è la visualizzazione di un'interfaccia utente.

Visualizzazione di un'interfaccia utente

Gran parte delle applicazioni Windows autonome aprono un oggetto Window una volta iniziata l'esecuzione. Il gestore eventi Startup è uno dei percorsi da cui è possibile eseguire questa operazione, come illustrato nel codice che segue.

<Application
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App" 
  Startup="App_Startup" />

using System.Windows; // Application, StartupEventArgs

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Open a window
            MainWindow window = new MainWindow();
            window.Show();
        }
    }
}

Al primo avvio di un'applicazione XBAP, è probabile che si verifichi uno spostamento su un oggetto Page, come illustrato nel codice che segue.

Se Startup viene gestito per la sola apertura di un oggetto Window o lo spostamento su un oggetto Page, è possibile impostare l'attributo StartupUri nel markup.

Nell'esempio seguente viene illustrato come utilizzare StartupUri da un'applicazione autonoma per aprire un oggetto Window.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="MainWindow.xaml" />

Nell'esempio seguente viene illustrato come utilizzare StartupUri da un'applicazione XBAP per spostarsi su un oggetto Page.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="HomePage.xaml" />

Questo markup ha lo stesso effetto del codice precedente per l'apertura di una finestra.

L'evento Startup deve essere gestito per l'apertura di un oggetto Window nei seguenti casi: se è necessario crearne un'istanza tramite un costruttore non predefinito, se è necessario impostarne le proprietà o sottoscriverne gli eventi prima di visualizzarlo oppure se occorre elaborare gli argomenti della riga di comando forniti in fase di avvio dell'applicazione.

Elaborazione degli argomenti della riga di comando

In Windows, le applicazioni autonome possono essere avviate da un prompt dei comandi oppure dal desktop. In entrambi i casi, gli argomenti della riga di comando possono essere passati all'applicazione. Nell'esempio che segue viene illustrata un'applicazione avviata con un unico argomento della riga di comando, "/StartMinimized":

wpfapplication.exe /StartMinimized

Durante l'inizializzazione dell'applicazione, WPF recupera gli argomenti della riga di comando dal sistema operativo e li passa al gestore eventi Startup tramite la proprietà Args del parametro StartupEventArgs. Gli argomenti della riga di comando possono essere recuperati e archiviati tramite codice analogo a quello riportato di seguito.

<Application
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App"
  Startup="App_Startup" />

using System.Windows; // Application, StartupEventArgs, WindowState

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Application is running
            // Process command line args
            bool startMinimized = false;
            for (int i = 0; i != e.Args.Length; ++i)
            {
                if (e.Args[i] == "/StartMinimized")
                {
                    startMinimized = true;
                }
            }

            // Create main application window, starting minimized if specified
            MainWindow mainWindow = new MainWindow();
            if (startMinimized)
            {
                mainWindow.WindowState = WindowState.Minimized;
            }
            mainWindow.Show();
        }
    }
}

Il codice gestisce Startup per controllare se l'argomento della riga di comando /StartMinimized è stato fornito; in caso affermativo, apre la finestra principale con WindowState equivalente a Minimized. Poiché la proprietà WindowState deve essere impostata a livello di codice, l'oggetto Window principale deve essere esplicitamente aperto nel codice.

Per un esempio che illustra una tecnica di analisi della riga di comando più affidabile, con l'utilizzo di espressioni regolari, vedere Esempio di elaborazione degli argomenti della riga di comando.

Le applicazioni XBAP non possono recuperare ed elaborare gli argomenti della riga di comando poiché vengono avviate mediante distribuzione ClickOnce (vedere Distribuzione di un'applicazione WPF (WPF)). Tuttavia sono in grado di recuperare ed elaborare i parametri delle stringhe di query dagli URL utilizzati per l'avvio. Per un esempio, vedere Esempio di parametri di una stringa di query URI.

Attivazione e disattivazione di un'applicazione

Windows consente agli utenti di passare da un'applicazione all'altra. Il metodo più comune consiste nell'utilizzo della combinazione di tasti ALT+TAB. Per passare a un'applicazione, occorre che questa disponga di un oggetto Window visibile e selezionabile da parte di un utente. L'oggetto Window attualmente selezionato rappresenta la finestra attiva, nota anche come finestra in primo piano, ed è l'oggetto Window che riceve l'input dell'utente. L'applicazione alla quale appartiene la finestra attiva è definita applicazione attiva o applicazione in primo piano. Di seguito vengono riportati i casi in cui un'applicazione diventa l'applicazione attiva:

• Viene avviata e visualizza un oggetto Window.

• Un utente passa da un'altra applicazione a quella in questione selezionando un oggetto Window nella stessa.

È possibile rilevare quando un'applicazione diventa attiva mediante gestione dell'evento Application.Activated.

Allo stesso modo, un'applicazione diventa inattiva nei seguenti casi:

• Un utente passa dall'applicazione corrente a un'altra applicazione.

• L'applicazione viene chiusa.

È possibile rilevare quando un'applicazione diventa inattiva mediante gestione dell'evento Application.Deactivated.

Nel codice seguente viene illustrato come gestire gli eventi Activated e Deactivated per determinare se un'applicazione è attiva o meno.

<Application 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App"
  StartupUri="MainWindow.xaml"
  Activated="App_Activated" 
  Deactivated="App_Deactivated" />

using System; // EventArgs
using System.Windows; // Application

namespace SDKSample
{
    public partial class App : Application
    {
        bool isApplicationActive;

        void App_Activated(object sender, EventArgs e)
        {
            // Application activated
            this.isApplicationActive = true;
        }

        void App_Deactivated(object sender, EventArgs e)
        {
            // Application deactivated
            this.isApplicationActive = false;
        }
    }
}

Anche Window può essere attivato e disattivato. Per ulteriori informazioni, vedere Window.Activated e Window.Deactivated.

Chiusura di un'applicazione

La durata di un'applicazione termina quando questa viene chiusa per uno dei seguenti motivi:

• Un utente chiude tutti gli oggetti Window.

• Un utente chiude l'oggetto Window principale.

• Un utente termina la sessione di Windows mediante disconnessione o spegnimento del computer.

• È stata soddisfatta una condizione specifica dell'applicazione.

Per facilitare la gestione della chiusura di un'applicazione, Application fornisce il metodo Shutdown, la proprietà ShutdownMode e gli eventi SessionEnding ed Exit.

Modalità di chiusura

La maggior parte delle applicazioni vengono chiuse in seguito a chiusura di tutte le finestre o della finestra principale. Talvolta però la chiusura di un'applicazione viene determinata da altre condizioni specifiche della stessa. Tali condizioni possono essere specificate impostando ShutdownMode con uno dei valori di enumerazione ShutdownMode seguenti:

• OnLastWindowClose

• OnMainWindowClose

• OnExplicitShutdown

Il valore predefinito di ShutdownMode è OnLastWindowClose, il quale determina la chiusura automatica di un'applicazione quando l'ultima finestra di questa viene chiusa dall'utente. Tuttavia è anche possibile fare in modo che l'applicazione venga chiusa quando si chiude la finestra principale. WPF esegue automaticamente tale operazione se si imposta ShutdownMode su OnMainWindowClose, come illustrato nell'esempio che segue.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    ShutdownMode="OnMainWindowClose" />

In presenza di condizioni di chiusura specifiche dell'applicazione, impostare ShutdownMode su OnExplicitShutdown. In questo caso, per chiudere un'applicazione sarà necessario chiamare in modo esplicito il metodo Shutdown; in caso contrario, l'applicazione continuerà a essere eseguita anche se tutte le finestre sono chiuse. Shutdown viene chiamato in modo implicito quando ShutdownMode è impostato su OnLastWindowClose o OnMainWindowClose.

Fine della sessione

Le condizioni di chiusura descritte dalla proprietà ShutdownMode sono specifiche di un'applicazione. In alcuni casi, tuttavia, è possibile che un'applicazione venga chiusa in seguito a una condizione esterna. La condizione esterna più comune si verifica quando un utente termina la sessione di Windows mediante le seguenti azioni:

• Disconnessione

• Spegnimento

• Riavvio

• Ibernazione

Per rilevare la fine di una sessione di Windows, è possibile gestire l'evento SessionEnding, come illustrato nell'esempio che segue.

<Application 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="MainWindow.xaml"
    SessionEnding="App_SessionEnding" />

using System.Windows; // Application, SessionEndingCancelEventArgs, MessageBox, MessageBoxResult, MessageBoxButton

namespace SDKSample
{
    public partial class App : Application
    {
        void App_SessionEnding(object sender, SessionEndingCancelEventArgs e)
        {
            // Ask the user if they want to allow the session to end
            string msg = string.Format("{0}. End session?", e.ReasonSessionEnding);
            MessageBoxResult result = MessageBox.Show(msg, "Session Ending", MessageBoxButton.YesNo);

            // End session, if specified
            if (result == MessageBoxResult.No)
            {
                e.Cancel = true;
            }
        }
    }
}

In questo esempio, il codice controlla la proprietà ReasonSessionEnding per stabilire come viene terminata la sessione di Windows. Utilizza quindi questo valore per visualizzare un messaggio di conferma per l'utente. Se l'utente decide che la sessione non deve terminare, il codice imposta Cancel su true per impedire la fine della sessione di Windows.

Uscita

Quando un'applicazione viene chiusa, è possibile che debba eseguire alcune operazioni di elaborazione finale, ad esempio mantenere lo stato dell'applicazione. In questi casi è possibile gestire l'evento Exit.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="MainWindow.xaml" 
    Startup="App_Startup" 
    Exit="App_Exit">


...


</Application>

using System.Windows; // Application, StartupEventArgs
using System.IO; // StreamReader, FileMode
using System.IO.IsolatedStorage; // IsolatedStorageFile, IsolatedStorageFileStream

namespace SDKSample
{
    public partial class App : Application
    {
        string filename = "App.txt";

Per l'esempio completo, vedere Procedura: salvare in modo permanente e ripristinare le proprietà con ambito applicazione tra le sessioni di un'applicazione.

Exit può essere gestito sia da applicazioni autonome che da applicazioni XBAP. Per quanto concerne le applicazioni XBAP, Exit viene generato nei seguenti casi:

• L'utente si sposta da un'applicazione XBAP.

• In Internet Explorer 7, la scheda che ospita l'applicazione XBAP viene chiusa.

• Il browser viene chiuso.

Codice di uscita

Nella maggior parte dei casi le applicazioni vengono avviate dal sistema operativo in risposta a una richiesta dell'utente. Tuttavia è possibile che un'applicazione venga avviata da un'altra applicazione per eseguire un'attività specifica. Quando l'applicazione avviata viene chiusa, è possibile che l'altra applicazione voglia conoscere la condizione che ne ha determinato la chiusura. In questi casi, Windows consente alle applicazioni di restituire un codice di uscita al momento della chiusura. Per impostazione predefinita, le applicazioni WPF restituiscono un codice di uscita con valore pari a 0.

Per modificare il codice di uscita è possibile chiamare l'overload di Shutdown(Int32), il quale accetta un argomento integer come codice di uscita:

// Shutdown and return a non-default exit code
Application.Current.Shutdown(-1);

È possibile rilevare e modificare il valore del codice di uscita mediante gestione dell'evento Exit. Al gestore eventi Exit viene passato un oggetto ExitEventArgs che consente di accedere al codice di uscita con la proprietà ApplicationExitCode. Per ulteriori informazioni, vedere Exit.

Eccezioni non gestite

Talvolta un'applicazione può essere chiusa in condizioni anomale, ad esempio in seguito alla generazione di un'eccezione imprevista. In questo caso, è possibile che l'applicazione non disponga del codice necessario a rilevare ed elaborare l'eccezione. Si avrà quindi un'eccezione non gestita e, prima della chiusura dell'applicazione, verrà visualizzata una notifica simile a quella riportata nella figura che segue.

Dal punto di vista dell'esperienza utente, è preferibile evitare questo comportamento predefinito dell'applicazione nei modi che seguono:

• Visualizzando informazioni di facile comprensione.

• Tentando di mantenere in esecuzione un'applicazione.

• Registrando informazioni sull'eccezione dettagliate e facilmente comprensibili per lo sviluppatore nel registro eventi di Windows.

L'implementazione di questo supporto dipende dalla possibilità di rilevare o meno le eccezioni non gestite, motivo per cui viene generato l'evento DispatcherUnhandledException.

<Application
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App"
  StartupUri="MainWindow.xaml"
  DispatcherUnhandledException="App_DispatcherUnhandledException" />

using System.Windows; // Application
using System.Windows.Threading; // DispatcherUnhandledExceptionEventArgs

namespace SDKSample
{
    public partial class App : Application
    {
        void App_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            // Process unhandled exception


...


            // Prevent default unhandled exception processing
            e.Handled = true;
        }
    }
}

Al gestore eventi DispatcherUnhandledException viene passato un parametro DispatcherUnhandledExceptionEventArgs contenente informazioni contestuali riguardo l'eccezione non gestita, inclusa l'eccezione stessa (DispatcherUnhandledExceptionEventArgs.Exception). È possibile utilizzare queste informazioni per stabilire come gestire l'eccezione.

Quando si gestisce DispatcherUnhandledException, è necessario impostare la proprietà DispatcherUnhandledExceptionEventArgs.Handled su true; in caso contrario, WPF continua a considerare l'eccezione come non gestita e ripristina il comportamento predefinito descritto in precedenza. Se viene generata un'eccezione non gestita e l'evento DispatcherUnhandledException non è gestito oppure l'evento è gestito e Handled è impostato su false, l'applicazione viene immediatamente chiusa. Inoltre, non vengono generati altri eventi Application. Di conseguenza, è necessario gestire DispatcherUnhandledException nel caso in cui l'applicazione possieda un codice da eseguire prima della chiusura.

Benché possa essere determinata da un'eccezione non gestita, in genere la chiusura di un'applicazione avviene in risposta a una richiesta dell'utente, come illustrato nella sezione che segue.

Eventi di durata dell'applicazione

La durata delle applicazioni autonome e delle applicazioni XBAP non è esattamente la stessa. Nella figura che segue vengono illustrati gli eventi principali nella durata di un'applicazione autonoma con la relativa sequenza di generazione.

Allo stesso modo, vengono illustrati anche gli eventi principali nella durata di un'applicazione XBAP con la relativa sequenza di generazione.

Altri servizi dell'applicazione

Oltre a gestire la durata di un'applicazione, Application fornisce servizi aggiuntivi tra cui:

• Proprietà con ambito di applicazione condivise.

• Risorse con ambito di applicazione condivise.

• File di risorse, file di dati e file del sito di origine dell'applicazione.

• Gestione delle finestre.

• Gestione dello spostamento.

Proprietà con ambito di applicazione condivise

L'applicazione fornisce la proprietà Properties per esporre uno stato condivisibile nell'ambito dell'intera applicazione. Di seguito viene riportato un esempio dell'utilizzo di Properties:

// Set an application-scope property with a custom type
CustomType customType = new CustomType();
Application.Current.Properties["CustomType"] = customType;


...


// Get an application-scope property
// NOTE: Need to convert since Application.Properties is a dictionary of System.Object
CustomType customType = (CustomType)Application.Current.Properties["CustomType"];

Per ulteriori informazioni, vedere i seguenti argomenti:

• Procedura: ottenere e impostare le proprietà dell'ambito dell'applicazione

• Procedura: salvare in modo permanente e ripristinare le proprietà con ambito applicazione tra le sessioni di un'applicazione

Risorse con ambito di applicazione condivise

L'applicazione fornisce la proprietà Resources che consente agli sviluppatori di condividere le risorse dell'interfaccia utente nell'ambito dell'applicazione stessa. Di seguito viene riportato un esempio dell'utilizzo di Properties:

// Set an application-scope resource
Application.Current.Resources["ApplicationScopeResource"] = Brushes.White;


...


// Get an application-scope resource
Brush whiteBrush = (Brush)Application.Current.Resources["ApplicationScopeResource"];

Per ulteriori informazioni, vedere i seguenti argomenti:

• TryFindResource

• FindResource

• Procedura: ottenere e impostare le risorse dell'ambito dell'applicazione

• Cenni preliminari sulle risorse

File di risorse, file di dati e file del sito di origine dell'applicazione

Le applicazioni WPF possono gestire vari tipi di file di dati diversi da codice, inclusi i file di risorse, i file di dati e i file del sito di origine. I metodi di supporto seguenti possono essere utilizzati per caricare questi tipi di file di dati:

• GetResourceStream

• GetContentStream

• GetRemoteStream

Gestione finestre

Application e Window sono strettamente correlati. Come si è visto, la durata di un'applicazione può dipendere dalla durata delle relative finestre, come specificato dalla proprietà ShutdownMode. Application registra la finestra designata come finestra principale dell'applicazione (Application.MainWindow) e gestisce un elenco di finestre per le quali è stata attualmente creata un'istanza (Application.Windows).

Per ulteriori informazioni, vedere la classe Cenni preliminari sulle finestre WPF.

Gestione dello spostamento

Nel caso delle applicazioni autonome con spostamento mediante NavigationWindow e Frame o delle applicazioni XBAP, Application rileva gli spostamenti all'interno di un'applicazione e genera, in base alle necessità, i seguenti eventi:

• Navigating

• Navigated

• NavigationProgress

• NavigationFailed

• NavigationStopped

• LoadCompleted

• FragmentNavigation

Inoltre, Application offre ad applicazioni di qualsiasi tipo la possibilità di creare, salvare in modo permanente e recuperare cookie mediante l'utilizzo di GetCookie e SetCookie.

Per ulteriori informazioni, vedere Cenni preliminari sull'esplorazione.

Vedere anche

Concetti

Cenni preliminari sulle finestre WPF

Cenni preliminari sull'esplorazione

File di dati e di risorse delle applicazioni Windows Presentation Foundation

Riferimenti

Application

Cronologia delle modifiche

Date	History	Motivo
Luglio 2008	Aggiunta sezione sull'utilizzo di una schermata iniziale.	Modifica di funzionalità in SP1.