Información general sobre ventanas de WPFWPF Windows Overview

Los usuarios interactúan con las aplicaciones independientes de Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) por medio de ventanas.Users interact with Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) standalone applications through windows. El propósito principal de una ventana es hospedar contenido que permita visualizar datos y que permita a los usuarios interactuar con estos.The primary purpose of a window is to host content that visualizes data and enables users to interact with data. Independiente WPFWPF aplicaciones proporcionan sus propias ventanas mediante la Window clase.Standalone WPFWPF applications provide their own windows by using the Window class. Este tema se presentan Window antes de tratar los conceptos básicos de creación y administración de windows en las aplicaciones independientes.This topic introduces Window before covering the fundamentals of creating and managing windows in standalone applications.

Nota

Hospedadas en explorador WPFWPF aplicaciones, incluidos Aplicaciones del explorador XAML (XBAPs)XAML browser applications (XBAPs) y malas Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) páginas, no proporcionan sus propias ventanas.Browser-hosted WPFWPF applications, including Aplicaciones del explorador XAML (XBAPs)XAML browser applications (XBAPs) and loose Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) pages, don't provide their own windows. En su lugar, se hospedan en ventanas proporcionadas por Windows Internet ExplorerWindows Internet Explorer.Instead, they are hosted in windows provided by Windows Internet ExplorerWindows Internet Explorer. Vea información general de las aplicaciones de explorador XAML de WPF.See WPF XAML Browser Applications Overview.

Clase de la ventanaThe Window Class

La ilustración siguiente muestra las partes constituyentes de una ventana.The following figure illustrates the constituent parts of a window.

Elementos de la ventanaWindow elements

Una ventana se divide en dos áreas: el área distinta del cliente y el área cliente.A window is divided into two areas: the non-client area and client area.

El área no cliente de una ventana se implementa mediante WPFWPF e incluye las partes de una ventana que son comunes a la mayoría de las ventanas, incluidos los siguientes:The non-client area of a window is implemented by WPFWPF and includes the parts of a window that are common to most windows, including the following:

  • Un borde.A border.

  • Una barra de título.A title bar.

  • Un icono.An icon.

  • Botones Minimizar, Maximizar y Restaurar.Minimize, Maximize, and Restore buttons.

  • Un botón Cerrar.A Close button.

  • Un menú de sistema con elementos de menú que permiten a los usuarios minimizar, maximizar, restaurar, mover, cambiar el tamaño y cerrar una ventana.A System menu with menu items that allow users to minimize, maximize, restore, move, resize, and close a window.

El área cliente de una ventana es el área dentro del área no cliente de una ventana y lo utilizan los desarrolladores para agregar contenido específico de la aplicación, como barras de menús, barras de herramientas y controles.The client area of a window is the area within a window's non-client area and is used by developers to add application-specific content, such as menu bars, tool bars, and controls.

En WPFWPF, una ventana es encapsulada por el Window clase que usa para hacer lo siguiente:In WPFWPF, a window is encapsulated by the Window class that you use to do the following:

  • Mostrar una ventana.Display a window.

  • Configurar el tamaño, posición y aspecto de una ventana.Configure the size, position, and appearance of a window.

  • Hospedar contenido específico de la aplicación.Host application-specific content.

  • Administrar la duración de una ventana.Manage the lifetime of a window.

Implementar una ventanaImplementing a Window

La implementación de una ventana típica consta de apariencia y comportamiento, donde apariencia define el aspecto de una ventana para usuarios y comportamiento define la forma en que las funciones de una ventana cuando los usuarios interactúan con él.The implementation of a typical window comprises both appearance and behavior, where appearance defines how a window looks to users and behavior defines the way a window functions as users interact with it. En WPFWPF, puede implementar la apariencia y comportamiento de una ventana con codificar o XAMLXAML marcado.In WPFWPF, you can implement the appearance and behavior of a window using either code or XAMLXAML markup.

En general, sin embargo, la apariencia de una ventana se implementa mediante XAMLXAML marcado y su comportamiento se implementa mediante código subyacente, como se muestra en el ejemplo siguiente.In general, however, the appearance of a window is implemented using XAMLXAML markup, and its behavior is implemented using code-behind, as shown in the following example.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  
  <!-- Client area (for content) -->
  
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }
    }
}

Imports System.Windows

Namespace SDKSample
	Partial Public Class MarkupAndCodeBehindWindow
		Inherits Window
		Public Sub New()
			InitializeComponent()
		End Sub
	End Class
End Namespace

Para habilitar un XAMLXAML archivo de marcado y el archivo de código subyacente para trabajar conjuntamente, se necesita lo siguiente:To enable a XAMLXAML markup file and code-behind file to work together, the following are required:

  • En el marcado, el Window elemento debe incluir el x:Class atributo.In markup, the Window element must include the x:Class attribute. Cuando se compila la aplicación, la existencia de x:Class en el marcado hace archivo Microsoft build engine (MSBuild)Microsoft build engine (MSBuild) para crear un partial clase que deriva de Window 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 Microsoft build engine (MSBuild)Microsoft build engine (MSBuild) to create a partial class that derives from Window and has the name that is specified by the x:Class attribute. Esto requiere la adición de un XMLXML declaración de espacio de nombres para el XAMLXAML esquema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ).This requires the addition of an XMLXML namespace declaration for the XAMLXAML schema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Generado partial la clase implementa la InitializeComponent método, que se llama para registrar los eventos y establecer las propiedades que se implementan en el marcado.The generated partial class implements the InitializeComponent method, which is called to register the events and set the properties that are implemented in markup.

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

  • En el código subyacente, el Window clase debe implementar un constructor que llama el InitializeComponent método.In code-behind, the Window class must implement a constructor that calls the InitializeComponent method. InitializeComponent se implementa mediante el marcado generado de archivo partial clase para registrar eventos y establecer las propiedades que se definen en el marcado.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Nota

Cuando se agrega un nuevo Window al proyecto mediante el uso de Microsoft Visual StudioMicrosoft Visual Studio, el Window se implementa mediante marcado y código subyacente e incluye la configuración necesaria para crear la asociación entre los archivos de código subyacente y marcado como se describe aquí.When you add a new Window to your project by using Microsoft Visual StudioMicrosoft Visual Studio, the Window is implemented using both markup and code-behind, and includes the necessary configuration to create the association between the markup and code-behind files as described here.

Con esta configuración en su lugar, puede centrarse en definir el aspecto de la ventana de XAMLXAML marcado e implementar su comportamiento en el código subyacente.With this configuration in place, you can focus on defining the appearance of the window in XAMLXAML markup and implementing its behavior in code-behind. En el ejemplo siguiente se muestra una ventana con un botón, implementado en XAMLXAML marcado y un controlador de eventos para el botón Click evento, implementado en código subyacente.The following example shows a window with a button, implemented in XAMLXAML markup, and an event handler for the button's Click event, implemented in code-behind.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  <!-- Client area (for content) -->
  <Button Click="button_Click">Click This Button</Button>
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Imports System.Windows

Namespace SDKSample
	Partial Public Class MarkupAndCodeBehindWindow
		Inherits Window
		Public Sub New()
			InitializeComponent()
		End Sub

		Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
			MessageBox.Show("Button was clicked.")
		End Sub
	End Class
End Namespace

Configuración de una definición de ventana para MSBuildConfiguring a Window Definition for MSBuild

Cómo implementar la ventana determina cómo está configurada para MSBuildMSBuild.How you implement your window determines how it is configured for MSBuildMSBuild. Para una ventana que se define utilizando tanto XAMLXAML marcado y código subyacente:For a window that is defined using both XAMLXAML markup and code-behind:

  • XAMLXAML archivos de marcado se configuran como MSBuildMSBuild Page elementos. markup files are configured as MSBuildMSBuildPage items.

  • Archivos de código subyacente se configuran como MSBuildMSBuild Compile elementos.Code-behind files are configured as MSBuildMSBuildCompile items.

Esto se muestra en la siguiente MSBuildMSBuild archivo de proyecto.This is shown in the following MSBuildMSBuild project file.

<Project ...  
                xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
    ...  
    <Page Include="MarkupAndCodeBehindWindow.xaml" />  
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />  
    ...  
</Project>  

Para obtener información sobre la compilación WPFWPF las aplicaciones, vea compilar una aplicación de WPF.For information about building WPFWPF applications, see Building a WPF Application.

Duración de ventanaWindow Lifetime

Como cualquier clase, una ventana tiene una vigencia que comienza cuando se crea una instancia por primera vez, después de lo cual se abre, activa y desactiva y, finalmente, se cierra.As with any class, a window has a lifetime that begins when it is first instantiated, after which it is opened, activated and deactivated, and eventually closed.

Abrir una ventanaOpening a Window

Para abrir una ventana, primero hay que crear una instancia de esta, como se muestra en el ejemplo siguiente.To open a window, you first create an instance of it, which is demonstrated 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"
    Startup="app_Startup">
</Application>
using System.Windows;
namespace SDKSample
{
    public partial class App : Application
    {
        void app_Startup(object sender, StartupEventArgs e)
        {
            // Create a window
            MarkupAndCodeBehindWindow window = new MarkupAndCodeBehindWindow();

            // Open a window
            window.Show();
        }
    }
}

En este ejemplo, el MarkupAndCodeBehindWindow se crea una instancia cuando se inicia la aplicación, que se produce cuando el Startup evento se desencadena.In this example, the MarkupAndCodeBehindWindow is instantiated when the application starts, which occurs when the Startup event is raised.

Cuando se crea una instancia de una ventana, automáticamente se agrega una referencia a él a una lista de windows que administra el Application objeto (consulte Application.Windows).When a window is instantiated, a reference to it is automatically added to a list of windows that is managed by the Application object (see Application.Windows). Además, la primera ventana que se creará una instancia, de forma predeterminada, establece Application como la ventana de la aplicación principal (vea Application.MainWindow).Additionally, the first window to be instantiated is, by default, set by Application as the main application window (see Application.MainWindow).

Por último, se abre la ventana mediante una llamada a la Show método; el resultado se muestra en la ilustración siguiente.The window is finally opened by calling the Show method; the result is shown in the following figure.

Ventana abierta mediante una llamada a Window.ShowA Window Opened by Calling Window.Show

Una ventana que se abre mediante una llamada a Show es una ventana no modal, lo que significa que la aplicación funciona en un modo que permite a los usuarios activar otras ventanas en la misma aplicación.A window that is opened by calling Show is a modeless window, which means that the application operates in a mode that allows users to activate other windows in the same application.

Nota

ShowDialog se llama para abrir ventanas como cuadros de diálogo de forma modal.ShowDialog is called to open windows such as dialog boxes modally. Vea información general de cuadros de diálogo para obtener más información.See Dialog Boxes Overview for more information.

Cuando Show es llama, una ventana realiza trabajo de inicialización antes de que se muestra para establecer una infraestructura que le permite recibir proporcionados por el usuario.When Show is called, a window performs initialization work before it is shown to establish infrastructure that allows it to receive user input. Cuando se inicializa la ventana, el SourceInitialized se genera el evento y se muestra la ventana.When the window is initialized, the SourceInitialized event is raised and the window is shown.

Como método abreviado, StartupUri se puede establecer para especificar la primera ventana que se abre automáticamente cuando se inicia una aplicación.As a shortcut, StartupUri can be set to specify the first window that is opened automatically when an application starts.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="PlainWindow.xaml" />

Cuando se inicia la aplicación, la ventana especificada por el valor de StartupUri se abre forma no modal; internamente, la ventana se abre mediante una llamada a su Show método.When the application starts, the window specified by the value of StartupUri is opened modelessly; internally, the window is opened by calling its Show method.

Propiedad de la ventanaWindow Ownership

Una ventana que se abre mediante el Show método no tiene una relación implícita con la ventana que lo creó; los usuarios pueden interactuar con cualquier ventana independientemente de la otra, lo que significa que cualquier ventana puede hacer lo siguiente:A window that is opened by using the Show method does not have an implicit relationship with the window that created it; users can interact with either window independently of the other, which means that either window can do the following:

  • Cubrir las demás (a menos que una de las ventanas tenga su Topmost propiedad establecida en true).Cover the other (unless one of the windows has its Topmost property set to true).

  • Minimizarse, maximizarse y restaurarse sin que afecte a las demás.Be minimized, maximized, and restored without affecting the other.

Algunas ventanas requieren una relación con la ventana que las abre.Some windows require a relationship with the window that opens them. Por ejemplo, un Entorno de desarrollo integrado (IDE)Integrated Development Environment (IDE) aplicación puede abrir ventanas de propiedades y las ventanas de herramientas cuyo comportamiento típico es cubrir la ventana que las crea.For example, an Entorno de desarrollo integrado (IDE)Integrated Development Environment (IDE) application may open property windows and tool windows whose typical behavior is to cover the window that creates them. Además, dichas ventanas se deben siempre cerrar, minimizar, maximizar y restaurar de acuerdo con la ventana que las creó.Furthermore, such windows should always close, minimize, maximize, and restore in concert with the window that created them. Este tipo de relación se puede establecer mediante la realización de una ventana propio otro y se logra estableciendo la Owner propiedad de la propiedad de la ventana con una referencia a la propietario ventana.Such a relationship can be established by making one window own another, and is achieved by setting the Owner property of the owned window with a reference to the owner window. Esta implementación se muestra en el ejemplo siguiente.This is shown in the following example.

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();
' Create a window and make this window its owner
Dim ownedWindow As New Window()
ownedWindow.Owner = Me
ownedWindow.Show()

Una vez establecida la propiedad:After ownership is established:

  • La ventana de propiedad puede hacer referencia a su ventana propietaria inspeccionando el valor de su Owner propiedad.The owned window can reference its owner window by inspecting the value of its Owner property.

  • La ventana propietaria puede detectar todas las ventanas que posee inspeccionando el valor de su OwnedWindows propiedad.The owner window can discover all the windows it owns by inspecting the value of its OwnedWindows property.

Prevención de la activación de ventanasPreventing Window Activation

Existen escenarios donde windows no deben activarse si se muestran como ventanas de conversación de una aplicación de estilo de mensajería de Internet o ventanas de notificación de una aplicación de correo electrónico.There are scenarios where windows should not be activated when shown, such as conversation windows of an Internet messenger-style application or notification windows of an email application.

Si la aplicación tiene una ventana que no debería activarse cuando se muestra, puede establecer su ShowActivated propiedad false antes de llamar a la Show método por primera vez.If your application has a window that shouldn't be activated when shown, you can set its ShowActivated property to false before calling the Show method for the first time. Como resultado:As a consequence:

  • La ventana no está activada.The window is not activated.

  • La ventana Activated no se produce el evento.The window's Activated event is not raised.

  • La ventana actualmente activada permanece activada.The currently activated window remains activated.

Sin embargo, la ventana se activará tan pronto como el usuario la active haciendo clic en el área de cliente o en el área distinta del cliente.The window will become activated, however, as soon as the user activates it by clicking either the client or non-client area. En este caso:In this case:

  • La ventana se activa.The window is activated.

  • La ventana Activated evento se desencadena.The window's Activated event is raised.

  • La ventana activada previamente se desactiva.The previously activated window is deactivated.

  • La ventana Deactivated y Activated posteriormente se generan eventos según lo previsto en respuesta a las acciones del usuario.The window's Deactivated and Activated events are subsequently raised as expected in response to user actions.

Activación de ventanasWindow Activation

Cuando se abre una ventana por primera vez, se convierte en la ventana activa (a menos que se muestra con ShowActivated establecido en false).When a window is first opened, it becomes the active window (unless it is shown with ShowActivated set to false). El ventana activa es la ventana que está capturando los proporcionados por el usuario, como las pulsaciones de teclas y los clics del mouse.The active window is the window that is currently capturing user input, such as key strokes and mouse clicks. Cuando se convierte en una ventana activa, se produce la Activated eventos.When a window becomes active, it raises the Activated event.

Nota

Cuando se abre una ventana por primera vez, el Loaded y ContentRendered se generan eventos sólo después el Activated evento se desencadena.When a window is first opened, the Loaded and ContentRendered events are raised only after the Activated event is raised. Con esto en mente, una ventana de forma eficaz se puede considerar abierto cuando ContentRendered se genera.With this in mind, a window can effectively be considered opened when ContentRendered is raised.

Después de que se activa una ventana, un usuario puede activar otra ventana de la misma aplicación o activar otra aplicación.After a window becomes active, a user can activate another window in the same application, or activate another application. Cuando esto ocurre, la ventana actualmente activa se convierte en desactivado y genera el Deactivated eventos.When that happens, the currently active window becomes deactivated and raises the Deactivated event. Del mismo modo, cuando el usuario selecciona una ventana actualmente desactivada, la ventana se vuelve activa y Activated se genera.Likewise, when the user selects a currently deactivated window, the window becomes active again and Activated is raised.

Un motivo habitual para controlar Activated y Deactivated es habilitar y deshabilitar la funcionalidad que se puede ejecutar sólo cuando una ventana está activa.One common reason to handle Activated and Deactivated is to enable and disable functionality that can only run when a window is active. Por ejemplo, algunas ventanas muestran contenido interactivo que requiere la entrada o atención del usuario constante, incluidos los reproductores de vídeo y los juegos.For example, some windows display interactive content that requires constant user input or attention, including games and video players. El ejemplo siguiente es un Reproductor de vídeo simplificado que muestra cómo controlar Activated y Deactivated para implementar este comportamiento.The following example is a simplified video player that demonstrates how to handle Activated and Deactivated to implement this behavior.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CustomMediaPlayerWindow"
    Activated="window_Activated"
    Deactivated="window_Deactivated">

    <!-- Media Player -->
    <MediaElement 
      Name="mediaElement" 
      Stretch="Fill" 
      LoadedBehavior="Manual" 
      Source="numbers.wmv" />

</Window>
using System;
using System.Windows;

namespace SDKSample
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow()
        {
            InitializeComponent();
        }

        void window_Activated(object sender, EventArgs e)
        {
            // Recommence playing media if window is activated
            this.mediaElement.Play();
        }

        void window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            this.mediaElement.Pause();
        }
    }
}

Imports System
Imports System.Windows

Namespace SDKSample
	Partial Public Class CustomMediaPlayerWindow
		Inherits Window
		Public Sub New()
			InitializeComponent()
		End Sub

		Private Sub window_Activated(ByVal sender As Object, ByVal e As EventArgs)
			' Recommence playing media if window is activated
			Me.mediaElement.Play()
		End Sub

		Private Sub window_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
			' Pause playing if media is being played and window is deactivated
			Me.mediaElement.Pause()
		End Sub
	End Class
End Namespace

Cuando se desactiva una ventana, otros tipos de aplicaciones pueden ejecutar código en segundo plano.Other types of applications may still run code in the background when a window is deactivated. Por ejemplo, un cliente de correo puede continuar sondeando el servidor de correo electrónico mientras el usuario está utilizando otras aplicaciones.For example, a mail client may continue polling the mail server while the user is using other applications. Las aplicaciones como estas suelen ofrecen un comportamiento diferente o adicional mientras la ventana principal está desactivada.Applications like these often provide different or additional behavior while the main window is deactivated. Con respecto al programa de correo electrónico, esto puede significar agregar el nuevo elemento de correo a la bandeja de entrada o agregar un icono de notificación a la bandeja del sistema.With respect to the mail program, this may mean both adding the new mail item to the inbox and adding a notification icon to the system tray. Solamente es necesario mostrar un icono de notificación cuando la ventana de correo electrónico no está activo, que se puede determinar mediante la inspección del IsActive propiedad.A notification icon need only be displayed when the mail window isn't active, which can be determined by inspecting the IsActive property.

Si se completa una tarea en segundo plano, una ventana que desee notificar al usuario más urgente mediante una llamada a Activate método.If a background task completes, a window may want to notify the user more urgently by calling Activate method. Si el usuario está interactuando con otra aplicación activada cuando Activate se llama, parpadeará el botón de barra de tareas de la ventana.If the user is interacting with another application activated when Activate is called, the window's taskbar button flashes. Si un usuario está interactuando con la aplicación actual, la llamada a Activate aparecerá la ventana a primer plano.If a user is interacting with the current application, calling Activate will bring the window to the foreground.

Nota

Puede administrar la activación del ámbito de la aplicación utilizando la Application.Activated y Application.Deactivated eventos.You can handle application-scope activation using the Application.Activated and Application.Deactivated events.

Cerrar una ventanaClosing a Window

La vigencia de una ventana llega a su fin cuando un usuario la cierra.The life of a window starts coming to an end when a user closes it. Se puede cerrar una ventana mediante elementos del área distinta del cliente, entre los que cabe incluir los siguientes:A window can be closed by using elements in the non-client area, including the following:

  • El cerrar elemento de la System menú.The Close item of the System menu.

  • Presionar ALT+F4.Pressing ALT+F4.

  • Al presionar la cerrar botón.Pressing the Close button.

Puede proporcionar mecanismos adicionales al área cliente para cerrar una ventana. Entre los más habituales se incluyen los siguientes:You can provide additional mechanisms to the client area to close a window, the more common of which include the following:

  • Un Exit de elemento en el archivo menú, normalmente para ventanas de la aplicación principal.An Exit item in the File menu, typically for main application windows.

  • A cerrar de elemento en el archivo menú, normalmente en una ventana secundaria de la aplicación.A Close item in the File menu, typically on a secondary application window.

  • A cancelar botón, normalmente en un cuadro de diálogo modal.A Cancel button, typically on a modal dialog box.

  • A cerrar botón, normalmente en un cuadro de diálogo no modal.A Close button, typically on a modeless dialog box.

Para cerrar una ventana en respuesta a uno de estos mecanismos personalizados, debe llamar a la Close método.To close a window in response to one of these custom mechanisms, you need to call the Close method. En el ejemplo siguiente se implementa la capacidad de cerrar una ventana eligiendo la Exit en el archivo menú.The following example implements the ability to close a window by choosing the Exit on the File menu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.WindowWithFileExit">
  
  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>
  
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class WindowWithFileExit : System.Windows.Window
    {
        public WindowWithFileExit()
        {
            InitializeComponent();
        }

        void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close this window
            this.Close();
        }
    }
}

Imports System.Windows

Namespace SDKSample
	Partial Public Class WindowWithFileExit
		Inherits System.Windows.Window
		Public Sub New()
			InitializeComponent()
		End Sub

		Private Sub fileExitMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
			' Close this window
			Me.Close()
		End Sub
	End Class
End Namespace

Cuando se cierra una ventana, genera dos eventos: Closing y Closed.When a window closes, it raises two events: Closing and Closed.

Closing se produce antes de que se cierra la ventana y proporciona un mecanismo de qué ventana se puede evitar la cierre.Closing is raised before the window closes, and it provides a mechanism by which window closure can be prevented. Una razón común para evitar el cierre de la ventana se produce en caso de que el contenido de la ventana contenga datos modificados.One common reason to prevent window closure is if window content contains modified data. En esta situación, el Closing se puede controlar el evento para determinar si los datos están desfasadas y, si es así, para preguntar al usuario si desea continuar cerrando la ventana sin guardar los datos o cancelar el cierre de la ventana.In this situation, the Closing event can be handled to determine whether data is dirty and, if so, to ask the user whether to either continue closing the window without saving the data or to cancel window closure. En el ejemplo siguiente se muestra los aspectos clave del control Closing.The following example shows the key aspects of handling Closing.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;

        public DataWindow()
        {
            InitializeComponent();
        }

        void documentTextBox_TextChanged(object sender, EventArgs e)
        {
            this.isDataDirty = true;
        }

        void DataWindow_Closing(object sender, CancelEventArgs e)
        {
            MessageBox.Show("Closing called");

            // If data is dirty, notify user and ask for a response
            if (this.isDataDirty)
            {
                string msg = "Data is dirty. Close without saving?";
                MessageBoxResult result = 
                  MessageBox.Show(
                    msg, 
                    "Data App", 
                    MessageBoxButton.YesNo, 
                    MessageBoxImage.Warning);
                if (result == MessageBoxResult.No)
                {
                    // If user doesn't want to close, cancel closure
                    e.Cancel = true;
                }
            }
        }
    }
}
Imports System ' EventArgs
Imports System.ComponentModel ' CancelEventArgs
Imports System.Windows ' window

Namespace VisualBasic
    Partial Public Class DataWindow
        Inherits Window
        ' Is data dirty
        Private isDataDirty As Boolean = False

        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub documentTextBox_TextChanged(ByVal sender As Object, ByVal e As EventArgs)
            Me.isDataDirty = True
        End Sub

        Private Sub DataWindow_Closing(ByVal sender As Object, ByVal e As CancelEventArgs)
            MessageBox.Show("Closing called")

            ' If data is dirty, notify user and ask for a response
            If Me.isDataDirty Then
                Dim msg As String = "Data is dirty. Close without saving?"
                Dim result As MessageBoxResult = MessageBox.Show(msg, "Data App", MessageBoxButton.YesNo, MessageBoxImage.Warning)
                If result = MessageBoxResult.No Then
                    ' If user doesn't want to close, cancel closure
                    e.Cancel = True
                End If
            End If
        End Sub
    End Class
End Namespace

El Closing controlador de eventos se pasa un CancelEventArgs, que implementa el Boolean Cancel propiedad que se establece en true para impedir que se cierre una ventana.The Closing event handler is passed a CancelEventArgs, which implements the BooleanCancel property that you set to true to prevent a window from closing.

Si Closing no está controlado, o se administra pero no cancela, la ventana se cerrará.If Closing is not handled, or it is handled but not canceled, the window will close. Justo antes de que realmente se cierra una ventana, Closed se genera.Just before a window actually closes, Closed is raised. En este momento, ya no se puede impedir el cierre de la ventana.At this point, a window cannot be prevented from closing.

Nota

Una aplicación puede configurarse para apagar automáticamente cuando se cierra la ventana de aplicación principal (vea MainWindow) o se cierra la última ventana.An application can be configured to shut down automatically when either the main application window closes (see MainWindow) or the last window closes. Para obtener información detallada, vea ShutdownMode.For details, see ShutdownMode.

Mientras que una ventana se puede cerrar explícitamente a través de los mecanismos proporcionados en las áreas de cliente y no cliente, una ventana también se puede cerrar implícitamente como resultado un comportamiento en otras partes de la aplicación o WindowsWindows, incluidos los siguientes:While a window can be explicitly closed through mechanisms provided in the non-client and client areas, a window can also be implicitly closed as a result of behavior in other parts of the application or WindowsWindows, including the following:

Nota

No se puede volver a abrir una ventana cuando se ha cerrado.A window cannot be reopened after it is closed.

Eventos de vigencia de ventanasWindow Lifetime Events

La ilustración siguiente muestra la secuencia de eventos principales en la vigencia de una ventana.The following illustration shows the sequence of the principal events in the lifetime of a window.

Window LifetimeWindow Lifetime

En la siguiente ilustración muestra la secuencia de eventos principales en la duración de una ventana que se muestra sin activación (ShowActivated está establecido en false antes de que se muestra la ventana).The following illustration shows the sequence of the principal events in the lifetime of a window that is shown without activation (ShowActivated is set to false before the window is shown).

Window Lifetime (Window.ShowActivated = False)Window Lifetime (Window.ShowActivated = False)

Ubicación de la ventanaWindow Location

Mientras una ventana está abierta, tiene una ubicación en las dimensiones x e y en relación con el escritorio.While a window is open, it has a location in the x and y dimensions relative to the desktop. Esta ubicación puede determinarse inspeccionando la Left y Top propiedades, respectivamente.This location can be determined by inspecting the Left and Top properties, respectively. Puede establecer estas propiedades para cambiar la ubicación de la ventana.You can set these properties to change the location of the window.

También puede especificar la ubicación inicial de un Window cuando aparece por primera vez estableciendo la WindowStartupLocation propiedad con uno de los siguientes WindowStartupLocation valores de enumeración:You can also specify the initial location of a Window when it first appears by setting the WindowStartupLocation property with one of the following WindowStartupLocation enumeration values:

Si se especifica la ubicación de inicio como Manualy el Left y Top no se han establecido propiedades, Window le preguntará WindowsWindows aparecen en una ubicación.If the startup location is specified as Manual, and the Left and Top properties have not been set, Window will ask WindowsWindows for a location to appear in.

Ventanas de nivel superior y orden ZTopmost Windows and Z-Order

Además de tener una ubicación x e y, una ventana también tiene una ubicación en la dimensión z, que determina su posición vertical con respecto a otras ventanas.Besides having an x and y location, a window also has a location in the z dimension, which determines its vertical position with respect to other windows. Esto se conoce como el orden z de la ventana y hay dos tipos: orden z normal y orden z superior.This is known as the window's z-order, and there are two types: normal z-order and topmost z-order. La ubicación de una ventana en la orden z normal se determina por si está actualmente activa o no.The location of a window in the normal z-order is determined by whether it is currently active or not. De forma predeterminada, una ventana se encuentra en el orden z normal.By default, a window is located in the normal z-order. La ubicación de una ventana en la orden z superior también se determina por si está actualmente activa o no.The location of a window in the topmost z-order is also determined by whether it is currently active or not. Además, las ventanas del orden z superior siempre se encuentran por encima de aquellas del orden z normal.Furthermore, windows in the topmost z-order are always located above windows in the normal z-order. Una ventana se encuentra en el orden z superior estableciendo su Topmost propiedad true.A window is located in the topmost z-order by setting its Topmost property to true.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Topmost="True">
</Window>

Dentro de cada orden z, la ventana actualmente activa aparece encima de las demás ventanas del mismo orden z.Within each z-order, the currently active window appears above all other windows in the same z-order.

Tamaño de ventanaWindow Size

Además de tener una ubicación en el escritorio, una ventana tiene un tamaño determinado por varias propiedades, incluidas las distintas propiedades de ancho y alto y SizeToContent.Besides having a desktop location, a window has a size that is determined by several properties, including the various width and height properties and SizeToContent.

MinWidth, Width, y MaxWidth se utilizan para administrar el intervalo de anchos una ventana puede tener durante su duración y que están configuradas tal como se muestra en el ejemplo siguiente.MinWidth, Width, and MaxWidth are used to manage the range of widths that a window can have during its lifetime, and are configured as shown in the following example.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">
</Window>

Alto de la ventana está administrado por MinHeight, Height, y MaxHeighty están configuradas tal como se muestra en el ejemplo siguiente.Window height is managed by MinHeight, Height, and MaxHeight, and are configured as shown in the following example.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">
</Window>

Dado que los distintos valores de anchura y altura especifican cada uno de ellos un intervalo, es posible que la anchura y altura de una ventana de tamaño ajustable se encuentre dentro del intervalo especificado para la dimensión correspondiente.Because the various width values and height values each specify a range, it is possible for the width and height of a resizable window to be anywhere within the specified range for the respective dimension. Para detectar su ancho y alto actuales, inspeccione ActualWidth y ActualHeight, respectivamente.To detect its current width and height, inspect ActualWidth and ActualHeight, respectively.

Si desea que el ancho y alto de la ventana para tener un tamaño que se ajuste al tamaño de la ventana del contenido, puede usar el SizeToContent propiedad, que tiene los siguientes valores:If you'd like the width and height of your window to have a size that fits to the size of the window's content, you can use the SizeToContent property, which has the following values:

  • Manual.Manual. Ningún efecto (valor predeterminado).No effect (default).

  • Width.Width. Ajustar al ancho del contenido, que tiene el mismo efecto que establecer ambos MinWidth y MaxWidth el ancho del contenido.Fit to content width, which has the same effect as setting both MinWidth and MaxWidth to the width of the content.

  • Height.Height. Ajustar al alto del contenido, que tiene el mismo efecto que establecer ambos MinHeight y MaxHeight el alto del contenido.Fit to content height, which has the same effect as setting both MinHeight and MaxHeight to the height of the content.

  • WidthAndHeight.WidthAndHeight. Ajustar al ancho del contenido y el alto, que tiene el mismo efecto que establecer ambos MinHeight y MaxHeight el alto del contenido y configuración de ambos MinWidth y MaxWidth el ancho del contenido.Fit to content width and height, which has the same effect as setting both MinHeight and MaxHeight to the height of the content, and setting both MinWidth and MaxWidth to the width of the content.

En el ejemplo siguiente se muestra una ventana que se redimensiona automáticamente para ajustarse al contenido, tanto vertical como horizontalmente, cuando se muestra por primera vez.The following example shows a window that automatically sizes to fit its content, both vertically and horizontally, when first shown.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    SizeToContent="WidthAndHeight">
</Window>

En el ejemplo siguiente se muestra cómo establecer el SizeToContent propiedad en el código para especificar cómo cambia el tamaño de una ventana para ajustar su contenido.The following example shows how to set the SizeToContent property in code to specify how a window resizes to fit its content .


// Manually alter window height and width
this.SizeToContent = SizeToContent.Manual;

// Automatically resize width relative to content
this.SizeToContent = SizeToContent.Width;

// Automatically resize height relative to content
this.SizeToContent = SizeToContent.Height;

// Automatically resize height and width relative to content
this.SizeToContent = SizeToContent.WidthAndHeight;

' Manually alter window height and width
Me.SizeToContent = SizeToContent.Manual

' Automatically resize width relative to content
Me.SizeToContent = SizeToContent.Width

' Automatically resize height relative to content
Me.SizeToContent = SizeToContent.Height

' Automatically resize height and width relative to content
Me.SizeToContent = SizeToContent.WidthAndHeight

Orden de prioridad de las propiedades de tamañoOrder of Precedence for Sizing Properties

Esencialmente, las diversas propiedades de tamaño de una ventana se combinan para definir el intervalo de anchura y altura de una ventana de tamaño ajustable.Essentially, the various sizes properties of a window combine to define the range of width and height for a resizable window. Para asegurarse de que se mantiene un intervalo válido, Window evalúa los valores de las propiedades de tamaño utilizando las órdenes de prioridad siguientes.To ensure a valid range is maintained, Window evaluates the values of the size properties using the following orders of precedence.

Para las propiedades de altura:For Height Properties:

  1. FrameworkElement.MinHeight >

  2. FrameworkElement.MaxHeight >

  3. SizeToContent.Height/SizeToContent.WidthAndHeight >

  4. FrameworkElement.Height

Para las propiedades de anchura:For Width Properties:

  1. FrameworkElement.MinWidth >

  2. FrameworkElement.MaxWidth >

  3. SizeToContent.Width/SizeToContent.WidthAndHeight >

  4. FrameworkElement.Width

El orden de precedencia puede determinar el tamaño de una ventana cuando está maximizado, que se administran mediante el WindowState propiedad.The order of precedence can also determine the size of a window when it is maximized, which is managed with the WindowState property.

Estado de la ventanaWindow State

Durante la vigencia de una ventana de tamaño ajustable, esta puede tener tres estados: normal, minimizado y maximizado.During the lifetime of a resizable window, it can have three states: normal, minimized, and maximized. Una ventana con un normal estado es el estado predeterminado de una ventana.A window with a normal state is the default state of a window. Una ventana con este estado permite al usuario moverla y cambiar su tamaño mediante los controles de cambio de tamaño o el borde, si es de tamaño ajustable.A window with this state allows a user to move and resize it by using a resize grip or the border, if it is resizable.

Una ventana con un minimizado estado se contrae hasta su botón de barra de tareas si ShowInTaskbar está establecido en true; en caso contrario, contrae hasta el tamaño más pequeño posible puede ser y reubica en la esquina inferior izquierda del escritorio.A window with a minimized state collapses to its task bar button if ShowInTaskbar is set to true; otherwise, it collapses to the smallest possible size it can be and relocates itself to the bottom-left corner of the desktop. Ningún tipo de ventana minimizada puede cambiar de tamaño mediante el borde ni mediante los controles de cambio de tamaño, aunque si no aparece en la barra de tareas se podrá arrastrar a cualquier parte del escritorio.Neither type of minimized window can be resized using a border or resize grip, although a minimized window that isn't shown in the task bar can be dragged around the desktop.

Una ventana con un maximizado estado se expande hasta el tamaño máximo que puede ser, que solo será tan grande como su MaxWidth, MaxHeight, y SizeToContent dictan de propiedades.A window with a maximized state expands to the maximum size it can be, which will only be as large as its MaxWidth, MaxHeight, and SizeToContent properties dictate. Al igual que una ventana minimizada, no puede cambiarse el tamaño de una ventana maximizada mediante un control de cambio de tamaño ni arrastrando el borde.Like a minimized window, a maximized window cannot be resized by using a resize grip or by dragging the border.

Nota

Los valores de la Top, Left, Width, y Height propiedades de una ventana siempre representan los valores para el estado normal, incluso cuando la ventana actualmente está maximizada o minimizada.The values of the Top, Left, Width, and Height properties of a window always represent the values for the normal state, even when the window is currently maximized or minimized.

El estado de una ventana se puede configurar estableciendo su WindowState propiedad, que puede tener uno de los siguientes WindowState valores de enumeración:The state of a window can be configured by setting its WindowState property, which can have one of the following WindowState enumeration values:

En el ejemplo siguiente se muestra cómo crear una ventana que se muestra como maximizada cuando se abre.The following example shows how to create a window that is shown as maximized when it opens.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowState="Maximized">
</Window>

En general, debería establecer WindowState para configurar el estado inicial de una ventana.In general, you should set WindowState to configure the initial state of a window. Cuando aparece una ventana de tamaño ajustable, los usuarios pueden presionar los botones para minimizar, maximizar y restaurar situados en la barra de título de la ventana para cambiar el estado de esta.Once a resizable window is shown, users can press the minimize, maximize, and restore buttons on the window's title bar to change the window state.

Aspecto de la ventanaWindow Appearance

Puede cambiar el aspecto del área cliente de una ventana mediante la adición de contenido específico, como botones, etiquetas y cuadros de texto.You change the appearance of the client area of a window by adding window-specific content to it, such as buttons, labels, and text boxes. Para configurar el área no cliente, Window proporciona varias propiedades, que incluyen Icon para establecer el icono de una ventana y Title para establecer su título.To configure the non-client area, Window provides several properties, which include Icon to set a window's icon and Title to set its title.

También puede cambiar el aspecto y comportamiento del borde del área distinta del cliente configurando el modo de cambio de tamaño de la ventana, el estilo de esta y si aparece como un botón en la barra de tareas del escritorio.You can also change the appearance and behavior of non-client area border by configuring a window's resize mode, window style, and whether it appears as a button in the desktop task bar.

Modo de cambio de tamañoResize Mode

En función de la WindowStyle propiedad, puede controlar cómo (y si) se puede cambiar el tamaño de la ventana.Depending on the WindowStyle property, you can control how (and if) users can resize the window. La opción de estilo de ventana determina si un usuario puede cambiar el tamaño de la ventana arrastrando su borde con el mouse, si la minimizar, maximizar, y cambiar el tamaño de botones aparecen en el área no cliente, y, si aparecen, si están habilitadas.The choice of window style affects whether a user can resize the window by dragging its border with the mouse, whether the Minimize, Maximize, and Resize buttons appear on the non-client area, and, if they do appear, whether they are enabled.

Puede configurar cómo cambia el tamaño de una ventana estableciendo su ResizeMode propiedad, que puede ser uno de los siguientes ResizeMode valores de enumeración:You can configure how a window resizes by setting its ResizeMode property, which can be one of the following ResizeMode enumeration values:

Al igual que con WindowStyle, es improbable que cambie durante su duración, lo que significa que es más probable es que configuran desde el modo de cambio de tamaño de una ventana XAMLXAML marcado.As with WindowStyle, the resize mode of a window is unlikely to change during its lifetime, which means that you'll most likely set it from XAMLXAML markup.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ResizeMode="CanResizeWithGrip">
</Window>

Tenga en cuenta que puede detectar si una ventana está maximizada, minimizada o restaurada inspeccionando el WindowState propiedad.Note that you can detect whether a window is maximized, minimized, or restored by inspecting the WindowState property.

Estilo de ventanaWindow Style

El borde que se expone desde el área distinta del cliente de una ventana es adecuado para la mayoría de las aplicaciones.The border that is exposed from the non-client area of a window is suitable for most applications. Sin embargo, hay circunstancias donde se necesitan tipos diferentes de borde o no se necesita ningún borde en absoluto, dependiendo del tipo de ventana.However, there are circumstances where different types of borders are needed, or no borders are needed at all, depending on the type of window.

Para controlar qué tipo de borde de una ventana obtiene, establecer su WindowStyle propiedad con uno de los siguientes valores de la WindowStyle enumeración:To control what type of border a window gets, you set its WindowStyle property with one of the following values of the WindowStyle enumeration:

El efecto de estos estilos de ventana se muestra en la ilustración siguiente.The effect of these window styles are illustrated in the following figure.

Estilos de ventanaWindow styles

Puede establecer WindowStyle mediante XAMLXAML o marcado del código; porque es improbable que cambie durante la duración de una ventana, más probable es que configurará con XAMLXAML marcado.You can set WindowStyle using either XAMLXAML markup or code; because it is unlikely to change during the lifetime of a window, you will most likely configure it using XAMLXAML markup.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="ToolWindow">
</Window>

Estilo de ventana no rectangularNon-Rectangular Window Style

También hay situaciones donde el borde estilos que WindowStyle permite tener no es suficientes.There are also situations where the border styles that WindowStyle allows you to have are not sufficient. Por ejemplo, puede que desee crear una aplicación con un borde no rectangular, como Reproductor de Windows Media de MicrosoftMicrosoft Windows Media Player usa.For example, you may want to create an application with a non-rectangular border, like Reproductor de Windows Media de MicrosoftMicrosoft Windows Media Player uses.

Considere, por ejemplo, la ventana de globo que se muestra en la ilustración siguiente.For example, consider the speech bubble window shown in the following figure.

Ventana no rectangularNonrectangular window

Se puede crear este tipo de ventana estableciendo la WindowStyle propiedad Noney mediante el comando especial compatible con esto Window tiene para la transparencia.This type of window can be created by setting the WindowStyle property to None, and by using special support that Window has for transparency.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="None"
    AllowsTransparency="True"
    Background="Transparent">
</Window>

Esta combinación de valores indica a la ventana que se puede representar de forma totalmente transparente.This combination of values instructs the window to render completely transparent. En este estado, no se pueden usar las opciones del área distinta del cliente de la ventana (el menú Cerrar, los botones para minimizar, maximizar y restaurar, etc.).In this state, the window's non-client area adornments (the Close menu, Minimize, Maximize, and Restore buttons, and so on) cannot be used. Por consiguiente, deberá proporcionar las suyas propias.Consequently, you need to provide your own.

Presencia de la barra de tareasTask Bar Presence

El aspecto predeterminado de una ventana incluye un botón de barra de tareas, como el que se muestra en la siguiente ilustración.The default appearance of a window includes a task bar button, like the one shown in the following figure.

Ventana con un botón de barra de tareasWindow with a task bar button

Algunos tipos de windows no tienen un botón de barra de tareas, como cuadros de mensaje y cuadros de diálogo (vea información general de cuadros de diálogo).Some types of windows don't have a task bar button, such as message boxes and dialog boxes (see Dialog Boxes Overview). Puede controlar si se muestra el botón de barra de tareas para una ventana estableciendo la ShowInTaskbar propiedad (true de forma predeterminada).You can control whether the task bar button for a window is shown by setting the ShowInTaskbar property (true by default).

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ShowInTaskbar="False">
</Window>

Consideraciones de seguridadSecurity Considerations

Window requiere UnmanagedCode permiso de seguridad que se creará una instancia.Window requires UnmanagedCode security permission to be instantiated. Para aquellas aplicaciones instaladas e iniciadas desde la máquina local, esto pertenece al conjunto de permisos que se conceden a la aplicación.For applications installed on and launched from the local machine, this falls within the set of permissions that are granted to the application.

Sin embargo, esto no entra en el conjunto de permisos concedidos a las aplicaciones que se inician desde la Internet o Local intranet zona utilizando ClickOnceClickOnce.However, this falls outside the set of permissions granted to applications that are launched from the Internet or Local intranet zone using ClickOnceClickOnce. Por lo tanto, los usuarios recibirán un ClickOnceClickOnce advertencia de seguridad y tendrá que elevar el conjunto de permisos para la aplicación en plena confianza.Consequently, users will receive a ClickOnceClickOnce security warning and will need to elevate the permission set for the application to full trust.

Además, XBAPsXBAPs no se pueden mostrar ventanas o cuadros de diálogo de forma predeterminada.Additionally, XBAPsXBAPs cannot show windows or dialog boxes by default. Para obtener información sobre las consideraciones de seguridad de aplicación independiente, consulte estrategia de seguridad de WPF: seguridad de la plataforma.For a discussion on standalone application security considerations, see WPF Security Strategy - Platform Security.

Otros tipos de ventanasOther Types of Windows

NavigationWindow es una ventana diseñada para hospedar contenido navegable.NavigationWindow is a window that is designed to host navigable content. Para obtener más información, consulte Navigation Overview).For more information, see Navigation Overview).

Los cuadros de diálogo son ventanas que se suelen utilizar para recopilar información de un usuario para completar una función.Dialog boxes are windows that are often used to gather information from a user to complete a function. Por ejemplo, cuando un usuario desea abrir un archivo, el abrir archivo cuadro de diálogo se muestra normalmente una aplicación para obtener el nombre de archivo del usuario.For example, when a user wants to open a file, the Open File dialog box is usually displayed by an application to get the file name from the user. Para obtener más información, vea Información general sobre cuadros de diálogo.For more information, see Dialog Boxes Overview.

Vea tambiénSee Also

Window
MessageBox
NavigationWindow
Application
Información general sobre cuadros de diálogoDialog Boxes Overview
Compilar una aplicación de WPFBuilding a WPF Application