Az alkalmazáskezelés áttekintése

Minden alkalmazás általában közös funkciókkal rendelkezik, amelyek az alkalmazás implementálására és felügyeletére vonatkoznak. Ez a témakör áttekintést nyújt az alkalmazások létrehozására és kezelésére szolgáló Application osztály funkcióiról.

Az alkalmazásosztály

A WPF-ben az alkalmazás hatókörébe tartozó általános funkciók a Application osztályba kerülnek. A Application osztály a következő funkciókat tartalmazza:

• Az alkalmazás élettartamának nyomon követése és interakciója.

• Parancssori paraméterek beolvasása és feldolgozása.

• Nem kezelt kivételek észlelése és megválaszolása.

• Alkalmazás-hatókör tulajdonságainak és erőforrásainak megosztása.

• Ablakok kezelése önálló alkalmazásokban.

• Navigáció nyomon követése és kezelése.

Gyakori feladatok végrehajtása az alkalmazásosztály használatával

Ha nem érdekli az Application osztály összes részlete, az alábbi táblázat felsorolja a Application néhány gyakori feladatát és azok elvégzésének módját. A kapcsolódó API-k és témakörök megtekintésével további információkat és mintakódot találhat.

Feladatok	Megközelítés
Az aktuális alkalmazást jelképező objektum lekérése	Használja a Application.Current tulajdonságot.
Indítási képernyő hozzáadása egy alkalmazáshoz	Lásd: Kezdőképernyő hozzáadása WPF-alkalmazáshoz.
Alkalmazás indítása	Használja a Application.Run módszert.
Alkalmazás leállítása	Használja a Shutdown metódusát a Application.Current objektumnak.
Argumentumok lekérése a parancssorból	Kezelje a Application.Startup eseményt, és használja a StartupEventArgs.Args tulajdonságot. Például tekintse meg a Application.Startup eseményt.
Az alkalmazás kilépési kódjának lekérése és beállítása	Állítsa be a ExitEventArgs.ApplicationExitCode tulajdonságot az Application.Exit eseménykezelőben, vagy hívja meg a Shutdown metódust, és adjon meg egy egész számot.
Nem kezelt kivételek észlelése és megválaszolás	Kezelje a DispatcherUnhandledException eseményt.
Alkalmazás hatókörű erőforrások lekérése és beállítása	Használja a Application.Resources tulajdonságot.
Alkalmazáshatókörű erőforrásszótár használata	Lásd: Application-Scope erőforrás-szótárhasználata.
Alkalmazás hatókörű tulajdonságok lekérése és beállítása	Használja a Application.Properties tulajdonságot.
Alkalmazás állapotának lekérése és mentése	Lásd: Application-Scope tulajdonságainak megőrzése és visszaállítása az alkalmazás-munkamenetek.
Nem kód típusú adatfájlok kezelése, beleértve az erőforrásfájlokat, a tartalomfájlokat és a forráshelyek fájljait.	Lásd a WPF-alkalmazás erőforrásait, tartalmát és adatfájljait.
Ablakok kezelése önálló alkalmazásokban	Lásd a WPF Windows áttekintését.
Navigáció nyomon követése és kezelése	Lásd: Az áttekintés a navigációról.

Az alkalmazásdefiníció

Az Application osztály funkcióinak használatához alkalmazásdefiníciót kell implementálnia. A WPF-alkalmazásdefiníció olyan osztály, amely Application származik, és speciális MSBuild beállítással van konfigurálva.

Alkalmazásdefiníció implementálása

A rendszer egy tipikus WPF-alkalmazásdefiníciót valósít meg a korrektúra és a kód mögötti kód használatával. Ez lehetővé teszi, hogy a korrektúra használatával deklaratív módon állítsa be az alkalmazás tulajdonságait, erőforrásait és regisztrálja az eseményeket, miközben kezeli az eseményeket, és alkalmazásspecifikus viselkedést valósít meg a kód mögött.

Az alábbi példa bemutatja, hogyan implementálhat egy alkalmazásdefiníciót a jelölőnyelv (markup) és a mögöttes kód (code-behind) használatával.

<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

Ahhoz, hogy egy korrektúrafájl és egy kód mögötti fájl működjön együtt, a következőknek kell történnie:

• A korrektúrában a Application elemnek tartalmaznia kell a x:Class attribútumot. Az alkalmazás létrehozásakor a korrektúrafájlban x:Class megléte miatt az MSBuild létrehoz egy partial osztályt, amely Application származik, és a x:Class attribútum által megadott névvel rendelkezik. Ehhez hozzá kell adnunk egy XML-névtér-deklarációt az XAML-sémához (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

• A kód mögötti osztálynak partial osztálynak kell lennie, amelynek neve megegyezik a jelölésben megadott x:Class attribútummal, és Application-ből kell származnia. Ez lehetővé teszi, hogy a kód mögötti fájl az alkalmazás létrehozásakor a korrektúrafájlhoz létrehozott partial osztályhoz legyen társítva (lásd WPF-alkalmazás létrehozása).

Megjegyzés:

Amikor új WPF-alkalmazásprojektet vagy WPF böngészőalkalmazás-projektet hoz létre a Visual Studióval, a rendszer alapértelmezés szerint egy alkalmazásdefiníciót is tartalmaz, amely korrektúrával és kód mögötti kóddal is definiálva van.

Ez a kód az alkalmazásdefiníciók implementálásához szükséges minimális kód. Az alkalmazás létrehozása és futtatása előtt azonban további MSBuild-konfigurációt kell készíteni az alkalmazásdefinícióhoz.

Az MSBuild alkalmazásdefiníciójának konfigurálása

Az önálló alkalmazások és az XAML böngészőalkalmazások (XBAP-k) futtatásához bizonyos szintű infrastruktúra szükséges. Az infrastruktúra legfontosabb része a belépési pont. Amikor egy felhasználó elindít egy alkalmazást, az operációs rendszer meghívja a belépési pontot, amely egy jól ismert függvény az alkalmazások indításához.

Figyelmeztetés

Az XBAP-k működéséhez régi böngészőkre van szükség, például az Internet Explorerre és a Firefox régi verzióira. Ezek a régebbi böngészők általában nem támogatottak a Windows 10-ben és a Windows 11-ben. A modern böngészők már nem támogatják az XBAP-alkalmazásokhoz szükséges technológiát a biztonsági kockázatok miatt. Az XBAP-ket engedélyező beépülő modulok már nem támogatottak. További információ: A WPF böngésző által üzemeltetett alkalmazásokkal (XBAP) kapcsolatos gyakori kérdések.

A fejlesztőknek hagyományosan a technológiától függően maguknak kellett megírniuk a kód egy részét vagy egészét. A WPF azonban akkor hozza létre ezt a kódot, ha az alkalmazásdefiníció korrektúrafájlja MSBuild ApplicationDefinition elemként van konfigurálva, ahogyan az alábbi MSBuild projektfájlban látható:

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

Mivel a kód mögötti fájl kódokat tartalmaz, a rendszer a szokásos módon MSBuild Compile elemként jelöli meg.

Ezeknek az MSBuild-konfigurációknak az alkalmazásdefiníciók korrektúráira és kód mögötti fájljaira való alkalmazása miatt az MSBuild az alábbihoz hasonló kódot hoz létre:

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

Az eredményként kapott kód további infrastruktúrakóddal bővíti az alkalmazásdefiníciót, amely tartalmazza a belépési pont metódusát Main. A STAThreadAttribute attribútum a Main metódusra lesz alkalmazva, amely azt jelzi, hogy a WPF-alkalmazás fő felhasználói felületi szála egy STA-szál, amely a WPF-alkalmazásokhoz szükséges. Meghíváskor Main létrehoz egy új App-példányt, mielőtt meghívja a InitializeComponent metódust az események regisztrálásához és a korrektúra által implementált tulajdonságok beállításához. Mivel a InitializeComponent az Ön számára jön létre, nem kell explicit módon meghívnia InitializeComponent egy alkalmazásdefinícióból, mint a Page és Window implementációk esetében. Végül a Run metódus meghívása az alkalmazás elindításához.

Az aktuális alkalmazás lekérése

Mivel a Application osztály funkciói egy alkalmazáson belül meg vannak osztva, a Application osztálynak csak egy példánya lehet a AppDomain-ben. Ennek kikényszerítéséhez a Application osztály egyetlentonos osztályként van implementálva (lásd A Singleton implementálása a C#-ban), amely egyetlen példányt hoz létre önmagából, és megosztott hozzáférést biztosít hozzá a staticCurrent tulajdonsággal.

Az alábbi kód bemutatja, hogyan szerezhet be hivatkozást az aktuális ApplicationAppDomain objektumára.

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

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

Current a Application osztály egy példányára mutató hivatkozást ad vissza. Ha a Application származtatott osztályra szeretne hivatkozni, a Current tulajdonság értékét kell megadnia az alábbi példában látható módon.

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

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

A Current értékét egy Application objektum élettartamának bármely pontján megvizsgálhatja. Azonban óvatosnak kell lennie. A Application osztály példányosítása után van egy időszak, amely során a Application objektum állapota inkonzisztens. Ebben az időszakban Application végrehajtja a kód futtatásához szükséges különböző inicializálási feladatokat, beleértve az alkalmazásinfrastruktúra létrehozását, a tulajdonságok beállítását és az események regisztrálását. Ha ebben az időszakban a Application objektumot próbálja használni, előfordulhat, hogy a kód váratlan eredményt ad, különösen akkor, ha az a beállított különböző Application tulajdonságoktól függ.

Amikor Application befejezi az inicializálási munkát, az élettartama valóban megkezdődik.

Alkalmazás élettartama

A WPF-alkalmazások élettartamát számos esemény jelöli, amelyeket a Application hoz létre, hogy tudja, mikor indult el az alkalmazás, aktiválódott és inaktivált, és le lett állítva.

Kezdőképernyő

A .NET-keretrendszer 3.5 SP1-től kezdve megadhat egy indítási ablakban használandó képet, vagy kezdőképernyős. A SplashScreen osztály megkönnyíti az indítási ablak megjelenítését az alkalmazás betöltése közben. A SplashScreen ablak a Run meghívása előtt jön létre és jelenik meg. További információ: alkalmazásindítási idő és Kezdőképernyő hozzáadása WPF-alkalmazáshoz.

Alkalmazás indítása

A Run meghívása és az alkalmazás inicializálása után az alkalmazás készen áll a futtatásra. Ez a pillanat a Startup esemény felmerülésekor jelenik meg:

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>

Az alkalmazás élettartamának ezen pontján a leggyakoribb teendő a felhasználói felület megjelenítése.

Felhasználói felület megjelenítése

A legtöbb különálló Windows-alkalmazás megnyit egy Window ablakot, amikor elkezdenek futni. Az Startup eseménykezelő egy olyan hely, ahonnan ezt megteheti, ahogyan azt az alábbi kód is mutatja.

<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

Megjegyzés:

Alapértelmezés szerint az első olyan Window lesz a fő alkalmazásablak, amelyet egy önálló alkalmazásban kell létrehozni. A Window objektumra a Application.MainWindow tulajdonság hivatkozik. A MainWindow tulajdonság értéke programozott módon módosítható, ha az első példányosított Window ablaktól eltérő ablaknak kell lennie a főablaknak.

Amikor egy XBAP először elindul, valószínűleg egy Page-ra navigál. Ez az alábbi kódban jelenik meg.

<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

Ha a Startup-t csak egy Window megnyitására vagy egy Page-höz való navigálásra kezeli, akkor ehelyett a StartupUri attribútumot jelölőként állíthatja be.

Az alábbi példa bemutatja, hogyan lehet egy különálló alkalmazásból a StartupUri-t használni egy Windowmegnyitására.

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

Az alábbi példa bemutatja, hogyan lehet a StartupUri-t egy XBAP-ből felhasználni arra, hogy elnavigáljunk egy Page-hez.

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

Ez a korrektúra ugyanazzal a hatással rendelkezik, mint az ablak megnyitására szolgáló előző kód.

Megjegyzés:

További információ a navigációról: Navigáció áttekintése.

Egy Startup megnyitásához kezelnie kell a Window eseményt, ha nem paraméter nélküli konstruktor használatával kell példányosítania, vagy meg kell adnia a tulajdonságait, vagy elő kell iratkoznia az eseményekre a megjelenítés előtt, vagy fel kell dolgoznia az alkalmazás elindításakor megadott parancssori argumentumokat.

Command-Line argumentumok feldolgozása

Windows rendszerben az önálló alkalmazások parancssorból vagy az asztalról indíthatók el. Mindkét esetben parancssori argumentumok továbbíthatók az alkalmazásnak. Az alábbi példa egy olyan alkalmazást mutat be, amely egyetlen parancssori argumentummal indul el: "/StartMinimized":

wpfapplication.exe /StartMinimized

Az alkalmazás inicializálása során a WPF lekéri a parancssori argumentumokat az operációs rendszerből, és a Startup paraméter Args tulajdonságán keresztül továbbítja azokat a StartupEventArgs eseménykezelőnek. A parancssori argumentumokat az alábbihoz hasonló kóddal kérdezheti le és tárolhatja.

<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

A kód kezeli a Startup-t azért, hogy ellenőrizze, megadták-e a /StartMinimized parancssori argumentumot; ha igen, megnyitja a főablakot WindowState formában Minimized. Vegye figyelembe, hogy mivel a WindowState tulajdonságot programozott módon kell beállítani, a fő Window-t explicit módon kell megnyitni a kódban.

Az XBAP-k nem tudják lekérni és feldolgozni a parancssori argumentumokat, mert a ClickOnce üzembe helyezésével indulnak el (lásd WPF-alkalmazás üzembe helyezése). A lekérdezési sztring paramétereit azonban lekérhetik és feldolgozhatják az indításukhoz használt URL-címekről.

Alkalmazás aktiválása és inaktiválása

A Windows lehetővé teszi a felhasználók számára az alkalmazások közötti váltást. A leggyakoribb módszer az ALT+TAB billentyűkombináció használata. Egy alkalmazás csak akkor váltható át, ha látható Window van, amelyet a felhasználó kiválaszthat. A jelenleg kiválasztott Window az aktív ablak (más néven az előtérablak), és ez az Window, amely fogadja a felhasználói bemenetet. Az aktív ablakkal rendelkező alkalmazás az aktív alkalmazás (vagy előtéralkalmazás). Az alkalmazás az alábbi körülmények között válik aktív alkalmazássá:

• Elindítják, és megjelenít egy Window-t.

• A felhasználó az alkalmazásban egy Window kiválasztásával vált át egy másik alkalmazásról.

Az Application.Activated esemény kezelésével észlelheti, hogy egy alkalmazás mikor válik aktívvá.

Hasonlóképpen, az alkalmazás inaktívvá válhat a következő esetekben:

• A felhasználó az aktuális alkalmazásból vált egy másik alkalmazásra.

• Amikor az alkalmazás leáll.

Az Application.Deactivated esemény kezelésével észlelheti, hogy egy alkalmazás mikor válik inaktívvá.

Az alábbi kód bemutatja, hogyan kezelhetők a Activated és Deactivated események annak megállapításához, hogy egy alkalmazás aktív-e.

<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

A Window is aktiválható és inaktiválható. További információért tekintse meg a Window.Activated és a Window.Deactivated.

Megjegyzés:

Az XBAP-ek esetében sem a Application.Activated, sem a Application.Deactivated nincs aktiválva.

Alkalmazásleállítás

Az alkalmazás élettartama leállításkor ér véget, ami a következő okokból fordulhat elő:

• A felhasználó bezár minden Window-t.

• A felhasználó bezárja a(z) Windowfő elemet.

• A felhasználó kijelentkezéssel vagy leállítással zárja le a Windows-munkamenetet.

• Egy alkalmazásspecifikus feltétel teljesült.

Az alkalmazásleállítás kezeléséhez Application biztosítja a Shutdown metódust, a ShutdownMode tulajdonságot, valamint a SessionEnding és Exit eseményeket.

Megjegyzés:

Shutdown csak olyan alkalmazásokból hívható meg, amelyek UIPermission. Az önálló WPF-alkalmazások mindig rendelkeznek ezzel az engedéllyel. Az internetzónában részleges megbízhatóságú biztonsági tesztkörnyezetben futó XBAP-k azonban nem.

Leállítási mód

A legtöbb alkalmazás leáll az összes ablak bezárásakor vagy a főablak bezárásakor. Előfordulhat azonban, hogy más alkalmazásspecifikus feltételek határozzák meg, hogy mikor áll le egy alkalmazás. Az alábbi ShutdownModeShutdownMode számbavételi értékek egyikével megadhatja, hogy az alkalmazás milyen feltételek mellett fog leállni:

• OnLastWindowClose

• OnMainWindowClose

• OnExplicitShutdown

A ShutdownMode alapértelmezett értéke OnLastWindowClose, ami azt jelenti, hogy az alkalmazás automatikusan leáll, amikor a felhasználó bezárja az alkalmazás utolsó ablakát. Ha azonban az alkalmazást le kell állítani a főablak bezárásakor, a WPF automatikusan ezt teszi, ha kijelölöd ShutdownModeOnMainWindowClose-re. Ez az alábbi példában látható.

<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" />

Ha alkalmazásspecifikus leállítási feltételekkel rendelkezik, ShutdownModeOnExplicitShutdownértékre állítja. Ebben az esetben az Ön felelőssége az alkalmazás leállítása a Shutdown metódus explicit meghívásával; ellenkező esetben az alkalmazás akkor is futni fog, ha az összes ablak be van zárva. Vegye figyelembe, hogy a Shutdown implicit módon hívjuk meg, ha a ShutdownModeOnLastWindowClose vagy OnMainWindowClose.

Megjegyzés:

ShutdownMode beállítható egy XBAP-ből, de figyelmen kívül marad; az XBAP mindig leáll, amikor egy böngészőből elnavigálnak róla vagy amikor az XBAP-t futtató böngészőt bezárják. További információ: Navigáció áttekintése.

Munkamenet vége

A ShutdownMode tulajdonság által leírt leállítási feltételek egy alkalmazásra vonatkoznak. Bizonyos esetekben azonban előfordulhat, hogy egy alkalmazás egy külső feltétel miatt leáll. A leggyakoribb külső feltétel akkor fordul elő, ha egy felhasználó az alábbi műveletekkel befejezi a Windows-munkamenetet:

• Kijelentkezés

• Leállítás

• Újraindítás

• Hibernálás

A Windows-munkamenetek befejeződésének észleléséhez kezelheti a SessionEnding eseményt, ahogyan az az alábbi példában is látható.

<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

Ebben a példában a kód a ReasonSessionEnding tulajdonságot vizsgálja annak meghatározásához, hogy a Windows-munkamenet hogyan végződik. Ezzel az értékkel egy megerősítő üzenetet jelenít meg a felhasználónak. Ha a felhasználó nem szeretné, hogy a munkamenet véget érjen, a kód Cancel-t true-re állítja, hogy megakadályozza a Windows-munkamenet befejeződését.

Megjegyzés:

SessionEnding nem váltódik ki az XBAP-k esetében.

Kijárat

Amikor egy alkalmazás leáll, előfordulhat, hogy végre kell hajtania valamilyen végső feldolgozást, például az alkalmazás állapotának megőrzését. Ezekben a helyzetekben kezelheti az Exit eseményt, ahogyan az App_Exit eseménykezelő az alábbi példában is. Eseménykezelőként van definiálva az App.xaml fájlban. A megvalósítás a App.xaml.cs és Application.xaml.vb fájlokban van kiemelve.

<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

A teljes példáért tekintse meg Application-Scope tulajdonságok megőrzése és visszaállítása az alkalmazás munkamenetei között.

A(z) Exit-t mind önálló alkalmazások, mind pedig XBAP-ek kezelhetik. XBAP-k esetén a Exit a következő esetekben merül fel:

• Az XBAP-ről elnavigáltak.

• Az Internet Explorerben, ha az XBAP-t futtató lap bezárul.

• A böngésző bezárásakor.

Kilépési kód

Az alkalmazásokat többnyire az operációs rendszer indítja el egy felhasználói kérésre válaszul. Egy alkalmazást azonban egy másik alkalmazás is elindíthat bizonyos feladatok végrehajtásához. Amikor az elindított alkalmazás leáll, előfordulhat, hogy az indítást kezdeményező alkalmazás szeretné tudni, milyen körülmények között állt le az elindított alkalmazás. Ilyen esetekben a Windows lehetővé teszi az alkalmazások számára, hogy leállításkor visszaadják az alkalmazás kilépési kódját. A WPF-alkalmazások alapértelmezés szerint 0 kilépési kódértéket ad vissza.

Megjegyzés:

Amikor hibakeresést hajt végre a Visual Studióban, az alkalmazás kilépési kódja megjelenik a Kimeneti ablakban, amikor az alkalmazás leáll, a következőhöz hasonló üzenetben:

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

A Kimenet ablak megnyitásához kattintson a Nézet menü Kimenet parancsára.

A kilépési kód módosításához meghívhatja a Shutdown(Int32) túlterhelést, amely egy egész szám argumentumot fogad el a kilépési kódként:

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

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

A kilépési kód értékét a Exit esemény kezelésével észlelheti és módosíthatja. A Exit eseménykezelő átad egy ExitEventArgs-et, amely hozzáférést ad a kilépési kódhoz a ApplicationExitCode tulajdonságán keresztül. További információért lásd Exit.

Megjegyzés:

A kilépési kódot önálló alkalmazásokban és XBAP-kben is beállíthatja. A kilépési kód értékét azonban a rendszer figyelmen kívül hagyja az XBAP-k esetében.

Kezeletlen kivételek

Előfordulhat, hogy egy alkalmazás rendellenes körülmények között leáll, például váratlan kivétel esetén. Ebben az esetben előfordulhat, hogy az alkalmazás nem rendelkezik a kivétel észlelésére és feldolgozására vonatkozó kóddal. Ez a kivételtípus kezeletlen kivétel; A következő ábrán láthatóhoz hasonló értesítés jelenik meg az alkalmazás bezárása előtt.

A felhasználói élmény szempontjából jobb, ha egy alkalmazás elkerüli ezt az alapértelmezett viselkedést az alábbiak valamelyikével vagy mindegyikével:

• Felhasználóbarát információk megjelenítése.

• Egy alkalmazás folyamatos futtatásának megkísérlése.

• Részletes, fejlesztőbarát kivételadatok rögzítése a Windows eseménynaplójában.

Ennek a támogatásnak a megvalósítása attól függ, hogy képes-e észlelni a kezeletlen kivételeket, ami miatt a DispatcherUnhandledException esemény létrejön.

<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

A DispatcherUnhandledException eseménykezelő egy DispatcherUnhandledExceptionEventArgs paramétert ad át, amely környezeti információkat tartalmaz a kezeletlen kivételről, beleértve magát a kivételt (DispatcherUnhandledExceptionEventArgs.Exception). Ez az információ a kivétel kezelésének módjának meghatározására szolgál.

A DispatcherUnhandledExceptionkezelésekor állítsd be a DispatcherUnhandledExceptionEventArgs.Handled tulajdonságot true-re; ellenkező esetben a WPF továbbra is kezeletlennek tekinti a kivételt, és visszaállít a korábban ismertetett alapértelmezett viselkedéshez. Ha felmerül egy nem kezelt kivétel, és a DispatcherUnhandledException eseményt vagy nem kezelik, vagy az eseményt kezelik, és a Handledfalseértékre van állítva, az alkalmazás azonnal leáll. Ezenkívül nincs más Application esemény, ami elindításra kerül. Ezért kezelnie kell DispatcherUnhandledException-t, ha az alkalmazásnak olyan kódja van, amelyet az alkalmazás leállítása előtt futtatnia kell.

Bár egy alkalmazás kezeletlen kivétel miatt leállhat, az alkalmazások általában egy felhasználói kérésre válaszolva leállnak, ahogyan azt a következő szakaszban is bemutattuk.

Alkalmazás élettartamának eseményei

Az önálló alkalmazások és az XBAP-k élettartama nem azonos. Az alábbi ábra bemutatja az önálló alkalmazások élettartamának legfontosabb eseményeit, és megjeleníti azokat a sorrendet, amelyekben azok létre lettek hozva.

Hasonlóképpen az alábbi ábra bemutatja az XBAP élettartamának legfontosabb eseményeit, és megjeleníti azokat a sorrendet, amelyekben a rendszer emeli őket.

Lásd még

• Application
• WPF Windows áttekintése
• Áttekintés a navigációról
• WPF-alkalmazáserőforrás, -tartalom és adatfájlok
• Csomag URI-k a WPF-ben
• alkalmazásmodell: Útmutató témakörök
• Alkalmazásfejlesztés