Übersicht über die AnwendungsverwaltungApplication Management Overview

Alle Anwendungen nutzen in der Regel einen gemeinsamen Satz von Funktionen, der für die Implementierung und Verwaltung der Anwendung gilt.All applications tend to share a common set of functionality that applies to application implementation and management. Dieses Thema enthält eine Übersicht über die Funktionen in der Application Klasse zum Erstellen und Verwalten von Anwendungen.This topic provides an overview of the functionality in the Application class for creating and managing applications.

Die Application-KlasseThe Application Class

In WPF im Gültigkeitsbereich der Anwendung die Grundfunktionen gekapselt ist, der Application Klasse.In WPF, common application-scoped functionality is encapsulated in the Application class. Die Application Klasse enthält die folgenden Funktionen:The Application class includes the following functionality:

  • Lebensdauer der Anwendung nachverfolgen und mit ihr interagierenTracking and interacting with application lifetime.

  • Befehlszeilenparameter abrufen und verarbeitenRetrieving and processing command-line parameters.

  • Nicht behandelte Ausnahmen erkennen und darauf reagierenDetecting and responding to unhandled exceptions.

  • Anwendungsspezifische Eigenschaften und Ressourcen teilenSharing application-scope properties and resources.

  • Fenster in eigenständigen Anwendungen verwaltenManaging windows in standalone applications.

  • Navigation nachverfolgen und verwaltenTracking and managing navigation.

Ausführen allgemeiner Aufgaben mithilfe der Application-KlasseHow to Perform Common Tasks Using the Application Class

Wenn Sie nicht alle Details der interessiert sind die Application -Klasse, die folgende Tabelle enthält einige häufige Aufgaben für Application und wie diese umgesetzt werden können.If you are not interested in all of the details of the Application class, the following table lists some of the common tasks for Application and how to accomplish them. Weitere Informationen und entsprechenden Beispielcode finden Sie über die zugehörigen APIs und Themen.By viewing the related API and topics, you can find more information and sample code.

AufgabeTask AnsatzApproach
Ein Objekt abrufen, das die aktuelle Anwendung darstellt.Get an object that represents the current application Verwenden Sie die Application.Current-Eigenschaft.Use the Application.Current property.
Einen Startbildschirm zu einer Anwendung hinzufügen.Add a startup screen to an application Finden Sie unter Hinzufügen eines Begrüßungsbildschirms zu einer WPF-Anwendung.See Add a Splash Screen to a WPF Application.
Eine Anwendung starten.Start an application Verwenden Sie die Application.Run-Methode.Use the Application.Run method.
Eine Anwendung beenden.Stop an application Verwenden der Shutdown Methode der Application.Current Objekt.Use the Shutdown method of the Application.Current object.
Argumente über die Befehlszeile abrufen.Get arguments from the command line Behandeln der Application.Startup Ereignisses und verwenden Sie die StartupEventArgs.Args Eigenschaft.Handle the Application.Startup event and use the StartupEventArgs.Args property. Ein Beispiel finden Sie unter den Application.Startup Ereignis.For an example, see the Application.Startup event.
Exitcode der Anwendung abrufen und festlegen.Get and set the application exit code Legen Sie die ExitEventArgs.ApplicationExitCode -Eigenschaft in der Application.Exit Ereignishandler oder der Aufruf der Shutdown -Methode und übergeben Sie eine ganze Zahl.Set the ExitEventArgs.ApplicationExitCode property in the Application.Exit event handler or call the Shutdown method and pass in an integer.
Nicht behandelte Ausnahmen erkennen und darauf reagieren.Detect and respond to unhandled exceptions Behandeln der DispatcherUnhandledException Ereignis.Handle the DispatcherUnhandledException event.
Anwendungsspezifische Ressourcen abrufen und festlegen.Get and set application-scoped resources Verwenden Sie die Application.Resources-Eigenschaft.Use the Application.Resources property.
Ein anwendungsspezifisches Ressourcenverzeichnis verwenden.Use an application-scope resource dictionary Finden Sie unter ein anwendungsspezifisches Ressourcenverzeichnis verwenden.See Use an Application-Scope Resource Dictionary.
Anwendungsspezifische Eigenschaften abrufen und festlegen.Get and set application-scoped properties Verwenden Sie die Application.Properties-Eigenschaft.Use the Application.Properties property.
Den Zustand einer Anwendung abrufen und speichern.Get and save an application's state Finden Sie unter beibehalten und Wiederherstellen von Anwendungsbereichseigenschaften über Anwendungssitzungen.See Persist and Restore Application-Scope Properties Across Application Sessions.
Datendateien ohne Code verwalten, einschließlich Ressourcendateien, Inhalts- und Ursprungssitedateien.Manage non-code data files, including resource files, content files, and site-of-origin files. Finden Sie unter WPF-Anwendungsressource, Inhalt und Datendateien.See WPF Application Resource, Content, and Data Files.
Fenster in eigenständigen Anwendungen verwalten.Manage windows in standalone applications Weitere Informationen finden Sie unter Übersicht über WPF-Fenster.See WPF Windows Overview.
Navigation überwachen und verwalten.Track and manage navigation Finden Sie unter Übersicht über die Navigation.See Navigation Overview.

Die AnwendungsdefinitionThe Application Definition

Nutzen Sie die Funktionalität der Application -Klasse, müssen Sie eine Anwendungsdefinition implementieren.To utilize the functionality of the Application class, you must implement an application definition. Eine Definition der WPF-Anwendung ist eine abgeleitete Klasse Application und mit einer speziellen MSBuild-Einstellung konfiguriert ist.A WPF application definition is a class that derives from Application and is configured with a special MSBuild setting.

Implementieren einer AnwendungsdefinitionImplementing an Application Definition

Eine typische Definition für die WPF-Anwendung wird mithilfe von Markup und CodeBehind implementiert.A typical WPF application definition is implemented using both markup and code-behind. Dadurch können Sie Anwendungseigenschaften und Ressourcen deklarativ mithilfe des Markups festlegen und Ereignisse registrieren, während mit CodeBehind Ereignisse behandelt und anwendungsspezifisches Verhalten implementiert wird.This allows you to use markup to declaratively set application properties, resources, and register events, while handling events and implementing application-specific behavior in code-behind.

Das folgende Beispiel veranschaulicht die Implementierung einer Anwendungsdefinition mithilfe von Markup und CodeBehind:The following example shows how to implement an application definition using both markup and code-behind:

<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 Microsoft.VisualBasic
Imports System.Windows

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

Damit eine Markup- und eine CodeBehind-Datei zusammenarbeiten können, ist Folgendes erforderlich:To allow a markup file and code-behind file to work together, the following needs to happen:

  • Im Markup der Application -Element muss enthalten der x:Class Attribut.In markup, the Application element must include the x:Class attribute. Wenn die Anwendung erstellt wird, wird das Vorhandensein des x:Class im Markup-Datei wird MSBuild zum Erstellen einer partial abgeleitete Klasse Application und hat den Namen, die angegeben wird die x:Class Attribut.When the application is built, the existence of x:Class in the markup file causes MSBuild to create a partial class that derives from Application and has the name that is specified by the x:Class attribute. Dies erfordert das Hinzufügen einer XML-Namespacedeklaration für das XAML-Schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").This requires the addition of an XML namespace declaration for the XAML schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

  • Im Code-Behind muss die Klasse muss eine partial Klasse mit dem gleichen Namen, die angegeben wird die x:Class -Attribut im Markup und eine Ableitung muss Application.In code-behind, the class must be a partial class with the same name that is specified by the x:Class attribute in markup and must derive from Application. Dadurch wird der Code-Behind-Datei zugeordnet werden die partial -Klasse, die für die Markupdatei generiert wird, wenn die Anwendung erstellt wird (finden Sie unter Erstellen einer WPF-Anwendung).This allows the code-behind file to be associated with the partial class that is generated for the markup file when the application is built (see Building a WPF Application).

Hinweis

Wenn Sie ein neues WPF-Anwendungsprojekt oder WPF-Browseranwendungsprojekt mit Visual Studio erstellen, wird eine Anwendungsdefinition ist standardmäßig enthalten und wird mithilfe von Markup und CodeBehind definiert.When you create a new WPF Application project or WPF Browser Application project using Visual Studio, an application definition is included by default and is defined using both markup and code-behind.

Dieser Code ist die Mindestanforderung zum Implementieren einer Anwendungsdefinition.This code is the minimum that is required to implement an application definition. Muss jedoch eine zusätzliche MSBuild-Konfiguration, die Definition für die Anwendung vor dem Erstellen und Ausführen der Anwendung vorgenommen werden.However, an additional MSBuild configuration needs to be made to the application definition before building and running the application.

Konfigurieren der Anwendungsdefinition für MSBuildConfiguring the Application Definition for MSBuild

Eigenständige Anwendungen und XAML-Browseranwendungen (XBAPs) erfordern die Implementierung ein gewisses Maß an die Infrastruktur, bevor sie ausgeführt werden können.Standalone applications and XAML browser applications (XBAPs) require the implementation of a certain level of infrastructure before they can run. Der wichtigste Teil dieser Infrastruktur ist der Einstiegspunkt.The most important part of this infrastructure is the entry point. Wenn eine Anwendung von einem Benutzer gestartet wird, ruft das Betriebssystem den Einstiegspunkt auf, der eine bekannte Funktion zum Starten von Anwendungen ist.When an application is launched by a user, the operating system calls the entry point, which is a well-known function for starting applications.

In der Vergangenheit mussten Entwickler je nach Technologie einen Teil oder sämtlichen Code selbst verfassen.Traditionally, developers have needed to write some or all of this code for themselves, depending on the technology. Allerdings WPF generiert dieser Code für Sie, wenn die Markupdatei Ihrer Anwendungsdefinition, als ein MSBuild konfiguriert ist ApplicationDefinition -Element angegeben, wie in der folgenden MSBuild-Projektdatei dargestellt:However, WPF generates this code for you when the markup file of your application definition is configured as an MSBuild ApplicationDefinition item, as shown in the following MSBuild project file:

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

Da die Code-Behind-Datei Code enthält, wird es als ein MSBuild gekennzeichnet Compile -Element angegeben, ist Sie normal.Because the code-behind file contains code, it is marked as an MSBuild Compile item, as is normal.

Die Anwendung diese MSBuild-Konfigurationen auf die Markup- und Code-Behind-Dateien einer Anwendungsdefinition führt dazu, dass MSBuild zum Generieren von Code wie folgt:The application of these MSBuild configurations to the markup and code-behind files of an application definition causes MSBuild to generate code like the following:

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

Der resultierende Code ergänzt die Anwendungsdefinition um zusätzlichen Infrastrukturcode, einschließlich der Einstiegspunktmethode Main.The resulting code augments your application definition with additional infrastructure code, which includes the entry-point method Main. Die STAThreadAttribute Attribut gilt für die Main Methode, um anzugeben, dass der Hauptthread der Benutzeroberfläche für die WPF-Anwendung einen STA-Thread, der für WPF-Anwendungen erforderlich ist.The STAThreadAttribute attribute is applied to the Main method to indicate that the main UI thread for the WPF application is an STA thread, which is required for WPF applications. Bei Aufruf Main erstellt eine neue Instanz der App vor dem Aufruf der InitializeComponent Methode zum Registrieren der Ereignisse, und legen Sie die Eigenschaften, die im Markup implementiert sind.When called, Main creates a new instance of App before calling the InitializeComponent method to register the events and set the properties that are implemented in markup. Da InitializeComponent wird generiert, Sie müssen nicht explizit aufrufen InitializeComponent aus einer Anwendungsdefinition wie beim Page und Window Implementierungen.Because InitializeComponent is generated for you, you don't need to explicitly call InitializeComponent from an application definition like you do for Page and Window implementations. Zum Schluss die Run aufgerufen, um die Anwendung zu starten.Finally, the Run method is called to start the application.

Abrufen der aktuellen AnwendungsdomäneGetting the Current Application

Da die Funktionalität der Application Klasse in einer Anwendung freigegeben werden, es können nur eine Instanz vorhanden sein. die Application pro Klasse AppDomain.Because the functionality of the Application class are shared across an application, there can be only one instance of the Application class per AppDomain. Um dies zu erzwingen die Application Klasse wird als Singleton-Klasse implementiert (finden Sie unter Implementieren von Singleton in c#), das eine einzelne Instanz von sich selbst erstellt und der SAS mit dem static Current Diese Eigenschaft.To enforce this, the Application class is implemented as a singleton class (see Implementing Singleton in C#), which creates a single instance of itself and provides shared access to it with the staticCurrent property.

Der folgende Code zeigt, wie Sie erhalten einen Verweis auf die Application Objekt für die aktuelle AppDomain.The following code shows how to acquire a reference to the Application object for the current AppDomain.

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

Current Gibt einen Verweis auf eine Instanz von der Application Klasse.Current returns a reference to an instance of the Application class. Einen Verweis auf Wunsch Ihre Application abgeleitete Klasse Sie den Wert wandelt müssen der Current -Eigenschaft, wie im folgenden Beispiel gezeigt.If you want a reference to your Application derived class you must cast the value of the Current property, as shown in the following example.

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

Sie können den Wert der untersuchen Current zu einem beliebigen Zeitpunkt während der Lebensdauer der ein Application Objekt.You can inspect the value of Current at any point in the lifetime of an Application object. Sie sollten dabei jedoch vorsichtig sein.However, you should be careful. Nach der Application Klasse instanziiert wird, gibt es ein Zeitraum während der den Status der Application -Objekts inkonsistent ist.After the Application class is instantiated, there is a period during which the state of the Application object is inconsistent. Während dieses Zeitraums Application ist die verschiedene Aufgaben Initialisierung, die von Ihrem Code erforderlich sind, ausgeführt wird, einschließlich der Einrichtung der Infrastruktur, Festlegen von Eigenschaften und Ereignisse registrieren.During this period, Application is performing the various initialization tasks that are required by your code to run, including establishing application infrastructure, setting properties, and registering events. Wenn Sie versuchen, Sie verwenden die Application Objekt während dieses Zeitraums wird der Code möglicherweise unerwartete Ergebnisse, insbesondere, wenn sie die verschiedenen abhängt Application festzulegenden Eigenschaften.If you try to use the Application object during this period, your code may have unexpected results, particularly if it depends on the various Application properties being set.

Wenn Application nach Abschluss der Initialisierung, seine Lebensdauer wirklich beginnt.When Application completes its initialization work, its lifetime truly begins.

AnwendungslebensdauerApplication Lifetime

Die Lebensdauer einer WPF-Anwendung wird durch verschiedene Ereignisse, die vom ausgelöst werden gekennzeichnet Application , damit Sie benachrichtigt, wenn die Anwendung gestartet wurde, wurde aktiviert und deaktiviert, und heruntergefahren wurde.The lifetime of a WPF application is marked by several events that are raised by Application to let you know when your application has started, has been activated and deactivated, and has been shut down.

BegrüßungsbildschirmSplash Screen

Ab der .NET Framework 3.5 SP1.NET Framework 3.5 SP1, Sie können angeben, ein Image aus, in einem Startfenster oder Begrüßungsbildschirm.Starting in the .NET Framework 3.5 SP1.NET Framework 3.5 SP1, you can specify an image to be used in a startup window, or splash screen. Die SplashScreen -Klasse macht es einfach, ein Startfenster anzuzeigen, während die Anwendung geladen wird.The SplashScreen class makes it easy to display a startup window while your application is loading. Die SplashScreen Fenster erstellt und angezeigt werden, bevor Sie Run aufgerufen wird.The SplashScreen window is created and shown before Run is called. Weitere Informationen finden Sie unter Anwendungsstartzeit und Hinzufügen eines Begrüßungsbildschirms zu einer WPF-Anwendung.For more information, see Application Startup Time and Add a Splash Screen to a WPF Application.

Starten einer AnwendungStarting an Application

Nach dem Run aufgerufen wird und die Anwendung initialisiert wird, die Anwendung für die Ausführung bereit ist.After Run is called and the application is initialized, the application is ready to run. Derzeit gekennzeichnet ist, wenn die Startup Ereignis wird ausgelöst:This moment is signified when the Startup event is raised:

using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Application is running
        }
    }
}
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
        End Sub
    End Class
End Namespace

An diesem Punkt ist der am häufigsten verwendete Schritt das in der Lebensdauer einer Anwendung, um eine Benutzeroberfläche anzuzeigen.At this point in an application's lifetime, the most common thing to do is to show a UI.

Anzeigen einer BenutzeroberflächeShowing a User Interface

Öffnen Sie die meisten eigenständigen Windows-Anwendungen eine Window wenn damit begonnen wird ausgeführt.Most standalone Windows applications open a Window when they begin running. Die Startup -Ereignishandler ist ein Speicherort, von dem Sie dies erreichen, wie im folgenden Code gezeigt.The Startup event handler is one location from which you can do this, as demonstrated by the following code.

<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 Microsoft.VisualBasic
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

Hinweis

Die erste Window um zu instanziierenden in einer eigenständigen Anwendung standardmäßig die Befugnisse Hauptfensters der Anwendung.The first Window to be instantiated in a standalone application becomes the main application window by default. Dies Window Objekt verweist auf die Application.MainWindow Eigenschaft.This Window object is referenced by the Application.MainWindow property. Der Wert des der MainWindow Eigenschaft kann programmgesteuert geändert werden, wenn ein anderes Fenster als das erste instanziiert Window das Hauptfenster sein soll.The value of the MainWindow property can be changed programmatically if a different window than the first instantiated Window should be the main window.

Beim ersten Start eine XBAP wird navigiert diese wahrscheinlich zu einer Page.When an XBAP first starts, it will most likely navigate to a Page. Dies wird im folgenden Code veranschaulicht.This is shown in the following code.

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

Verarbeitet Startup nur öffnen eine Window oder navigieren Sie zu einer Page, Sie können festlegen, die StartupUri Attribut im Markup.If you handle Startup to only open a Window or navigate to a Page, you can set the StartupUri attribute in markup instead.

Das folgende Beispiel zeigt, wie Sie mit der StartupUri einer eigenständigen Anwendung zum Öffnen einer Window.The following example shows how to use the StartupUri from a standalone application to open a Window.

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

Das folgende Beispiel zeigt, wie Sie mit StartupUri aus einer XBAP zum Navigieren zu einer Page.The following example shows how to use StartupUri from an XBAP to navigate to a Page.

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

Dieses Markup hat denselben Effekt wie der vorherige Code zum Öffnen eines Fensters.This markup has the same effect as the previous code for opening a window.

Hinweis

Weitere Informationen zur Navigation finden Sie unter Übersicht über die Navigation.For more information on navigation, see Navigation Overview.

Sie behandeln müssen die Startup Ereignis zu öffnen eine Window , wenn Sie mit einem nicht standardmäßigen Konstruktors instanziieren müssen die Eigenschaften festlegen bzw. Ereignisse abonnieren, bevor es angezeigt werden sollen, oder Sie alle Befehlszeilenargumente verarbeiten müssen, wurden angegeben, wenn die Anwendung gestartet wurde.You need to handle the Startup event to open a Window if you need to instantiate it using a non-default constructor, or you need to set its properties or subscribe to its events before showing it, or you need to process any command-line arguments that were supplied when the application was launched.

Verarbeiten von BefehlszeilenargumentenProcessing Command-Line Arguments

In Windows können eigenständige Anwendungen von einer Eingabeaufforderung oder dem Desktop gestartet werden.In Windows, standalone applications can be launched from either a command prompt or the desktop. In beiden Fällen können Befehlszeilenargumente an die Anwendung übergeben werden.In both cases, command-line arguments can be passed to the application. Im folgenden Beispiel sehen Sie eine Anwendung, die mit nur einem Befehlszeilenargument („/StartMinimized“) gestartet wird:The following example shows an application that is launched with a single command-line argument, "/StartMinimized":

wpfapplication.exe /StartMinimized

Während der anwendungsinitialisierung WPF ruft die Befehlszeilenargumente vom Betriebssystem ab und übergibt sie an der Startup Ereignishandler über die Args Eigenschaft der StartupEventArgs Parameter.During application initialization, WPF retrieves the command-line arguments from the operating system and passes them to the Startup event handler via the Args property of the StartupEventArgs parameter. Mit Code wie dem folgenden können Sie Befehlszeilenargumente abrufen und speichern.You can retrieve and store the command-line arguments using code like the following.

<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 Microsoft.VisualBasic
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

Der Code behandelt Startup um zu überprüfen, ob die /StartMinimized -Befehlszeilenargument angegeben wurde; Wenn dies der Fall ist, wird es das Hauptfenster mit einer WindowState von Minimized.The code handles Startup to check whether the /StartMinimized command-line argument was provided; if so, it opens the main window with a WindowState of Minimized. Beachten Sie, dass die WindowState Eigenschaft muss festgelegt werden, programmgesteuert Hauptfenster Window muss explizit im Code geöffnet sein.Note that because the WindowState property must be set programmatically, the main Window must be opened explicitly in code.

XBAPs können nicht abgerufen werden und Befehlszeilenargumente verarbeiten, da sie mit der ClickOnce-Bereitstellung gestartet werden (finden Sie unter Bereitstellen von WPF-Anwendungen).XBAPs cannot retrieve and process command-line arguments because they are launched using ClickOnce deployment (see Deploying a WPF Application). Von den zum Starten verwendeten URLs können jedoch Abfragezeichenfolgenparameter abgerufen und verarbeitet werden.However, they can retrieve and process query string parameters from the URLs that are used to launch them.

Aktivieren und Deaktivieren von AnwendungenApplication Activation and Deactivation

Windows kann Benutzer zwischen Anwendungen zu wechseln.Windows allows users to switch between applications. Meistens wird dazu die Tastenkombination ALT+TAB verwendet.The most common way is to use the ALT+TAB key combination. Eine Anwendung kann nur gewechselt werden, wenn sie ein sichtbares hat Window , die ein Benutzer auswählen kann.An application can only be switched to if it has a visible Window that a user can select. Das derzeit ausgewählte Window ist die des aktiven Fensters (auch bekannt als die Vordergrundfenster) und die Window , das Benutzereingaben empfängt.The currently selected Window is the active window (also known as the foreground window) and is the Window that receives user input. Die Anwendung mit dem aktiven Fenster ist die aktive Anwendung (oder vordergrundanwendung).The application with the active window is the active application (or foreground application). Eine Anwendung wird unter folgenden Umständen zur aktiven Anwendung:An application becomes the active application in the following circumstances:

  • Es wird gestartet und zeigt eine Window.It is launched and shows a Window.

  • Ein Benutzer wechselt von einer anderen Anwendung durch Auswahl einer Window in der Anwendung.A user switches from another application by selecting a Window in the application.

Sie können erkennen, wenn eine Anwendung aktiv, durch behandeln wird der Application.Activated Ereignis.You can detect when an application becomes active by handling the Application.Activated event.

Auf ähnliche Weise kann eine Anwendung unter folgenden Umständen inaktiv werden:Likewise, an application can become inactive in the following circumstances:

  • Ein Benutzer wechselt von der aktuellen zu einer anderen Anwendung.A user switches to another application from the current one.

  • Wenn die Anwendung heruntergefahren wird.When the application shuts down.

Sie können erkennen, wenn eine Anwendung inaktiv, durch behandeln wird der Application.Deactivated Ereignis.You can detect when an application becomes inactive by handling the Application.Deactivated event.

Der folgende Code zeigt, wie Sie behandelt die Activated und Deactivated Ereignisse, um zu bestimmen, ob eine Anwendung aktiv ist.The following code shows how to handle the Activated and Deactivated events to determine whether an application is active.

<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 Microsoft.VisualBasic
Imports System
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

Ein Window auch aktiviert und deaktiviert werden kann.A Window can also be activated and deactivated. Weitere Informationen finden Sie unter Window.Activated und Window.Deactivated.See Window.Activated and Window.Deactivated for more information.

Hinweis

Weder Application.Activated noch Application.Deactivated für XBAPs ausgelöst.Neither Application.Activated nor Application.Deactivated is raised for XBAPs.

Herunterfahren einer AnwendungApplication Shutdown

Die Lebensdauer einer Anwendung endet mit dem Herunterfahren, das aus folgenden Gründen erfolgen kann:The life of an application ends when it is shut down, which can occur for the following reasons:

  • Ein Benutzer schließt alle Window.A user closes every Window.

  • Ein Benutzer schließt das Haupt- Window.A user closes the main Window.

  • Der Benutzer beendet die Windows-Sitzung durch abmelden oder Herunterfahren.A user ends the Windows session by logging off or shutting down.

  • Eine anwendungsspezifische Bedingung wurde erfüllt.An application-specific condition has been met.

Können Sie zum Beenden der Anwendung verwalten Application bietet die Shutdown -Methode, die ShutdownMode -Eigenschaft, und die SessionEnding und Exit Ereignisse.To help you manage application shutdown, Application provides the Shutdown method, the ShutdownMode property, and the SessionEnding and Exit events.

Hinweis

Shutdown kann nur von Anwendungen, die aufgerufen werden UIPermission.Shutdown can only be called from applications that have UIPermission. Standalone-WPF-Anwendungen verfügen immer über diese Berechtigung.Standalone WPF applications always have this permission. Allerdings gilt dies nicht XBAPs, die in den Sicherheitssandkasten der Internetzone Sicherheit bei teilweiser Vertrauenswürdigkeit ausgeführt.However, XBAPs running in the Internet zone partial-trust security sandbox do not.

Modus für das HerunterfahrenShutdown Mode

Anwendungen werden in der Regel entweder heruntergefahren, wenn alle Fenster geschlossen werden, oder wenn das Hauptfenster geschlossen wird.Most applications shut down either when all the windows are closed or when the main window is closed. Manchmal kann jedoch auch durch andere anwendungsspezifische Bedingungen bestimmt werden, wann eine Anwendung heruntergefahren wird.Sometimes, however, other application-specific conditions may determine when an application shuts down. Sie können angeben, die Bedingungen, unter dem Ihre Anwendung heruntergefahren durch Festlegen von wird ShutdownMode mit einem der folgenden ShutdownMode -Enumerationswerte fest:You can specify the conditions under which your application will shut down by setting ShutdownMode with one of the following ShutdownMode enumeration values:

Der Standardwert von ShutdownMode ist OnLastWindowClose, d. h., die eine Anwendung automatisch heruntergefahren wird, wenn das letzte Fenster in der Anwendung vom Benutzer geschlossen wird.The default value of ShutdownMode is OnLastWindowClose, which means that an application automatically shuts down when the last window in the application is closed by the user. Aber wenn Ihre Anwendung heruntergefahren werden soll, wenn das Hauptfenster geschlossen wird, WPF automatisch ausgeführt, wenn Sie festlegen, ShutdownMode zu OnMainWindowClose.However, if your application should be shut down when the main window is closed, WPF automatically does that if you set ShutdownMode to OnMainWindowClose. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

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

Wenn Ihre Bedingungen zum Herunterfahren die anwendungsspezifische können Sie festlegen, ShutdownMode zu OnExplicitShutdown.When you have application-specific shutdown conditions, you set ShutdownMode to OnExplicitShutdown. In diesem Fall ist es Ihrer Verantwortung, eine Anwendung heruntergefahren durch explizites Aufrufen der Shutdown Methode; andernfalls, Ihre Anwendung weiterhin ausgeführt, auch wenn alle Fenster geschlossen sind.In this case, it is your responsibility to shut an application down by explicitly calling the Shutdown method; otherwise, your application will continue running even if all the windows are closed. Beachten Sie, dass Shutdown wird implizit aufgerufen, wenn die ShutdownMode ist entweder OnLastWindowClose oder OnMainWindowClose.Note that Shutdown is called implicitly when the ShutdownMode is either OnLastWindowClose or OnMainWindowClose.

Hinweis

ShutdownMode eine XBAP festgelegt werden können, aber sie wird ignoriert; eine XBAP wird immer heruntergefahren, wenn die von ihr weg navigiert wird in einem Browser oder beim Schließen des Browsers, die die XBAP hostet.ShutdownMode can be set from an XBAP, but it is ignored; an XBAP is always shut down when it is navigated away from in a browser or when the browser that hosts the XBAP is closed. Weitere Informationen finden Sie unter Übersicht über die Navigation.For more information, see Navigation Overview.

Beenden einer SitzungSession Ending

Die Bedingungen zum Herunterfahren, die beschrieben werden die ShutdownMode Eigenschaft für eine Anwendung spezifisch sind.The shutdown conditions that are described by the ShutdownMode property are specific to an application. In einigen Fällen kann eine Anwendung aber auch als Ergebnis einer externen Bedingung heruntergefahren werden.In some cases, though, an application may shut down as a result of an external condition. Die gängigste externe Bedingung tritt auf, wenn ein Benutzer die Windows-Sitzung durch die folgenden Aktionen beendet:The most common external condition occurs when a user ends the Windows session by the following actions:

  • AbmeldenLogging off

  • HerunterfahrenShutting down

  • NeustartenRestarting

  • Wechseln in den RuhezustandHibernating

Um zu erkennen, wenn eine Windows-Sitzung beendet wird, können Sie behandeln die SessionEnding Ereignis, wie im folgenden Beispiel dargestellt.To detect when a Windows session ends, you can handle the SessionEnding event, as illustrated in the following example.

<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 Microsoft.VisualBasic
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

In diesem Beispiel überprüft der Code die ReasonSessionEnding Eigenschaft, um zu bestimmen, wie die Windows-Sitzung beendet wird.In this example, the code inspects the ReasonSessionEnding property to determine how the Windows session is ending. Dieser Wert wird verwendet, um dem Benutzer eine Bestätigungsmeldung anzuzeigen.It uses this value to display a confirmation message to the user. Der Code legt fest, wenn der Benutzer nicht die Sitzung beenden möchte, Cancel zu true um zu verhindern, dass die Windows-Sitzung beendet.If the user does not want the session to end, the code sets Cancel to true to prevent the Windows session from ending.

Hinweis

SessionEnding für XBAPs wird nicht ausgelöst werden.SessionEnding is not raised for XBAPs.

SchließenExit

Beim Herunterfahren einer Anwendung werden evtl. abschließende Verarbeitungsaufgaben ausgeführt, z. B. Beibehalten des Anwendungszustands.When an application shuts down, it may need to perform some final processing, such as persisting application state. In diesen Situationen können Sie behandeln die Exit -Ereignis, als die App_Exit -Ereignishandler wird im folgenden Beispiel.For these situations, you can handle the Exit event, as the App_Exit event handler does in the following example. Es wird definiert, wie ein Ereignishandler in der "App.xaml" Datei.It is defined as an event handler in the App.xaml file. Die Implementierung wird hervorgehoben, der "App.Xaml.cs" und "Application.Xaml.vb" Dateien.Its implementation is highlighted in the App.xaml.cs and Application.xaml.vb files.

<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

Das vollständige Beispiel finden Sie unter beibehalten und Wiederherstellen mit Anwendungsbereich Eigenschaften über mehrere Anwendungssitzungen.For the complete example, see Persist and Restore Application-Scope Properties Across Application Sessions.

Exit kann von sowohl eigenständigen Anwendungen als auch XBAPs behandelt werden.Exit can be handled by both standalone applications and XBAPs. Für XBAPs Exit wird ausgelöst, wenn Sie in den folgenden Situationen:For XBAPs, Exit is raised when in the following circumstances:

  • Eine XBAP ist weg navigiert.An XBAP is navigated away from.

  • In Internet Explorer 7Internet Explorer 7, wenn die Registerkarte, die die XBAP gehostet wird geschlossen ist.In Internet Explorer 7Internet Explorer 7, when the tab that is hosting the XBAP is closed.

  • Wenn der Browser geschlossen wird.When the browser is closed.

ExitcodeExit Code

Anwendungen werden meistens durch das Betriebssystem als Reaktion auf eine Benutzeranforderung gestartet.Applications are mostly launched by the operating system in response to a user request. Eine Anwendung kann aber auch von einer anderen Anwendung gestartet werden, um eine bestimmte Aufgabe zu übernehmen.However, an application can be launched by another application to perform some specific task. Wenn die gestartete Anwendung heruntergefahren wird, muss die startende Anwendung möglicherweise über die Bedingung informiert werden, unter der die gestartete Anwendung heruntergefahren wurde.When the launched application shuts down, the launching application may want to know the condition under which the launched application shut down. In diesen Fällen kann Windows Anwendungen einen Anwendungsexitcode zurückzugeben.In these situations, Windows allows applications to return an application exit code on shutdown. Standardmäßig geben die WPF-Anwendungen Exitcodewert 0 zurück.By default, WPF applications return an exit code value of 0.

Hinweis

Beim Debuggen in Visual Studio wird ein Exitcode der Anwendung angezeigt, der Ausgabe Fenster, wenn die Anwendung in einer Meldung heruntergefahren, der folgendermaßen aussieht:When you debug from Visual Studio, the application exit code is displayed in the Output window when the application shuts down, in a message that looks like the following:

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

Öffnen Sie die Ausgabe Fenster, indem Sie auf Ausgabe auf die Ansicht Menü.You open the Output window by clicking Output on the View menu.

Um den Exitcode ändern möchten, können Sie rufen die Shutdown(Int32) überladen ist, wird ein ganzzahliges Argument zum Exitcode akzeptiert:To change the exit code, you can call the Shutdown(Int32) overload, which accepts an integer argument to be the exit code:

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

Sie können den Wert des Exitcodes ermitteln und ändern, indem die Behandlung der Exit Ereignis.You can detect the value of the exit code, and change it, by handling the Exit event. Die Exit -Ereignishandler übergeben wird ein ExitEventArgs dem ermöglicht den Zugriff auf den Exitcode mit der ApplicationExitCode Eigenschaft.The Exit event handler is passed an ExitEventArgs which provides access to the exit code with the ApplicationExitCode property. Weitere Informationen finden Sie unter Exit.For more information, see Exit.

Hinweis

Sie können den Exitcode sowohl von eigenständigen Anwendungen als auch XBAPs in festlegen.You can set the exit code in both standalone applications and XBAPs. Der Exitcodewert wird jedoch für XBAPs ignoriert.However, the exit code value is ignored for XBAPs.

Nicht behandelte AusnahmenUnhandled Exceptions

Es kommt vor, dass eine Anwendung unter nicht ordnungsgemäßen Bedingungen heruntergefahren wird, z. B. wenn eine unerwartete Ausnahme ausgelöst wird.Sometimes an application may shut down under abnormal conditions, such as when an unanticipated exception is thrown. In diesem Fall verfügt die Anwendung möglicherweise nicht über den Code, der zum Erkennen und Verarbeiten der Ausnahme erforderlich ist.In this case, the application may not have the code to detect and process the exception. Eine solche Ausnahme wird als nicht behandelte Ausnahme bezeichnet. Vor dem Schließen der Anwendung wird eine Meldung angezeigt, die der folgenden ähnelt.This type of exception is an unhandled exception; a notification similar to that shown in the following figure is displayed before the application is closed.

Screenshot mit einer Benachrichtigung über Ausnahmefehler.

Für die Benutzererfahrung ist es vorteilhafter, wenn eine Anwendung dieses Standardverhalten vermeidet. Dazu dienen mehrere oder alle der folgenden Aktionen:From the user experience perspective, it is better for an application to avoid this default behavior by doing some or all of the following:

  • Anzeigen von benutzerfreundlichen InformationenDisplaying user-friendly information.

  • Versuchen, eine Anwendung weiterhin auszuführenAttempting to keep an application running.

  • Aufzeichnen von detaillierten, entwicklerfreundlichen-Ausnahmeinformationen in die Windows-Ereignisprotokoll.Recording detailed, developer-friendly exception information in the Windows event log.

Implementierung dieser Unterstützung hängt von der nicht behandelte Ausnahmen zu erkennen, d. h. die DispatcherUnhandledException -Ereignis wird für ausgelöst.Implementing this support depends on being able to detect unhandled exceptions, which is what the DispatcherUnhandledException event is raised for.

<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

Die DispatcherUnhandledException übergebene Ereignishandler wird ein DispatcherUnhandledExceptionEventArgs Parameter, der Kontextinformationen zur nicht behandelten Ausnahme, einschließlich der Ausnahme selbst enthält (DispatcherUnhandledExceptionEventArgs.Exception).The DispatcherUnhandledException event handler is passed a DispatcherUnhandledExceptionEventArgs parameter that contains contextual information regarding the unhandled exception, including the exception itself (DispatcherUnhandledExceptionEventArgs.Exception). Sie können anhand dieser Informationen feststellen, wie die Ausnahme behandelt werden soll.You can use this information to determine how to handle the exception.

Bei der Behandlung DispatcherUnhandledException, legen Sie die DispatcherUnhandledExceptionEventArgs.Handled Eigenschaft trueist, andernfalls WPF immer noch berücksichtigt die Ausnahme unbehandelt und wird auf die zuvor beschriebene Standardverhalten zurückgesetzt.When you handle DispatcherUnhandledException, you should set the DispatcherUnhandledExceptionEventArgs.Handled property to true; otherwise, WPF still considers the exception to be unhandled and reverts to the default behavior described earlier. Wenn eine nicht behandelte Ausnahme ausgelöst wird und entweder die DispatcherUnhandledException -Ereignis nicht behandelt wird oder das Ereignis behandelt wird und Handled nastaven NA hodnotu false, die Anwendung sofort heruntergefahren.If an unhandled exception is raised and either the DispatcherUnhandledException event is not handled, or the event is handled and Handled is set to false, the application shuts down immediately. Darüber hinaus keine weiteren Application Ereignisse ausgelöst werden.Furthermore, no other Application events are raised. Folglich müssen Sie behandeln DispatcherUnhandledException , wenn Ihre Anwendung über Code, die ausgeführt werden muss verfügt, bevor die Anwendung beendet wird.Consequently, you need to handle DispatcherUnhandledException if your application has code that must run before the application shuts down.

Obwohl eine Anwendung wegen einer nicht behandelten Ausnahme heruntergefahren werden kann, erfolgt das Herunterfahren normalerweise als Reaktion auf eine Benutzeranforderung, wie im nächsten Abschnitt beschrieben.Although an application may shut down as a result of an unhandled exception, an application usually shuts down in response to a user request, as discussed in the next section.

Anwendungslebensdauer-EreignisseApplication Lifetime Events

Eigenständige Anwendungen als auch XBAPs haben nicht genau dieselbe Lebensdauer.Standalone applications and XBAPs don't have exactly the same lifetimes. Die folgende Abbildung veranschaulicht die wichtigsten Ereignisse in der Lebensdauer einer eigenständigen Anwendung und die Reihenfolge, in der sie ausgelöst werden.The following figure illustrates the key events in the lifetime of a standalone application and shows the sequence in which they are raised.

Eigenständige Anwendung - AnwendungsobjektereignisseStandalone Application - Application Object Events

Ebenso wird die folgende Abbildung veranschaulicht die wichtigsten Ereignisse in der Lebensdauer einer XBAP und zeigt die Reihenfolge, in der sie ausgelöst werden.Likewise, the following figure illustrates the key events in the lifetime of an XBAP, and shows the sequence in which they are raised.

XBAP - AnwendungsobjektereignisseXBAP - Application Object Events

Siehe auchSee also