Dela via

Översikt över programhantering

  • Artikel

Alla program brukar dela en gemensam uppsättning funktioner som gäller för programimplementering och hantering. Det här avsnittet innehåller en översikt över funktionerna i klassen Application för att skapa och hantera program.

Programklassen

I WPF kapslas vanliga funktioner med programomfattning in i klassen Application. Klassen Application innehåller följande funktioner:

  • Spåra och interagera med programmets livslängd.

  • Hämtar och bearbetar kommandoradsparametrar.

  • Identifiera och svara på ohanterade undantag.

  • Dela programövergripande egenskaper och resurser.

  • Hantera fönster i fristående program.

  • Spåra och hantera navigering.

Så här utför du vanliga uppgifter med hjälp av programklassen

Om du inte är intresserad av all information om klassen Application listar följande tabell några av de vanliga uppgifterna för Application och hur du utför dem. Genom att visa det relaterade API:et och ämnena kan du hitta mer information och exempelkod.

Uppgift Tillvägagångssätt
Hämta ett objekt som representerar det aktuella programmet Använd egenskapen Application.Current.
Lägga till en startskärm i ett program Se Lägg till en välkomstskärm i ett WPF-program.
Starta ett program Använd metoden Application.Run.
Stoppa ett program Använd Shutdown-metoden för Application.Current-objektet.
Hämta argument från kommandoraden Hantera händelsen Application.Startup och använd egenskapen StartupEventArgs.Args. Ett exempel finns i händelsen Application.Startup.
Hämta och ange programmets slutkod Ange egenskapen ExitEventArgs.ApplicationExitCode i händelsehanteraren för Application.Exit eller anropa metoden Shutdown och skicka ett heltal.
Identifiera och svara på ohanterade undantag Hantera händelsen DispatcherUnhandledException.
Hämta och ange tillämpningsomfattande resurser Använd egenskapen Application.Resources.
Använd en resursordlista för applikationsomfattning Se Använd en Application-Scope resursordbok.
Hämta och ange applikationsomfattade egenskaper Använd egenskapen Application.Properties.
Hämta och spara ett programs tillstånd Se bevara och återställa egenskaper för Application-Scope mellan programsessioner.
Hantera icke-kodade datafiler, inklusive resursfiler, innehållsfiler och ursprungsfiler. Se WPF-programresurs, innehåll och datafiler.
Hantera fönster i fristående program Se WPF Windows-översikt.
Spåra och hantera navigering Se navigeringsöversikt.

Programdefinitionen

Om du vill använda funktionerna i klassen Application måste du implementera en programdefinition. En WPF-programdefinition är en klass som härleds från Application och konfigureras med en speciell MSBuild-inställning.

Implementera en applikationsdefinition

En typisk WPF-applikationsdefinition implementeras med både markup (XAML) och code-behind. På så sätt kan du använda markering för att deklarativt ange programegenskaper, resurser och registrera händelser, samtidigt som du hanterar händelser och implementerar programspecifikt beteende i code-behind.

I följande exempel visas hur du implementerar en programdefinition med både markering och bakomliggande kod:

<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

För att en markeringsfil och kod bakom fil ska fungera tillsammans måste följande ske:

  • I markering måste elementet Application innehålla attributet x:Class. När programmet skapas får förekomsten av x:Class i markeringsfilen MSBuild att skapa en partial-klass som härleds från Application och har det namn som anges av attributet x:Class. Detta kräver tillägg av en XML-namnområdesdeklaration för XAML-schemat (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

  • I code-behind måste klassen vara en partial-klass med samma namn som anges av attributet x:Class i markering och måste härledas från Application. Detta gör att filen bakom koden kan associeras med den partial-klass som genereras för markeringsfilen när programmet skapas (se Skapa ett WPF-program).

Notera

När du skapar ett nytt WPF-programprojekt eller ett WPF-webbläsarprogramprojekt med Visual Studio, inkluderas en programdefinition som standard och definieras med både markup och bakomliggande kod.

Den här koden är det minsta som krävs för att implementera en programdefinition. En ytterligare MSBuild-konfiguration måste dock göras till programdefinitionen innan programmet skapas och körs.

Konfigurera programdefinitionen för MSBuild

Fristående program och XAML-webbläsarprogram (XBAPs) kräver implementering av en viss infrastrukturnivå innan de kan köras. Den viktigaste delen av den här infrastrukturen är startpunkten. När ett program startas av en användare anropar operativsystemet startpunkten, som är en välkänd funktion för att starta program.

Varning

XBAP:er kräver att äldre webbläsare används, till exempel Internet Explorer och gamla versioner av Firefox. Dessa äldre webbläsare stöds vanligtvis inte i Windows 10 och Windows 11. Moderna webbläsare stöder inte längre den teknik som krävs för XBAP-appar på grund av säkerhetsrisker. Plugin-program som aktiverar XBAP:er stöds inte längre. Mer information finns i Vanliga frågor och svar om WPF-webbläsarbaserade program (XBAP).

Traditionellt har utvecklare behövt skriva en del av eller hela den här koden för sig själva, beroende på tekniken. WPF genererar dock den här koden åt dig när programdefinitionens markeringsfil konfigureras som ett MSBuild-ApplicationDefinition objekt, enligt följande MSBuild-projektfil:

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

Eftersom koden bakom filen innehåller kod markeras den som en MSBuild-Compile objekt, som vanligt.

Tillämpningen av dessa MSBuild-konfigurationer på markerings- och kod bakom filer i en programdefinition gör att MSBuild genererar kod som följande:

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

Den resulterande koden utökar programdefinitionen med ytterligare infrastrukturkod, som innehåller startpunktsmetoden Main. Attributet STAThreadAttribute tillämpas på metoden Main för att indikera att huvudgränssnittstråden för WPF-programmet är en STA-tråd som krävs för WPF-program. När den anropas skapar Main en ny instans av App innan du anropar metoden InitializeComponent för att registrera händelserna och ange de egenskaper som implementeras i markering. Eftersom InitializeComponent genereras åt dig behöver du inte uttryckligen anropa InitializeComponent från en programdefinition som du gör för Page och Window implementeringar. Slutligen anropas metoden Run för att starta programmet.

Hämta det aktuella programmet

Eftersom funktionerna i Application-klassen delas mellan ett program kan det bara finnas en instans av Application-klassen per AppDomain. För att framtvinga detta implementeras klassen Application som en singleton-klass (se Implementering av Singleton i C#), som skapar en enda instans av sig själv och ger delad åtkomst till den med egenskapen staticCurrent.

Följande kod visar hur du hämtar en referens till Application-objektet för den aktuella AppDomain.

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

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

Current returnerar en referens till en instans av klassen Application. Om du vill ha en referens till din Application härledd klass måste du ange värdet för egenskapen Current, som du ser i följande exempel.

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

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

Du kan kontrollera värdet för Current när som helst under livslängden för ett Application objekt. Du bör dock vara försiktig. När Application-klassen har instansierats finns det en period då tillståndet för det Application objektet är inkonsekvent. Under den här perioden utför Application de olika initieringsuppgifter som krävs av koden för att köras, inklusive att upprätta programinfrastruktur, ange egenskaper och registrera händelser. Om du försöker använda objektet Application under den här perioden kan koden ha oväntade resultat, särskilt om den beror på de olika Application egenskaper som anges.

När Application slutför sitt initieringsarbete börjar dess livslängd verkligen.

Programmets livslängd

Livslängden för ett WPF-program markeras av flera händelser som genereras av Application för att meddela dig när programmet har startats, har aktiverats och inaktiverats och har stängts av.

Välkomstskärm

Från och med .NET Framework 3.5 SP1 kan du ange en bild som ska användas i ett startfönster eller välkomstskärm. Klassen SplashScreen gör det enkelt att visa ett startfönster medan programmet läses in. Fönstret SplashScreen skapas och visas innan Run anropas. Mer information finns i programstarttid och Lägg till en välkomstskärm i ett WPF-program.

Starta ett program

När Run anropas och programmet initieras är programmet redo att köras. Detta ögonblick markeras när händelsen Startup utlöses.

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>

Vid den här tidpunkten under programmets livslängd är det vanligaste att visa ett användargränssnitt.

Visar ett användargränssnitt

De flesta fristående Windows-program öppnar en Window när de börjar köras. Den Startup händelsehanteraren är en plats där du kan göra detta, vilket visas i följande kod.

<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

Not

Den första Window som instansieras i ett fristående program blir som standard det huvudsakliga programfönstret. Det här Window objektet refereras av egenskapen Application.MainWindow. Värdet för egenskapen MainWindow kan ändras programmatiskt om ett annat fönster än den första instansierade Window ska vara huvudfönstret.

När en XBAP först startar kommer den förmodligen att navigera till en Page. Detta visas i följande kod.

<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

Om du hanterar Startup för att bara öppna en Window eller navigera till en Pagekan du ange attributet StartupUri i markering i stället.

I följande exempel visas hur du använder StartupUri från ett fristående program för att öppna en Window.

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

I följande exempel visas hur du använder StartupUri från en XBAP för att navigera till en Page.

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

Den här markeringen har samma effekt som den tidigare koden för att öppna ett fönster.

Obs

Mer information om navigering finns i Navigeringsöversikt.

Du måste hantera Startup-händelsen för att öppna en Window om du behöver instansiera den med en icke-parameterlös konstruktor, eller om du behöver ange dess egenskaper eller prenumerera på dess händelser innan du visar den, eller om du behöver bearbeta eventuella kommandoradsargument som angavs när programmet startades.

Bearbeta Command-Line argumenten

I Windows kan fristående program startas från antingen en kommandotolk eller från skrivbordet. I båda fallen kan kommandoradsargument skickas till programmet. I följande exempel visas ett program som startas med ett enda kommandoradsargument, "/StartMinimized":

wpfapplication.exe /StartMinimized

Under programinitiering hämtar WPF kommandoradsargumenten från operativsystemet och skickar dem till Startup händelsehanterare via egenskapen Args för parametern StartupEventArgs. Du kan hämta och lagra kommandoradsargumenten med hjälp av kod som följande.

<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

Koden hanterar Startup för att kontrollera om kommandoradsargumentet /StartMinimized har angetts. I så fall öppnas huvudfönstret med en WindowState av Minimized. Observera att eftersom egenskapen WindowState måste anges programmatiskt måste huvud-Window öppnas explicit i kod.

XBAP:er kan inte hämta och bearbeta kommandoradsargument eftersom de startas med ClickOnce-distribution (se Distribuera ett WPF-program). De kan dock hämta och bearbeta frågesträngsparametrar från de URL:er som används för att starta dem.

Programaktivering och inaktivering

Med Windows kan användare växla mellan program. Det vanligaste sättet är att använda tangentkombinationen ALT+TAB. En applikation kan endast växlas till om den har en synlig Window som användaren kan välja. Den markerade Window är det aktiva fönstret (även kallat förgrundsfönster) och är det Window som tar emot användarinmatningen. Programmet med det aktiva fönstret är det aktiva programmet (eller förgrundsprogram). Ett program blir det aktiva programmet under följande omständigheter:

  • Det är lanserat och visar Window.

  • En användare växlar från ett annat program genom att välja en Window i programmet.

Du kan identifiera när ett program blir aktivt genom att hantera händelsen Application.Activated.

På samma sätt kan ett program bli inaktivt under följande omständigheter:

  • En användare växlar till ett annat program från det aktuella.

  • När programmet stängs av.

Du kan identifiera när ett program blir inaktivt genom att hantera händelsen Application.Deactivated.

Följande kod visar hur du hanterar Activated och Deactivated händelser för att avgöra om ett program är aktivt.

<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

En Window kan också aktiveras och inaktiveras. Mer information finns i Window.Activated och Window.Deactivated.

Notera

Varken Application.Activated eller Application.Deactivated har tagits upp för XBAP:er.

Programavstängning

Livslängden för ett program upphör när det stängs av, vilket kan inträffa av följande skäl:

  • En användare stänger varje Window.

  • En användare stänger huvud-Window.

  • En användare avslutar Windows-sessionen genom att logga ut eller stänga av.

  • Ett programspecifikt villkor har uppfyllts.

För att hjälpa dig att hantera programavstängning tillhandahåller Application metoden Shutdown, egenskapen ShutdownMode samt händelserna SessionEnding och Exit.

Notera

Shutdown kan bara anropas från program som har UIPermission. Fristående WPF-program har alltid den här behörigheten. XBAP:er som körs i sandbox-miljön för partiellt förtroende för internetzonen gör dock inte det.

Avstängningsläge

De flesta program stängs antingen när alla fönster är stängda eller när huvudfönstret är stängt. Ibland kan dock andra programspecifika villkor avgöra när ett program stängs av. Du kan ange under vilka villkor programmet ska stängas av genom att ange ShutdownMode med något av följande ShutdownMode uppräkningsvärden:

Standardvärdet för ShutdownMode är OnLastWindowClose, vilket innebär att ett program stängs av automatiskt när det sista fönstret i programmet stängs av användaren. Men om programmet ska stängas av när huvudfönstret stängs gör WPF automatiskt det om du anger ShutdownMode till OnMainWindowClose. Detta visas i följande exempel.

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

När du har programspecifika avstängningsvillkor anger du ShutdownMode till OnExplicitShutdown. I det här fallet är det ditt ansvar att stänga av ett program genom att uttryckligen anropa metoden Shutdown; Annars fortsätter programmet att köras även om alla fönster är stängda. Observera att Shutdown anropas implicit när ShutdownMode antingen är OnLastWindowClose eller OnMainWindowClose.

Not

ShutdownMode kan ställas in från en XBAP, men ignoreras. en XBAP stängs alltid av när den navigeras bort från i en webbläsare eller när webbläsaren som är värd för XBAP är stängd. Mer information finns i Navigeringsöversikt.

Sessionsslut

De avstängningsvillkor som beskrivs av egenskapen ShutdownMode är specifika för ett program. I vissa fall kan dock ett program stängas av på grund av ett externt villkor. Det vanligaste externa villkoret inträffar när en användare avslutar Windows-sessionen med följande åtgärder:

  • Logga ut

  • Stänger av

  • Omstart

  • Viloläge

Om du vill identifiera när en Windows-session slutar kan du hantera händelsen SessionEnding, vilket visas i följande exempel.

<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

I det här exemplet kontrollerar koden egenskapen ReasonSessionEnding för att avgöra hur Windows-sessionen slutar. Det använder det här värdet för att visa ett bekräftelsemeddelande för användaren. Om användaren inte vill att sessionen ska avslutas sätter koden Cancel till true för att förhindra att Windows-sessionen avslutas.

Not

SessionEnding aktiveras inte för XBAP:er.

Utgång

När ett program stängs av kan det behöva utföra viss slutlig bearbetning, till exempel att bevara programtillståndet. I dessa situationer kan du hantera Exit-händelsen, som App_Exit-händelsehanteraren gör i följande exempel. Den definieras som en händelsehanterare i filen App.xaml. Implementeringen är markerad i filerna App.xaml.cs och 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

Det fullständiga exemplet finns i Spara och återställa Application-Scope egenskaper mellan programsessioner.

Exit kan hanteras av både fristående program och XBAP:er. För XBAP:er utlöses Exit under följande omständigheter:

  • En XBAP navigeras bort från.

  • När fliken som är värd för XBAP stängs i Internet Explorer.

  • När webbläsaren är stängd.

Avslutskod

Program startas mestadels av operativsystemet som svar på en användarbegäran. Ett program kan dock startas av ett annat program för att utföra en viss uppgift. När det lanserade programmet stängs av kanske det startande programmet vill veta under vilket villkor det startade programmet stängdes av. I dessa situationer tillåter Windows att program returnerar en programavslutskod vid avstängning. Som standard returnerar WPF-program ett slutkodsvärde på 0.

Not

När du felsöker från Visual Studio visas programmets slutkod i fönstret Utdata när programmet stängs av i ett meddelande som ser ut så här:

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

Du öppnar fönstret Utdata genom att klicka på Utdata på menyn Visa.

För att ändra slutkoden kan du anropa Shutdown(Int32)-överbelastningen, som accepterar ett heltalsargument som slutkod:

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

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

Du kan identifiera värdet för slutkoden och ändra den genom att hantera händelsen Exit. Händelsehanteraren för Exit får en ExitEventArgs som ger tillgång till avslutningskoden via egenskapen ApplicationExitCode. Mer information finns i Exit.

Not

Du kan ange slutkoden i både fristående program och XBAP:er. Värdet för slutkoden ignoreras dock för XBAP:er.

Ohanterade undantag

Ibland kan ett program stängas av under onormala förhållanden, till exempel när ett oväntat undantag utlöses. I det här fallet kanske programmet inte har koden för att identifiera och bearbeta undantaget. Den här typen av undantag är ett ohanterat undantag. Ett meddelande som liknar det som visas i följande bild visas innan programmet stängs.

Skärmbild som visar ett ohanterat undantagsmeddelande.

Ur användarupplevelsens perspektiv är det bättre för ett program att undvika det här standardbeteendet genom att göra något av följande:

  • Visa användarvänlig information.

  • Försöker hålla ett program igång.

  • Registrera detaljerad, utvecklarvänlig undantagsinformation i Windows-händelseloggen.

Implementeringen av det här stödet beror på att det går att identifiera ohanterade undantag, vilket är vad den DispatcherUnhandledException händelsen genereras för.

<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

Händelsehanteraren för DispatcherUnhandledException skickas en DispatcherUnhandledExceptionEventArgs parameter som innehåller kontextuell information om det ohanterade undantaget, inklusive själva undantaget (DispatcherUnhandledExceptionEventArgs.Exception). Du kan använda den här informationen för att avgöra hur undantaget ska hanteras.

När du hanterar DispatcherUnhandledExceptionbör du ange egenskapen DispatcherUnhandledExceptionEventArgs.Handled till true; annars anser WPF fortfarande att undantaget är ohanterat och återgår till det standardbeteende som beskrevs tidigare. Om ett ohanterat undantag utlöses och antingen DispatcherUnhandledException händelsen inte hanteras eller om händelsen hanteras och Handled är inställd på falsestängs programmet av omedelbart. Dessutom utlöses inga andra Application händelser. Därför måste du hantera DispatcherUnhandledException om programmet har kod som måste köras innan programmet stängs av.

Även om ett program kan stängas av på grund av ett ohanterat undantag stängs ett program vanligtvis av som svar på en användarbegäran, enligt beskrivningen i nästa avsnitt.

Programlivshändelser

Fristående program och XBAP:er har inte exakt samma livslängd. Följande bild illustrerar de viktigaste händelserna under livslängden för ett fristående program och visar sekvensen där de genereras.

fristående program – Programobjekthändelser

På samma sätt illustrerar följande bild de viktigaste händelserna under livslängden för en XBAP och visar sekvensen där de inträffar.

XBAP – Programobjekthändelser

Se även