Přehled správy aplikací

Článek
12/17/2024

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í ve třídě Application pro vytváření a správu aplikací.

Třída aplikace

Ve WPF se běžné funkce vymezené aplikací zapouzdřují do třídy Application. Třída Application obsahuje následující funkce:

Sledování a interakce s životností aplikace
Načítání a zpracová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 pro Application a jejich provedení. Zobrazením souvisejícího rozhraní API a témat najdete další informace a ukázkový kód.

Úkol	Přístup
Získání objektu, který představuje aktuální aplikaci	Použijte vlastnost Application.Current.
Přidání úvodní obrazovky do aplikace	Viz Přidání úvodní obrazovky do aplikace WPF.
Spuštění aplikace	Použijte metodu Application.Run.
Zastavení aplikace	Použijte Shutdown metodu objektu Application.Current.
Získání argumentů z příkazového řádku	Zpracujte událost Application.Startup a použijte vlastnost StartupEventArgs.Args. Příklad najdete v události Application.Startup.
Získání a nastavení ukončovacího kódu aplikace	Nastavte vlastnost ExitEventArgs.ApplicationExitCode v obslužné rutině události Application.Exit nebo zavolejte metodu Shutdown a předejte celé číslo.
Detekce neošetřených výjimek a reakce na ně	Zpracování události DispatcherUnhandledException
Získání a nastavení prostředků v oboru aplikace	Použijte vlastnost Application.Resources.
Použijte slovník prostředků oboru aplikace	Viz Použitíslovníku prostředků Application-Scope .
Získání a nastavení vlastností s vymezeným oborem aplikace	Použijte vlastnost Application.Properties.
Získání a uložení stavu aplikace	Viz zachování a obnovení vlastností Application-Scope napříč relacemi aplikace.
Správa datových souborů bez kódu, včetně souborů prostředků, souborů obsahu a souborů původu webu	Viz prostředky aplikace WPF, obsah a datové soubory.
Správa oken v samostatných aplikacích	Podívejte se na WPF Windows Overview.
Sledování a správa navigace	Podívejte se na přehled navigace.

Definice aplikace

Pokud chcete využívat funkce Application třídy, musíte implementovat definici aplikace. Definice aplikace WPF je třída, která je odvozena z Application a 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 v pozadí. Toto umožňuje použít značkování k deklarativnímu nastavení vlastností aplikace, prostředků a registraci událostí, zatímco zpracováváte události a implementujete chování specifické 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 mohl soubor se značkami a soubor s kódem fungovat společně, musí se stát následující:

V kódu musí prvek Application obsahovat atribut x:Class. Při sestavení aplikace existence x:Class v souboru značek způsobí MSBuild vytvoření partial třídy, která je odvozena z Application a má název, který je určen atributem x:Class. To vyžaduje přidání deklarace oboru názvů XML pro schéma XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").
V kódu na pozadí musí být třída partial třída se stejným názvem, který je určen atributem x:Class ve značkování a musí být odvozena z Application. To umožňuje přidružit soubor kódu s třídou partial, která je generována pro soubor značek při sestavení aplikace (viz Sestavení aplikace WPF).

Poznámka

Když vytvoříte nový projekt aplikace WPF nebo projekt aplikace WPF Browser pomocí sady Visual Studio, definice aplikace se standardně zahrne a definuje se pomocí značek i kódu.

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 provést další konfiguraci MSBuild v definici aplikace.

Konfigurace definičního souboru pro 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í.

Varování

XBAPs vyžadují, aby fungovaly starší prohlížeče, jako je Internet Explorer a starší verze Firefoxu. Tyto starší prohlížeče jsou obvykle nepodporované ve Windows 10 a Windows 11. Moderní prohlížeče už kvůli rizikům zabezpečení nepodporují technologii potřebnou pro aplikace XBAP. Moduly plug-in, které umožňují XBAPs, se už nepodporují. Další informace najdete v tématu nejčastější dotazy k aplikacím hostovaným v prohlížeči WPF (XBAP).

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 MSBuild ApplicationDefinition položka, 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 code-behind soubor obsahuje kód, je označen jako položka MSBuild Compile, jak je to obvyklé.

Použití těchto konfigurací MSBuild na soubory definice aplikace, jako jsou markup a code-behind soubory, způsobí, že 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 aplikace o další kód infrastruktury, který zahrnuje metodu vstupního bodu Main. Atribut STAThreadAttribute se použije na metodu Main, která indikuje, ž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í Main vytvoří novou instanci App před voláním metody InitializeComponent pro registraci událostí a nastavení vlastností implementovaných v kódu. Vzhledem k tomu, že InitializeComponent je vygenerován za vás, nemusíte explicitně volat InitializeComponent z definice aplikace, jako jste to udělali pro Page a Window implementace. Nakonec se volá metoda Run pro spuštění aplikace.

Získání aktuální aplikace

Vzhledem k tomu, že funkce třídy Application jsou sdíleny v rámci aplikace, může existovat pouze jedna instance třídy Application na AppDomain. Aby se to vynutilo, je Application třída implementována jako singleton třída (viz Implementace Singleton v jazyce C#), který vytvoří jedinou instanci a poskytuje k ní sdílený přístup pomocí vlastnosti staticCurrent.

Následující kód ukazuje, jak získat odkaz na objekt Application 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 třídy Application. Pokud chcete mít referenci na odvozenou třídu Application, musíte přetypovat hodnotu vlastnosti Current, 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 Current můžete zkontrolovat v libovolném okamžiku životnosti objektu Application. Měli byste ale být opatrní. Po vytvoření instance třídy Application existuje období, během kterého je stav Application objektu nekonzistentní. Během této doby Application provádí různé úlohy inicializace, 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 použít objekt Application, může mít váš kód neočekávané výsledky, zejména pokud závisí na různých Application vlastností, které jsou nastaveny.

Když Application dokončí svou inicializační práci, její ž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 ve 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. Vytvoří se okno SplashScreen a zobrazí se před zavolání Run. Další informace naleznete v tématu Čas spuštění aplikace a Přidat úvodní obrazovku do aplikace WPF.

Spuštění aplikace

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

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 události Startup je jedním z míst, odkud můžete toto provést, což 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

Poznámka

První Window, která se má vytvořit v samostatné aplikaci, se ve výchozím nastavení stane hlavním oknem aplikace. Na tento objekt Window odkazuje vlastnost Application.MainWindow. Hodnota vlastnosti MainWindow lze změnit programově, pokud by mělo být hlavním oknem jiné okno než první vytvoření instance Window.

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 Startup používáte pouze k otevření Window nebo k přechodu na Page, můžete místo toho v kódu nastavit atribut StartupUri.

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.

Poznámka

Další informace o navigaci naleznete v tématu Přehled navigace.

Pokud potřebujete zpracovat událost Startup pro otevření Window, abyste ho mohli vytvořit pomocí konstruktoru bez parametrů, nebo pokud potřebujete před jeho zobrazením nastavit jeho vlastnosti či se přihlásit k odběru jeho událostí, nebo zpracovat všechny argumenty příkazového řádku, které byly zadány při spuštění aplikace.

Zpracování argumentů Command-Line

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álostí prostřednictvím vlastnosti Args 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 a kontroluje, jestli byl poskytnut argument příkazového řádku /StartMinimized; pokud ano, otevře hlavní okno s WindowState Minimized. Všimněte si, že protože vlastnost WindowState musí být nastavena programově, musí být hlavní Window 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, pokud má viditelné Window, které uživatel může vybrat. Aktuálně vybrané Window je aktivní okno (označované také jako okno popředí) a je to Window, 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í se kód Window.
Uživatel přepne z jiné aplikace výběrem Window v aplikaci.

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

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.

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

Následující kód ukazuje, jak zpracovat Activated a Deactivated události, abyste zjistili, jestli 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

Můžete také aktivovat a deaktivovat Window. Další informace najdete v tématu Window.Activated a Window.Deactivated.

Poznámka

Pro XBAPs se nevyvolá Application.Activated ani Application.Deactivated.

Vypnutí aplikace

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

Uživatel zavře každou 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í aplikace poskytuje Application metodu Shutdown, vlastnost ShutdownMode a události SessionEnding a Exit.

Poznámka

Shutdown lze volat pouze z aplikací, které mají UIPermission. Samostatné aplikace WPF vždy mají toto oprávnění. Protokoly XBAP spuštěné v zóně Internetu s částečnou důvěryhodností však izolaci zabezpečení sandboxu netvoří.

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 s jednou z následujících hodnot výčtu ShutdownMode:

Výchozí hodnota ShutdownMode je OnLastWindowClose, což znamená, že aplikace se automaticky vypne, když uživatel zavře poslední okno aplikace. Pokud je však aplikace při zavření hlavního okna vypnuta, WPF to automaticky provede, pokud nastavíte ShutdownMode na OnMainWindowClose. To 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"
    ShutdownMode="OnMainWindowClose" />

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

Poznámka

ShutdownMode lze nastavit z XBAP, ale je ignorován; XBAP se vždy vypne, když je mimo prohlížeč nebo když je zavřený prohlížeč, který je hostitelem XBAP. Další informace naleznete v tématu Přehled navigace.

Konec relace

Podmínky vypnutí popsané vlastností ShutdownMode 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í
Hibernace

Pokud chcete zjistit, kdy relace systému Windows skončí, můžete zpracovat událost SessionEnding, 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 kód zkoumá vlastnost ReasonSessionEnding, aby zjistil, jak se relace systému Windows ukončuje. Tato hodnota používá k zobrazení potvrzovací zprávy uživateli. Pokud uživatel nechce relaci ukončit, nastaví kód Cancel na true, aby se zabránilo ukončení relace Systému Windows.

Poznámka

SessionEnding není zvýšena pro XBAPs.

Východ

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 událost Exit, jako to dělá obslužná rutina události App_Exit 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 souborech App.xaml.cs a Application.xaml.vb.

<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í Application-Scope napříč relacemi aplikace.

Exit mohou zpracovávat jak samostatné aplikace, tak XBAPs. U XBAPs se Exit vyvolá v následujících případech:

Od XBAP se přechází jinam.
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.

Poznámka

Při ladění ze sady Visual Studio se kód ukončení aplikace zobrazí v okně Výstup, když se aplikace vypne, ve zprávě, která vypadá nějak takto:

The program '[5340] AWPFApp.vshost.exe: Managed' has exited with code 0 (0x0).

Kliknutím na Výstup v nabídce Zobrazit otevřete okno Výstup.

Chcete-li změnit ukončovací kód, můžete volat přetížení Shutdown(Int32), které přijímá celočíselný argument 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 ji zpracováním Exit události. Obslužné rutině události Exit je předán ExitEventArgs, který poskytuje přístup k ukončovacímu kódu přes vlastnost ApplicationExitCode. Další informace najdete v tématu Exit.

Poznámka

Ukončovací kód můžete nastavit jak v samostatných aplikacích, tak v XBAPs. Hodnota výstupního kódu je však pro XBAPs ignorována.

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 aplikace se zobrazí oznámení podobné tomu, které je znázorněno na následujícím obrázku.

snímek obrazovky s oznámením o neošetřené výjimce

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 je vyvolána DispatcherUnhandledException událost.

<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

Parametr DispatcherUnhandledExceptionEventArgs, který se předává obslužné rutině události DispatcherUnhandledException, 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 vlastnost DispatcherUnhandledExceptionEventArgs.Handled nastavit na true; v opačném případě 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 musíte zpracovat DispatcherUnhandledException, pokud má aplikace kód, který se musí spustit 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.

samostatná aplikace – události objektu aplikace

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.

XBAP – události objektu aplikace

Viz také

Application
Přehled WPF systému Windows
Přehled navigace
prostředek aplikace WPF, obsah a datové soubory
Pack URI v aplikacích WPF
Aplikační Model: Návody
vývoj aplikací

Sdílet prostřednictvím

Přehled správy aplikací

Třída aplikace

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

Definice aplikace

Implementace definice aplikace

Konfigurace definičního souboru pro MSBuild

Získání aktuální aplikace

Životnost aplikace

Úvodní obrazovka

Spuštění aplikace

Zobrazení uživatelského rozhraní

Zpracování argumentů Command-Line

Aktivace a deaktivace aplikace

Vypnutí aplikace

Režim vypnutí

Konec relace

Východ

Ukončovací kód

Neošetřené výjimky

Události životnosti aplikace

Viz také

Další materiály