Přehled správy aplikací

Všechny aplikace mají tendenci sdílet společnou sadu funkcí, které platí pro implementaci a správu aplikací. Toto téma obsahuje přehled funkcí třídy Application pro vytváření a správu aplikací.

Třída aplikace

Ve WPF je společná funkce vymezená aplikací zapouzdřena do Application třídy. Třída Application obsahuje následující funkce:

• Sledování a interakce s životností aplikace

• Načítání a zpracovávání parametrů příkazového řádku

• Detekce neošetřených výjimek a reagování na ně

• Sdílení vlastností a prostředků oboru aplikace

• Správa oken v samostatných aplikacích

• Sledování a správa navigace

Provádění běžných úloh pomocí třídy aplikace

Pokud vás všechny podrobnosti Application třídy nezajímají, uvádí následující tabulka některé běžné úlohy a Application jejich provedení. Zobrazením souvisejícího rozhraní API a témat najdete další informace a ukázkový kód.

Definice aplikace

Pokud chcete využívat funkce Application třídy, musíte implementovat definici aplikace. Definice aplikace WPF je třída, která je odvozena a Application je nakonfigurována se speciálním nastavením MSBuild.

Implementace definice aplikace

Typická definice aplikace WPF se implementuje pomocí značek i kódu. To umožňuje použít značky k deklarativnímu nastavení vlastností aplikace, prostředků a registrace událostí při zpracování událostí a implementaci chování specifického pro aplikaci v kódu.

Následující příklad ukazuje, jak implementovat definici aplikace pomocí značek i kódu na pozadí:

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

using System.Windows;

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
    End Class
End Namespace

Aby soubor s kódem a soubor s kódem fungovaly společně, musí proběhnout následující kroky:

• V souboru s XAML kódem musí element Application obsahovat atribut x:Class. Při sestavení aplikace, existence x:Class v souboru značek způsobí MSBuild vytvořit partial třídu, která je odvozena a Application má název, který je určen atributem x:Class . To vyžaduje přidání deklarace názvového prostoru XML pro schéma XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

• V kódu za třídou musí být partial třída se stejným názvem, který je určen atributem x:Class v kódu a musí odvodit z Application. To umožňuje, aby se soubor kódu za kódem přidružoval ke partial třídě, která je vygenerována pro soubor revizí při vytváření aplikace (viz Sestavení aplikace WPF).

Tento kód je minimum, které je nutné k implementaci definice aplikace. Před sestavením a spuštěním aplikace je však potřeba do definice aplikace vytvořit další konfiguraci NÁSTROJE MSBuild.

Konfigurace definice aplikace pro NÁSTROJ MSBuild

Samostatné aplikace a aplikace prohlížeče XAML (XBAPs) před spuštěním vyžadují implementaci určité úrovně infrastruktury. Nejdůležitější součástí této infrastruktury je vstupní bod. Když uživatel spustí aplikaci, operační systém volá vstupní bod, což je dobře známá funkce pro spouštění aplikací.

Tradičně vývojáři potřebovali napsat nějaký nebo celý tento kód pro sebe v závislosti na technologii. WPF však vygeneruje tento kód za vás, když je soubor značek vaší definice aplikace nakonfigurován jako položka MSBuild ApplicationDefinition , jak je znázorněno v následujícím souboru projektu MSBuild:

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

Vzhledem k tomu, že soubor kódu za kódem obsahuje kód, je označen jako položka MSBuild Compile , jak je normální.

Aplikace těchto konfigurací MSBuild pro soubory kódu a kódu definice aplikace způsobí, že NÁSTROJ MSBuild vygeneruje kód podobný následujícímu:

using System;
using System.Windows;

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()
        {
            // Initialization code goes here.
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Public Class App
        Inherits Application
        Public Sub New()
        End Sub
        <STAThread>
        Public Shared Sub Main()
            ' Create new instance of application subclass
            Dim app As 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()
        End Sub

        Public Sub InitializeComponent()
            ' Initialization code goes here.	
        End Sub
    End Class
End Namespace

Výsledný kód rozšiřuje definici vaší aplikace o další kód infrastruktury, který zahrnuje metodu Mainvstupního bodu . Atribut STAThreadAttribute se použije na metodu Main , která označuje, že hlavní vlákno uživatelského rozhraní pro aplikaci WPF je vlákno STA, které je vyžadováno pro aplikace WPF. Při volání vytvoří Main novou instanci App před voláním InitializeComponent metody pro registraci událostí a nastavení vlastností, které jsou implementovány v kódu. Vzhledem k tomu InitializeComponent , že je pro vás generován, nemusíte explicitně volat InitializeComponent z definice aplikace, jako to uděláte pro Page a Window implementace. Nakonec se Run volá metoda pro spuštění aplikace.

Získání aktuální aplikace

Vzhledem k tomu, že funkce třídy jsou sdíleny Application v rámci aplikace, může existovat pouze jedna instance Application třídy na každou AppDomain. K vynucování je Application třída implementována jako singleton třída (viz Implementace Singleton v jazyce C#), která vytvoří jednu instanci sama o sobě a poskytuje sdílený přístup k ní s staticCurrent vlastností.

Následující kód ukazuje, jak získat odkaz na Application objekt pro aktuální AppDomain.

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

' Get current application
Dim current As Application = App.Current

Current vrátí odkaz na instanci Application třídy. Pokud chcete odkaz na odvozenou Application třídu, musíte přetypovat hodnotu Current vlastnosti, jak je znázorněno v následujícím příkladu.

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

' Get strongly-typed current application
Dim appCurrent As App = CType(App.Current, App)

Hodnotu objektu můžete zkontrolovat Current v libovolném okamžiku životnosti objektu Application . Měli byste ale být opatrní. Application Po vytvoření instance třídy existuje období, během kterého je stav objektu Application nekonzistentní. Během této doby provádí různé úlohy inicializace, Application které váš kód vyžaduje ke spuštění, včetně vytvoření infrastruktury aplikace, nastavení vlastností a registrace událostí. Pokud se během tohoto období pokusíte objekt použít Application , může mít váš kód neočekávané výsledky, zejména pokud závisí na nastavených různých Application vlastnostech.

Po Application dokončení jeho inicializační práce, jeho životnost skutečně začíná.

Životnost aplikace

Životnost aplikace WPF je označena několika událostmi, které jsou vyvolány Application , abyste věděli, kdy byla aplikace spuštěna, aktivována a deaktivována a byla vypnuta.

Úvodní obrazovka

Počínaje rozhraním .NET Framework 3.5 SP1 můžete zadat obrázek, který se má použít v spouštěcím okně, nebo úvodní obrazovku. Třída SplashScreen usnadňuje zobrazení spouštěcího okna při načítání aplikace. Okno SplashScreen se vytvoří a zobrazí se před Run zavolání. Další informace naleznete v tématu Čas spuštění aplikace a přidání úvodní obrazovky do aplikace WPF.

Spuštění aplikace

Po Run zavolání a inicializace aplikace je připravena ke spuštění. Tento okamžik se označuje při Startup vyvolání události:

using System.Windows;

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

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Application is running
            '</SnippetStartupCODEBEHIND1>
    End Class
End Namespace
'</SnippetStartupCODEBEHIND2>

V tomto okamžiku životnosti aplikace je nejběžnější věcí, kterou je třeba udělat, zobrazit uživatelské rozhraní.

Zobrazení uživatelského rozhraní

Většina samostatných aplikací pro Windows otevře Window při spuštění. Obslužná rutina Startup události je jedno místo, ze kterého to můžete provést, jak ukazuje následující kód.

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

using System.Windows;

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Open a window
            Dim window As New MainWindow()
            window.Show()
        End Sub
    End Class
End Namespace

Když se poprvé spustí XBAP, pravděpodobně přejde na .Page To je znázorněno v následujícím kódu.

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

using System;
using System.Windows;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            ((NavigationWindow)this.MainWindow).Navigate(new Uri("HomePage.xaml", UriKind.Relative));
        }
    }
}

Imports System.Windows
Imports System.Windows.Navigation

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            CType(Me.MainWindow, NavigationWindow).Navigate(New Uri("HomePage.xaml", UriKind.Relative))
        End Sub
    End Class
End Namespace

Pokud zpracováváte Startup pouze otevření Window nebo přechod na , Pagemůžete místo toho nastavit StartupUri atribut v kódu.

Následující příklad ukazuje, jak použít StartupUri ze samostatné aplikace k otevření Window.

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

Následující příklad ukazuje, jak použít StartupUri z XBAP k přechodu na Page.

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

Tento kód má stejný účinek jako předchozí kód pro otevření okna.

Pokud Window potřebujete vytvořit instanci pomocí konstruktoru bez parametrů, musíte událost zpracovatStartup, nebo musíte před zobrazením nastavit její vlastnosti nebo přihlásit se k odběru událostí nebo zpracovat všechny argumenty příkazového řádku, které byly zadány při spuštění aplikace.

Zpracování argumentů příkazového řádku

Ve Windows je možné samostatné aplikace spustit z příkazového řádku nebo z plochy. V obou případech je možné do aplikace předat argumenty příkazového řádku. Následující příklad ukazuje aplikaci, která je spuštěna s jedním argumentem příkazového řádku "/StartMinimized":

wpfapplication.exe /StartMinimized

Během inicializace aplikace wpF načte argumenty příkazového řádku z operačního systému a předá je obslužné rutině Startup události prostřednictvím Args vlastnosti parametru StartupEventArgs . Argumenty příkazového řádku můžete načíst a uložit pomocí kódu, jako je následující.

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

using System.Windows;

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();
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Application is running
            ' Process command line args
            Dim startMinimized As Boolean = False
            Dim i As Integer = 0
            Do While i <> e.Args.Length
                If e.Args(i) = "/StartMinimized" Then
                    startMinimized = True
                End If
                i += 1
            Loop

            ' Create main application window, starting minimized if specified
            Dim mainWindow As New MainWindow()
            If startMinimized Then
                mainWindow.WindowState = WindowState.Minimized
            End If
            mainWindow.Show()
        End Sub
    End Class
End Namespace

Kód zpracovává Startup kontrolu, zda byl argument příkazového řádku /StartMinimized poskytnut; pokud ano, otevře hlavní okno s parametrem WindowState Minimized. Všimněte si, že vzhledem k tomu WindowState , že vlastnost musí být nastavena programově, musí být hlavní Window soubor otevřen explicitně v kódu.

XBAPs nemohou načíst a zpracovat argumenty příkazového řádku, protože jsou spuštěny pomocí nasazení ClickOnce (viz Nasazení aplikace WPF). Můžou ale načítat a zpracovávat parametry řetězce dotazu z adres URL, které se používají ke spuštění.

Aktivace a deaktivace aplikace

Systém Windows umožňuje uživatelům přepínat mezi aplikacemi. Nejběžnějším způsobem je použití kombinace kláves ALT+TAB. Aplikaci lze přepnout pouze v případě, že má viditelné Window , že uživatel může vybrat. Aktuálně vybrané Window je aktivní okno (označované také jako okno popředí) a je Window to, které přijímá uživatelský vstup. Aplikace s aktivním oknem je aktivní aplikace (nebo aplikace na popředí). Aplikace se stane aktivní aplikací za následujících okolností:

• Spustí se a zobrazí Window.

• Uživatel přepne z jiné aplikace tak Window , že vybere v aplikaci.

Zjištění, kdy se aplikace stane aktivní, můžete zjistit zpracováním Application.Activated události.

Podobně může být aplikace neaktivní za následujících okolností:

• Uživatel přepne na jinou aplikaci z aktuální aplikace.

• Když se aplikace vypne.

Můžete zjistit, kdy se aplikace stane neaktivní, a to zpracováním Application.Deactivated události.

Následující kód ukazuje, jak zpracovat Activated události a Deactivated určit, zda je aplikace aktivní.

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

using System;
using System.Windows;

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;
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private isApplicationActive As Boolean

        Private Sub App_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Application activated
            Me.isApplicationActive = True
        End Sub

        Private Sub App_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
            ' Application deactivated
            Me.isApplicationActive = False
        End Sub
    End Class
End Namespace

Je Window také možné aktivovat a deaktivovat. Další informace najdete a Window.Deactivated dozvíte Window.Activated se o tom.

Vypnutí aplikace

Životnost aplikace skončí, když se vypne, což může nastat z následujících důvodů:

• Uživatel zavře každý Window.

• Uživatel zavře hlavní Window.

• Uživatel ukončí relaci Systému Windows tím, že se odhlásí nebo vypne.

• Byla splněna podmínka specifická pro aplikaci.

Pro usnadnění správy vypnutí Application aplikace poskytuje metodu Shutdown ShutdownMode , vlastnost a SessionEnding Exit události.

Režim vypnutí

Většina aplikací se vypne, a to buď při zavření všech oken, nebo při zavření hlavního okna. Někdy ale můžou jiné podmínky specifické pro aplikaci určit, kdy se aplikace vypne. Podmínky, za kterých se aplikace vypne, můžete zadat nastavením ShutdownMode jedné z následujících ShutdownMode hodnot výčtu:

• OnLastWindowClose

• OnMainWindowClose

• OnExplicitShutdown

Výchozí hodnota ShutdownMode je OnLastWindowClose, což znamená, že aplikace automaticky vypne, když uživatel zavře poslední okno v aplikaci. Pokud by však aplikace měla být vypnuta při zavření hlavního okna, WPF to automaticky provede, pokud jste nastavili ShutdownMode OnMainWindowClose. To je ukázáno v následujícím příkladu.

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

Pokud máte podmínky vypnutí specifické pro aplikaci, nastavíte ShutdownMode na OnExplicitShutdownhodnotu . V tomto případě je vaší zodpovědností vypnout aplikaci explicitním voláním Shutdown metody. Jinak bude vaše aplikace fungovat i v případě, že jsou všechna okna zavřená. Všimněte si, že Shutdown je volána implicitně, pokud ShutdownMode je buď OnLastWindowClose nebo OnMainWindowClose.

Konec relace

Podmínky vypnutí, které jsou popsány ShutdownMode vlastností, jsou specifické pro aplikaci. V některých případech se ale aplikace může vypnout v důsledku externí podmínky. K nejběžnější externí podmínce dochází, když uživatel ukončí relaci Systému Windows následujícími akcemi:

• Odhlášení

• Vypnutí

• Restartování

• Režimu spánku

Pokud chcete zjistit, kdy relace Systému Windows skončí, můžete SessionEnding zpracovat událost, jak je znázorněno v následujícím příkladu.

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

using System.Windows;

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;
            }
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_SessionEnding(ByVal sender As Object, ByVal e As SessionEndingCancelEventArgs)
            ' Ask the user if they want to allow the session to end
            Dim msg As String = String.Format("{0}. End session?", e.ReasonSessionEnding)
            Dim result As MessageBoxResult = MessageBox.Show(msg, "Session Ending", MessageBoxButton.YesNo)

            ' End session, if specified
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End Sub
    End Class
End Namespace

V tomto příkladu ReasonSessionEnding kód zkontroluje vlastnost, aby určil, jak relace Systému Windows končí. Tato hodnota používá k zobrazení potvrzovací zprávy uživateli. Pokud uživatel nechce relaci ukončit, nastaví Cancel kód tak, aby true zabránil ukončení relace Systému Windows.

Ukončit

Když se aplikace vypne, může být potřeba provést určité konečné zpracování, jako je zachování stavu aplikace. V těchto situacích můžete zpracovat Exit událost, protože obslužná rutina App_Exit události v následujícím příkladu. Je definován jako obslužná rutina události v souboru App.xaml . Jeho implementace je zvýrazněna v App.xaml.cs a Application.xaml.vb soubory.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="MainWindow.xaml" 
    Startup="App_Startup" 
    Exit="App_Exit">
    <Application.Resources>
        <SolidColorBrush x:Key="ApplicationScopeResource" Color="White"></SolidColorBrush>
    </Application.Resources>
</Application>

using System.Windows;
using System.IO;
using System.IO.IsolatedStorage;

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

        public App()
        {
            // Initialize application-scope property
            this.Properties["NumberOfAppSessions"] = 0;
        }

        private void App_Startup(object sender, StartupEventArgs e)
        {
            // Restore application-scope property from isolated storage
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForDomain();
            try
            {
                using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(filename, FileMode.Open, storage))
                using (StreamReader reader = new StreamReader(stream))
                {
                    // Restore each application-scope property individually
                    while (!reader.EndOfStream)
                    {
                        string[] keyValue = reader.ReadLine().Split(new char[] {','});
                        this.Properties[keyValue[0]] = keyValue[1];
                    }
                }
            }
            catch (FileNotFoundException ex)
            {
                // Handle when file is not found in isolated storage:
                // * When the first application session
                // * When file has been deleted
            }
        }

        private void App_Exit(object sender, ExitEventArgs e)
        {
            // Persist application-scope property to isolated storage
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForDomain();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(filename, FileMode.Create, storage))
            using (StreamWriter writer = new StreamWriter(stream))
            {
                // Persist each application-scope property individually
                foreach (string key in this.Properties.Keys)
                {
                    writer.WriteLine("{0},{1}", key, this.Properties[key]);
                }
            }
        }
    }
}

Imports System.IO
Imports System.IO.IsolatedStorage

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private filename As String = "App.txt"

        Public Sub New()
            ' Initialize application-scope property
            Me.Properties("NumberOfAppSessions") = 0
        End Sub

        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Restore application-scope property from isolated storage
            Dim storage As IsolatedStorageFile = IsolatedStorageFile.GetUserStoreForDomain()
            Try
                Using stream As New IsolatedStorageFileStream(filename, FileMode.Open, storage)
                Using reader As New StreamReader(stream)
                    ' Restore each application-scope property individually
                    Do While Not reader.EndOfStream
                        Dim keyValue() As String = reader.ReadLine().Split(New Char() {","c})
                        Me.Properties(keyValue(0)) = keyValue(1)
                    Loop
                End Using
                End Using
            Catch ex As FileNotFoundException
                ' Handle when file is not found in isolated storage:
                ' * When the first application session
                ' * When file has been deleted
            End Try
        End Sub

        Private Sub App_Exit(ByVal sender As Object, ByVal e As ExitEventArgs)
            ' Persist application-scope property to isolated storage
            Dim storage As IsolatedStorageFile = IsolatedStorageFile.GetUserStoreForDomain()
            Using stream As New IsolatedStorageFileStream(filename, FileMode.Create, storage)
            Using writer As New StreamWriter(stream)
                ' Persist each application-scope property individually
                For Each key As String In Me.Properties.Keys
                    writer.WriteLine("{0},{1}", key, Me.Properties(key))
                Next key
            End Using
            End Using
        End Sub
    End Class
End Namespace

Úplný příklad najdete v tématu Zachování a obnovení vlastností oboru aplikace napříč relacemi aplikace.

Exit je možné zpracovat jak samostatnými aplikacemi, tak XBAPs. Pro XBAPs Exit je vyvolána v následujících případech:

• XBAP se odchází.

• Když se v Internet Exploreru zavře karta hostující XBAP.

• Po zavření prohlížeče

Ukončovací kód

Aplikace jsou většinou spouštěné operačním systémem v reakci na požadavek uživatele. Aplikaci však může spustit jiná aplikace, která provede určitou úlohu. Když se spuštěná aplikace vypne, může spouštěcí aplikace chtít znát podmínku, pod kterou se spuštěná aplikace vypne. V těchto situacích systém Windows umožňuje aplikacím vrátit ukončovací kód aplikace při vypnutí. Aplikace WPF ve výchozím nastavení vrací hodnotu ukončovacího kódu 0.

Pokud chcete změnit ukončovací kód, můžete volat Shutdown(Int32) přetížení, které přijímá celočíselné argumenty jako ukončovací kód:

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

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

Hodnotu ukončovacího kódu můžete zjistit a změnit pomocí Exit zpracování události. Obslužná rutina Exit události je předána, ExitEventArgs která poskytuje přístup k ukončovacímu kódu s ApplicationExitCode vlastností. Další informace najdete na webu Exit.

Neošetřené výjimky

Někdy se může aplikace vypnout za neobvyklých podmínek, například při vyvolání neočekávané výjimky. V tomto případě aplikace nemusí mít kód pro detekci a zpracování výjimky. Tento typ výjimky je neošetřená výjimka; Před zavřeným aplikací se zobrazí oznámení podobné tomu, co je znázorněno na následujícím obrázku.

Z hlediska uživatelského prostředí je lepší, aby se aplikace vyhnula tomuto výchozímu chování provedením některých nebo všech následujících kroků:

• Zobrazuje uživatelsky přívětivé informace.

• Pokoušíte se udržet aplikaci spuštěnou.

• Zaznamenávání podrobných informací o výjimce pro vývojáře v protokolu událostí systému Windows.

Implementace této podpory závisí na tom, že dokáže rozpoznat neošetřené výjimky, což je to, k čemu DispatcherUnhandledException je událost vyvolána.

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

using System.Windows;
using System.Windows.Threading;

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;
        }
    }
}

Imports System.Windows
Imports System.Windows.Threading

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_DispatcherUnhandledException(ByVal sender As Object, ByVal e As DispatcherUnhandledExceptionEventArgs)
            ' Process unhandled exception

            ' Prevent default unhandled exception processing
            e.Handled = True
        End Sub
    End Class
End Namespace

Obslužná DispatcherUnhandledException rutina události se předává DispatcherUnhandledExceptionEventArgs parametr, který obsahuje kontextové informace týkající se neošetřené výjimky, včetně samotné výjimky (DispatcherUnhandledExceptionEventArgs.Exception). Tyto informace můžete použít k určení způsobu zpracování výjimky.

Při zpracování DispatcherUnhandledExceptionbyste měli nastavit DispatcherUnhandledExceptionEventArgs.Handled vlastnost truena ; jinak WPF stále považuje výjimku za neošetřenou a vrátí se k výchozímu chování popsanému výše. Pokud je vyvolána neošetřená výjimka a událost DispatcherUnhandledException není zpracována, nebo je událost zpracována a Handled je nastavena na false, aplikace se okamžitě vypne. Kromě toho nejsou vyvolány žádné další Application události. V důsledku toho je nutné zpracovat DispatcherUnhandledException , pokud vaše aplikace obsahuje kód, který musí běžet před vypnutím aplikace.

Aplikace se sice může vypnout v důsledku neošetřené výjimky, ale aplikace se obvykle vypne v reakci na žádost uživatele, jak je popsáno v další části.

Události životnosti aplikace

Samostatné aplikace a XBAPs nemají přesně stejné životnosti. Následující obrázek znázorňuje klíčové události v době životnosti samostatné aplikace a ukazuje posloupnost, ve které jsou vyvolány.

Podobně následující obrázek znázorňuje klíčové události v době životnosti XBAP a ukazuje posloupnost, ve které jsou vyvolány.

Viz také

• Application
• Přehled Windows ve WPF
• Přehled navigace
• Prostředek, obsah a datové soubory aplikace WPF
• Sbalení URI v technologii WPF
• Aplikační model: Postupy: Témata
• Vývoj aplikací