Información general sobre la administración de aplicacionesApplication Management Overview

Todas las aplicaciones suelen compartir un conjunto común de funciones que se aplica a la implementación y la administración de la aplicación.All applications tend to share a common set of functionality that applies to application implementation and management. Este tema proporciona información general de la funcionalidad de la Application clase para crear y administrar aplicaciones.This topic provides an overview of the functionality in the Application class for creating and managing applications.

La clase ApplicationThe Application Class

En WPF, se encapsula la funcionalidad común de ámbito de la aplicación en el Application clase.In WPF, common application-scoped functionality is encapsulated in the Application class. La Application clase incluye la funcionalidad siguiente:The Application class includes the following functionality:

  • Realizar el seguimiento e interactuar con la duración de la aplicación.Tracking and interacting with application lifetime.

  • Recuperar y procesar los parámetros de la línea de comandos.Retrieving and processing command-line parameters.

  • Detectar y responder a las excepciones no controladas.Detecting and responding to unhandled exceptions.

  • Compartir propiedades y recursos en el ámbito de aplicación.Sharing application-scope properties and resources.

  • Administrar ventanas en las aplicaciones independientes.Managing windows in standalone applications.

  • Seguimiento y administración de la navegación.Tracking and managing navigation.

Cómo realizar las tareas comunes con la clase ApplicationHow to Perform Common Tasks Using the Application Class

Si no está interesado en todos los detalles de la Application (clase), en la tabla siguiente se enumera algunas de las tareas comunes para Application y cómo realizarlas.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. Viendo las API y los temas relacionados, puede buscar más información y código de ejemplo.By viewing the related API and topics, you can find more information and sample code.

TareaTask MétodoApproach
Obtener un objeto que representa la aplicación actualGet an object that represents the current application Utilice la propiedad Application.Current.Use the Application.Current property.
Agregar una pantalla de inicio a una aplicaciónAdd a startup screen to an application Consulte agregar una pantalla de presentación a una aplicación WPF.See Add a Splash Screen to a WPF Application.
Iniciar una aplicaciónStart an application Utilice el método Application.Run.Use the Application.Run method.
Detener una aplicaciónStop an application Use la Shutdown método de la Application.Current objeto.Use the Shutdown method of the Application.Current object.
Obtener los argumentos de la línea de comandosGet arguments from the command line Controlar la Application.Startup evento y utilice la StartupEventArgs.Args propiedad.Handle the Application.Startup event and use the StartupEventArgs.Args property. Para obtener un ejemplo, vea el Application.Startup eventos.For an example, see the Application.Startup event.
Obtener y establecer el código de salida de la aplicaciónGet and set the application exit code Establecer el ExitEventArgs.ApplicationExitCode propiedad en el Application.Exit controlador de eventos o llamada la Shutdown método y pasar un entero.Set the ExitEventArgs.ApplicationExitCode property in the Application.Exit event handler or call the Shutdown method and pass in an integer.
Detectar y responder a las excepciones no controladasDetect and respond to unhandled exceptions Controlar la DispatcherUnhandledException eventos.Handle the DispatcherUnhandledException event.
Obtener y establecer recursos en el ámbito de aplicaciónGet and set application-scoped resources Utilice la propiedad Application.Resources.Use the Application.Resources property.
Usar un diccionario de recursos en el ámbito de aplicaciónUse an application-scope resource dictionary Consulte usar un diccionario de recursos en el ámbito de aplicación.See Use an Application-Scope Resource Dictionary.
Obtener y establecer propiedades en el ámbito de aplicaciónGet and set application-scoped properties Utilice la propiedad Application.Properties.Use the Application.Properties property.
Obtener y guardar el estado de una aplicaciónGet and save an application's state Consulte conservar y restaurar propiedades en el ámbito de la aplicación a través de sesiones de la aplicación.See Persist and Restore Application-Scope Properties Across Application Sessions.
Administrar archivos de datos que no son de código, incluidos los archivos de recursos, los archivos de contenido y los archivos de sitio de origen.Manage non-code data files, including resource files, content files, and site-of-origin files. Consulte WPF Application Resource, contenido y los archivos de datos.See WPF Application Resource, Content, and Data Files.
Administrar ventanas en las aplicaciones independientesManage windows in standalone applications Vea WPF Windows Overview (Introducción a Windows Presentation Foundation).See WPF Windows Overview.
Realizar un seguimiento y administrar la navegaciónTrack and manage navigation Consulte información general sobre navegación.See Navigation Overview.

La definición de aplicaciónThe Application Definition

Para utilizar la funcionalidad de la Application (clase), debe implementar una definición de aplicación.To utilize the functionality of the Application class, you must implement an application definition. Una definición de aplicación de WPF es una clase que deriva de Application y está configurado con una configuración especial de MSBuild.A WPF application definition is a class that derives from Application and is configured with a special MSBuild setting.

Implementar una definición de aplicaciónImplementing an Application Definition

Una definición de aplicación WPF típica se implementa usando tanto marcado como código subyacente.A typical WPF application definition is implemented using both markup and code-behind. Esto le permite usar marcado para establecer mediante declaración propiedades, recursos y eventos de registro de la aplicación, mientras que el control de eventos y la implementación del comportamiento específico de la aplicación se realizan en el código subyacente.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.

En el ejemplo siguiente se muestra cómo implementar una definición de aplicación usando tanto marcado como código subyacente: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

Para que un archivo de marcado y un archivo de código subyacente funcionen conjuntamente, debe ocurrir lo siguiente:To allow a markup file and code-behind file to work together, the following needs to happen:

  • En el marcado, el Application elemento debe incluir el x:Class atributo.In markup, the Application element must include the x:Class attribute. Cuando se compila la aplicación, la existencia de x:Class en el marcado de archivos, MSBuild creará un partial clase que derive de Application y tiene el nombre especificado por el x:Class atributo.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. Esto requiere la adición de una declaración de espacio de nombres XML para el esquema XAML (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").

  • En el código subyacente, la clase debe ser un partial clase con el mismo nombre que se especifica mediante el x:Class de atributo en el marcado y debe derivar de 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. Esto permite que el archivo de código subyacente se asocie a la partial clase que se genera para el archivo de marcado cuando se compila la aplicación (consulte compilar una aplicación WPF).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).

Nota

Cuando se crea un nuevo proyecto de aplicación WPF o el proyecto de aplicación de explorador WPF mediante Visual Studio, una definición de aplicación se incluye de forma predeterminada y se define usando tanto marcado como código subyacente.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.

Este código es el mínimo necesario para implementar una definición de aplicación.This code is the minimum that is required to implement an application definition. Sin embargo, una configuración adicional de MSBuild debe realizarse en la definición de aplicación antes de compilar y ejecutar la aplicación.However, an additional MSBuild configuration needs to be made to the application definition before building and running the application.

Configurar la definición de aplicación para MSBuildConfiguring the Application Definition for MSBuild

Las aplicaciones independientes y aplicaciones de explorador XAML (XBAP) requieren la implementación de un cierto nivel de infraestructura para que poderse ejecutar.Standalone applications and XAML browser applications (XBAPs) require the implementation of a certain level of infrastructure before they can run. La parte más importante de esta infraestructura es el punto de entrada.The most important part of this infrastructure is the entry point. Cuando un usuario inicia una aplicación, el sistema operativo llama al punto de entrada, que es una función conocida para iniciar las aplicaciones.When an application is launched by a user, the operating system calls the entry point, which is a well-known function for starting applications.

Tradicionalmente, los desarrolladores necesitaban escribir todo o parte de este código, según la tecnología.Traditionally, developers have needed to write some or all of this code for themselves, depending on the technology. Sin embargo, WPF genera este código para cuando el archivo de marcado de la definición de aplicación se configura como un MSBuild ApplicationDefinition de elemento, como se muestra en el siguiente archivo de proyecto de MSBuild: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>  

Dado que el archivo de código subyacente contiene código, se marca como un MSBuild Compile de elemento, lo cual es normal.Because the code-behind file contains code, it is marked as an MSBuild Compile item, as is normal.

La aplicación de estas configuraciones de MSBuild para los archivos de marcado y código subyacente de una definición de aplicación hace que MSBuild generar código similar al siguiente: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

El código resultante amplía la definición de aplicación con código de infraestructura adicional, que incluye el método de punto de entrada Main.The resulting code augments your application definition with additional infrastructure code, which includes the entry-point method Main. El STAThreadAttribute atributo se aplica a la Main método para indicar que el subproceso de interfaz de usuario principal de la aplicación de WPF es un subproceso STA, que es necesario para las aplicaciones de WPF.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. Cuando se llama, Main crea una nueva instancia de App antes de llamar a la InitializeComponent método para registrar los eventos y establecer las propiedades que se implementan en el marcado.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. Dado que InitializeComponent se genera automáticamente, no es necesario llamar explícitamente a InitializeComponent desde una definición de aplicación como haría para hacer Page y Window implementaciones.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. Por último, el Run método se llama para iniciar la aplicación.Finally, the Run method is called to start the application.

Obtener la aplicación actualGetting the Current Application

Dado que la funcionalidad de la Application clase se comparten entre una aplicación, puede haber solo una instancia de la Application clase por 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. Para exigir esto, el Application clase se implementa como una clase singleton (vea Implementing Singleton in C#), que crea una única instancia de sí mismo y proporciona acceso comparten a ella con el static Current propiedad.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.

El código siguiente muestra cómo adquirir una referencia a la Application objeto actual 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 Devuelve una referencia a una instancia de la Application clase.Current returns a reference to an instance of the Application class. Si desea obtener una referencia a su Application derivados de la clase primero debe convertir el valor de la Current propiedad, como se muestra en el ejemplo siguiente.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)

Puede inspeccionar el valor de Current en cualquier momento de la duración de un Application objeto.You can inspect the value of Current at any point in the lifetime of an Application object. En cambio, se recomienda tener cuidado.However, you should be careful. Después de la Application se crea una instancia de clase, hay un período durante el cual el estado de la Application objeto es incoherente.After the Application class is instantiated, there is a period during which the state of the Application object is inconsistent. Durante este período, Application está realizando las diversas tareas de inicialización que requieren el código para ejecutar, incluido el establecimiento de la infraestructura de aplicación, establecer las propiedades y registrar los eventos.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. Si intenta usar el Application objeto durante este período, el código puede tener resultados inesperados, particularmente si depende de los distintos Application propiedades que se va a establecer.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.

Cuando Application completa su trabajo de inicialización, se inicia realmente su duración.When Application completes its initialization work, its lifetime truly begins.

Duración de la aplicaciónApplication Lifetime

La duración de una aplicación de WPF está marcada por varios eventos generados por Application para que sepa cuándo se ha iniciado la aplicación, se ha activado y desactivado y se ha cerrado.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.

Pantalla de presentaciónSplash Screen

A partir de .NET Framework 3.5 SP1, puede especificar una imagen que se usará en una ventana de inicio o pantalla de presentación.Starting in the .NET Framework 3.5 SP1, you can specify an image to be used in a startup window, or splash screen. La SplashScreen clase facilita la tarea mostrar una ventana de inicio mientras se carga la aplicación.The SplashScreen class makes it easy to display a startup window while your application is loading. El SplashScreen se crea y se muestra antes de ventana Run se llama.The SplashScreen window is created and shown before Run is called. Para obtener más información, consulte Application Startup Time y agregar una pantalla de presentación a una aplicación WPF.For more information, see Application Startup Time and Add a Splash Screen to a WPF Application.

Iniciar una aplicaciónStarting an Application

Después de Run se denomina y se inicializa la aplicación, está lista para ejecutar la aplicación.After Run is called and the application is initialized, the application is ready to run. En este momento se especifica cuando la Startup provoca el evento: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

En este momento de la duración de la aplicación, lo más común es mostrar una interfaz de usuario.At this point in an application's lifetime, the most common thing to do is to show a UI.

Mostrar una interfaz de usuarioShowing a User Interface

Abre la mayoría de las aplicaciones Windows independiente una Window cuando empieza a ejecutar.Most standalone Windows applications open a Window when they begin running. El Startup controlador de eventos es una ubicación desde la que puede hacer esto, como se muestra en el código siguiente.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

Nota

La primera Window para ejecutarse en una independiente aplicación se convierte en la ventana principal de la aplicación de forma predeterminada.The first Window to be instantiated in a standalone application becomes the main application window by default. Esto Window objeto hace referencia el Application.MainWindow propiedad.This Window object is referenced by the Application.MainWindow property. El valor de la MainWindow propiedad se puede cambiar mediante programación si una ventana diferente que el primero crea una instancia de Window debe ser la ventana principal.The value of the MainWindow property can be changed programmatically if a different window than the first instantiated Window should be the main window.

Cuando se inicia por primera vez una aplicación XBAP, probablemente se le remitirá a un Page.When an XBAP first starts, it will most likely navigate to a Page. Esto se muestra en el código siguiente.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

Si controla Startup sólo abran un Window o navegue hasta un Page, puede establecer el StartupUri atributo en el marcado en su lugar.If you handle Startup to only open a Window or navigate to a Page, you can set the StartupUri attribute in markup instead.

El ejemplo siguiente muestra cómo usar el StartupUri desde una aplicación independiente para abrir un 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" />

El ejemplo siguiente muestra cómo usar StartupUri desde una aplicación XBAP para navegar a un 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" />

Este marcado tiene el mismo efecto que el código anterior para abrir una ventana.This markup has the same effect as the previous code for opening a window.

Nota

Para obtener más información sobre la navegación, consulte información general sobre navegación.For more information on navigation, see Navigation Overview.

Tiene que controlar la Startup eventos para abrir un Window si necesita crear una instancia mediante un constructor no predeterminado, o deberá establecer sus propiedades o suscribirse a sus eventos antes de mostrarlo o necesita procesar los argumentos de línea de comandos que se han proporcionado cuando se inicia la aplicación.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.

Procesar argumentos de la línea de comandosProcessing Command-Line Arguments

En Windows, las aplicaciones independientes pueden iniciarse desde un símbolo del sistema o el escritorio.In Windows, standalone applications can be launched from either a command prompt or the desktop. En ambos casos, es posible pasar argumentos de la línea de comandos a la aplicación.In both cases, command-line arguments can be passed to the application. En el ejemplo siguiente se muestra una aplicación que se inicia con un solo argumento de la línea de comandos, "/StartMinimized":The following example shows an application that is launched with a single command-line argument, "/StartMinimized":

wpfapplication.exe /StartMinimized

Durante la inicialización de la aplicación, WPF recupera los argumentos de línea de comandos desde el sistema operativo y los pasa a la Startup controlador de eventos a través de la Args propiedad de la StartupEventArgs parámetro.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. Puede recuperar y almacenar los argumentos de la línea de comandos usando código como el siguiente.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

El código controla Startup para comprobar si el /StartMinimized se ha proporcionado un argumento de línea de comandos; si es así, se abre la ventana principal con un WindowState de 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. Tenga en cuenta que dado que la WindowState propiedad debe establecerse mediante programación, el método main Window debe abrirse explícitamente en el código.Note that because the WindowState property must be set programmatically, the main Window must be opened explicitly in code.

Las aplicaciones XBAP no se pueden recuperar y procesar los argumentos de línea de comandos porque se inician mediante la implementación de ClickOnce (consulte implementar una aplicación WPF).XBAPs cannot retrieve and process command-line arguments because they are launched using ClickOnce deployment (see Deploying a WPF Application). En cambio, pueden recuperar y procesar los parámetros de las cadenas de consulta de las direcciones URL que se usan para iniciarlas.However, they can retrieve and process query string parameters from the URLs that are used to launch them.

Activación y desactivación de aplicacionesApplication Activation and Deactivation

Windows permite a los usuarios cambiar entre las aplicaciones.Windows allows users to switch between applications. El método más común es usar la combinación de teclas ALT+TAB.The most common way is to use the ALT+TAB key combination. Una aplicación solo se puede cambiar a si tiene un visible Window que un usuario puede seleccionar.An application can only be switched to if it has a visible Window that a user can select. Actualmente seleccionado Window es el ventana activa (también conocido como el ventana de primer plano) y es el Window que recibe la entrada del usuario.The currently selected Window is the active window (also known as the foreground window) and is the Window that receives user input. La aplicación con la ventana activa es la aplicación activa (o aplicación en primer plano).The application with the active window is the active application (or foreground application). Una aplicación se convierte en la aplicación activa en las siguientes circunstancias:An application becomes the active application in the following circumstances:

  • Se inicia y muestra un Window.It is launched and shows a Window.

  • Un usuario cambia desde otra aplicación seleccionando un Window en la aplicación.A user switches from another application by selecting a Window in the application.

Puede detectar cuando se activa una aplicación controlando el Application.Activated eventos.You can detect when an application becomes active by handling the Application.Activated event.

De manera similar, una aplicación puede volverse inactiva en las circunstancias siguientes:Likewise, an application can become inactive in the following circumstances:

  • Un usuario cambia a otra aplicación desde la actual.A user switches to another application from the current one.

  • Cuando se cierra la aplicación.When the application shuts down.

Puede detectar cuando una aplicación pasa a estar inactiva controlando el Application.Deactivated eventos.You can detect when an application becomes inactive by handling the Application.Deactivated event.

El código siguiente muestra cómo controlar el Activated y Deactivated eventos para determinar si una aplicación está activa.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

Un Window también se puede activar y desactivar.A Window can also be activated and deactivated. Para obtener más información, vea Window.Activated y Window.Deactivated.See Window.Activated and Window.Deactivated for more information.

Nota

Ni Application.Activated ni Application.Deactivated se desencadena para las aplicaciones XBAP.Neither Application.Activated nor Application.Deactivated is raised for XBAPs.

Cierre de la aplicaciónApplication Shutdown

La duración de una aplicación finaliza cuando se cierra, lo cual puede ocurrir por las razones siguientes:The life of an application ends when it is shut down, which can occur for the following reasons:

  • Un usuario cierra cada Window.A user closes every Window.

  • Un usuario cierra el principal Window.A user closes the main Window.

  • Un usuario finaliza la sesión de Windows cerrando sesión o cerrando.A user ends the Windows session by logging off or shutting down.

  • Se ha cumplido una condición específica de la aplicación.An application-specific condition has been met.

Para ayudarle a administrar el cierre de la aplicación, Application proporciona el Shutdown método, el ShutdownMode propiedad y el SessionEnding y Exit eventos.To help you manage application shutdown, Application provides the Shutdown method, the ShutdownMode property, and the SessionEnding and Exit events.

Nota

Shutdown solo se puede llamar desde las aplicaciones que tienen UIPermission.Shutdown can only be called from applications that have UIPermission. Las aplicaciones de WPF Standalone siempre tienen este permiso.Standalone WPF applications always have this permission. Sin embargo, las aplicaciones XBAP que se ejecuta en el recinto de seguridad de confianza parcial de la zona de Internet no lo hacen.However, XBAPs running in the Internet zone partial-trust security sandbox do not.

Modo de apagadoShutdown Mode

La mayoría de las aplicaciones se apagan cuando se cierran todas las ventanas o cuando se cierra la ventana principal.Most applications shut down either when all the windows are closed or when the main window is closed. En ocasiones, en cambio, puede haber otras condiciones específicas de la aplicación que determinen cuándo se cierra la aplicación.Sometimes, however, other application-specific conditions may determine when an application shuts down. Puede especificar las condiciones en las que se cerrará la aplicación estableciendo ShutdownMode con uno de los siguientes ShutdownMode valores de enumeración:You can specify the conditions under which your application will shut down by setting ShutdownMode with one of the following ShutdownMode enumeration values:

El valor predeterminado de ShutdownMode es OnLastWindowClose, lo que significa que una aplicación se cierra automáticamente cuando el usuario cierra la última ventana de la aplicación.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. Sin embargo, si la aplicación debe cerrarse cuando se cierra la ventana principal, WPF lo hará automáticamente si establece ShutdownMode a 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. Esta implementación se muestra en el ejemplo siguiente.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" />

Cuando tiene condiciones de cierre específicas de la aplicación, establezca ShutdownMode a OnExplicitShutdown.When you have application-specific shutdown conditions, you set ShutdownMode to OnExplicitShutdown. En este caso, es su responsabilidad cerrar la aplicación llamando explícitamente la Shutdown método; en caso contrario, la aplicación seguirá ejecutándose aunque se cierran todas las ventanas.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. Tenga en cuenta que Shutdown se llama implícitamente cuando el ShutdownMode sea OnLastWindowClose o OnMainWindowClose.Note that Shutdown is called implicitly when the ShutdownMode is either OnLastWindowClose or OnMainWindowClose.

Nota

ShutdownMode se puede establecer desde una aplicación XBAP, pero se omite; una aplicación XBAP siempre se cierra cuando se navega fuera de ella en un explorador o cuando se cierra el explorador que hospeda la aplicación XBAP.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. Para obtener más información, consulte Información general sobre navegación.For more information, see Navigation Overview.

Fin de la sesiónSession Ending

Las condiciones de apagado que describen el ShutdownMode propiedad son específicos de una aplicación.The shutdown conditions that are described by the ShutdownMode property are specific to an application. En algunos casos, en cambio, es posible que una aplicación se cierre como resultado de una condición externa.In some cases, though, an application may shut down as a result of an external condition. La condición externa más común se produce cuando un usuario finaliza la sesión de Windows mediante las siguientes acciones:The most common external condition occurs when a user ends the Windows session by the following actions:

  • Cerrar sesiónLogging off

  • ApagarShutting down

  • ReiniciarRestarting

  • HibernarHibernating

Para detectar cuándo finaliza una sesión de Windows, puede controlar la SessionEnding eventos, como se muestra en el ejemplo siguiente.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

En este ejemplo, el código inspecciona el ReasonSessionEnding propiedad para determinar la forma en que finaliza la sesión de Windows.In this example, the code inspects the ReasonSessionEnding property to determine how the Windows session is ending. Usa este valor para mostrar un mensaje de confirmación al usuario.It uses this value to display a confirmation message to the user. Si el usuario no desea que la sesión finalice, el código establece Cancel a true para evitar que la sesión de Windows final.If the user does not want the session to end, the code sets Cancel to true to prevent the Windows session from ending.

Nota

SessionEnding no se genera para las aplicaciones XBAP.SessionEnding is not raised for XBAPs.

SalirExit

Cuando una aplicación se apaga, es posible que necesite realizar algunos últimos procesos, como conservar el estado de la aplicación.When an application shuts down, it may need to perform some final processing, such as persisting application state. Para estas situaciones, puede controlar la Exit eventos, como el App_Exit hace el controlador de eventos en el ejemplo siguiente.For these situations, you can handle the Exit event, as the App_Exit event handler does in the following example. Se define como un controlador de eventos en el App.xaml archivo.It is defined as an event handler in the App.xaml file. Su implementación está resaltada en la App.xaml.cs y Application.xaml.vb archivos.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

Para obtener un ejemplo completo, vea conservar y restaurar las propiedades de ámbito de la aplicación a través de sesiones de aplicación.For the complete example, see Persist and Restore Application-Scope Properties Across Application Sessions.

Exit puede controlar las aplicaciones independientes y las aplicaciones XBAP.Exit can be handled by both standalone applications and XBAPs. Para las aplicaciones XBAP, Exit se produce cuando se encuentra en las siguientes circunstancias:For XBAPs, Exit is raised when in the following circumstances:

  • Una aplicación XBAP se navega fuera de ella.An XBAP is navigated away from.

  • En Internet Explorer 7Internet Explorer 7, cuando se cierra la pestaña que hospeda la aplicación XBAP.In Internet Explorer 7Internet Explorer 7, when the tab that is hosting the XBAP is closed.

  • Cuando se cierra el explorador.When the browser is closed.

Código de salidaExit Code

La mayoría de las aplicaciones las inicia el sistema operativo en respuesta a una solicitud del usuario.Applications are mostly launched by the operating system in response to a user request. En cambio, una aplicación puede ser iniciada por otra aplicación para realizar alguna tarea concreta.However, an application can be launched by another application to perform some specific task. Cuando la aplicación iniciada se cierra, es posible que la aplicación que la ha iniciado quiera conocer la condición en la que se cerró la aplicación iniciada.When the launched application shuts down, the launching application may want to know the condition under which the launched application shut down. En estas situaciones, Windows permite que las aplicaciones devolver un código de salida de la aplicación en el apagado.In these situations, Windows allows applications to return an application exit code on shutdown. De forma predeterminada, las aplicaciones de WPF devolver un valor de código de salida de 0.By default, WPF applications return an exit code value of 0.

Nota

Cuando se depura desde Visual Studio, el código de salida de la aplicación se muestra en el salida ventana cuando se cierra la aplicación, en un mensaje similar a lo siguiente: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).

Abre el salida ventana haciendo salida en el vista menú.You open the Output window by clicking Output on the View menu.

Para cambiar el código de salida, puede llamar a la Shutdown(Int32) sobrecarga, que acepta un argumento entero sea el código de salida: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)

Puede detectar el valor del código de salida y cambiarlo, controlando la Exit eventos.You can detect the value of the exit code, and change it, by handling the Exit event. El Exit controlador de eventos se pasa un ExitEventArgs que proporciona acceso al código de salida con el ApplicationExitCode propiedad.The Exit event handler is passed an ExitEventArgs which provides access to the exit code with the ApplicationExitCode property. Para obtener más información, consulta Exit.For more information, see Exit.

Nota

Puede establecer el código de salida en las aplicaciones independientes y las aplicaciones XBAP.You can set the exit code in both standalone applications and XBAPs. Sin embargo, se omite el valor del código de salida para las aplicaciones XBAP.However, the exit code value is ignored for XBAPs.

Excepciones no controladasUnhandled Exceptions

A veces, puede que una aplicación se cierre en condiciones irregulares, como cuando se produce una excepción imprevista.Sometimes an application may shut down under abnormal conditions, such as when an unanticipated exception is thrown. En este caso, es posible que la aplicación no tenga el código necesario para detectar y procesar la excepción.In this case, the application may not have the code to detect and process the exception. Este tipo de excepción es una excepción no controlada; se muestra una notificación similar a la que aparece en la figura siguiente antes de que se cierre la aplicación.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.

Captura de pantalla que muestra una notificación de excepción no controlada.

Desde la perspectiva del usuario, es mejor que una aplicación evite este comportamiento predeterminado realizando todas o alguna de las siguientes acciones:From the user experience perspective, it is better for an application to avoid this default behavior by doing some or all of the following:

  • Mostrar información fácil de usar.Displaying user-friendly information.

  • Intentar mantener la aplicación en funcionamiento.Attempting to keep an application running.

  • Grabación detallada, información de excepción sencillo para los desarrolladores en el registro de eventos de Windows.Recording detailed, developer-friendly exception information in the Windows event log.

Implementación de esta compatibilidad depende de poder detectar las excepciones no controladas, que es lo que el DispatcherUnhandledException evento se desencadena para.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

El DispatcherUnhandledException controlador de eventos se pasa un DispatcherUnhandledExceptionEventArgs parámetro que contiene información contextual referente a la excepción no controlada, incluida la propia excepción (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). Puede usar esta información para determinar cómo debe controlar la excepción.You can use this information to determine how to handle the exception.

Cuando controle DispatcherUnhandledException, debe establecer el DispatcherUnhandledExceptionEventArgs.Handled propiedad true; en caso contrario, WPF aún considera que la excepción no controlada y se revierte al comportamiento predeterminado se ha descrito anteriormente.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. Si se produce una excepción no controlada y la DispatcherUnhandledException no se controla el evento o se controla el evento y Handled está establecido en false, la aplicación se cierra inmediatamente.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. Además, ninguna otra Application se generan eventos.Furthermore, no other Application events are raised. Por lo tanto, tiene que controlar DispatcherUnhandledException si la aplicación tiene código que deba ejecutarse antes de que se cierra la aplicación.Consequently, you need to handle DispatcherUnhandledException if your application has code that must run before the application shuts down.

Aunque es posible que una aplicación se cierre como resultado de una excepción no controlada, las aplicaciones suelen cerrarse en respuesta a una solicitud del usuario, tal como se explica en la sección siguiente.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.

Eventos de duración de la aplicaciónApplication Lifetime Events

Las aplicaciones independientes y las aplicaciones XBAP no tienen exactamente la misma duración.Standalone applications and XBAPs don't have exactly the same lifetimes. En la ilustración siguiente se muestran los eventos clave en la duración de una aplicación independiente y la secuencia en la que se generan.The following figure illustrates the key events in the lifetime of a standalone application and shows the sequence in which they are raised.

Aplicación independiente - Eventos de objeto de la aplicaciónStandalone Application - Application Object Events

Del mismo modo, la siguiente ilustración muestra los eventos claves en la duración de una aplicación XBAP y muestra la secuencia en la que se generan.Likewise, the following figure illustrates the key events in the lifetime of an XBAP, and shows the sequence in which they are raised.

XBAP - Eventos de objeto de la aplicaciónXBAP - Application Object Events

Vea tambiénSee also