Información general sobre ventanas de WPF

Actualización: Julio de 2008

Los usuarios interactúan con las aplicaciones independientes de Windows Presentation Foundation (WPF) por medio de ventanas. El propósito principal de una ventana es hospedar contenido que muestre datos y permita al usuario interactuar con ellos. Las aplicaciones de WPF independientes proporcionan sus propias ventanas por medio de la clase Window. En este tema se presenta Window antes de tratar los principios de la creación y administración de ventanas en aplicaciones independientes.

Este tema contiene las secciones siguientes.

• La clase Window
• Implementar una ventana
• Configurar una definición de ventana para MSBuild
• Duración de la ventana
• Ubicación de la ventana
• Tamaño de la ventana
• Orden de prioridad para las propiedades de tamaño
• Estado de la ventana
• Aspecto de la ventana
• Consideraciones de seguridad
• Otros tipos de ventanas
• Temas relacionados

La clase Window

La figura siguiente muestra las partes constituyente de una ventana.

Una ventana está dividida en dos áreas: el área de no cliente y área cliente.

El área de no cliente de una ventana se implementa mediante WPF e incluye las partes de una ventana que son comunes a la mayoría de las ventanas, incluidas las siguientes:

• Borde.

• Barra de título.

• Icono.

• Botones para minimizar, maximizar y restaurar.

• Botón Cerrar.

• Menú Sistema con elementos de menú que permiten a los usuarios minimizar, maximice, restaurar, mover, cambiar de tamaño y cerrar una ventana.

El área cliente de una ventana es el área dentro del área de no cliente de una ventana y es utilizada por los programadores para agregar contenido específico de la aplicación, tal como barras de menús, barras de herramientas y controles.

En WPF, las ventanas se encapsulan en la clase Window, que se utiliza para hacer lo siguiente:

• Mostrar una ventana.

• Configurar el tamaño, posición y aspecto de una ventana.

• Hospedar contenido específico de la aplicación.

• Administrar la duración de una ventana.

Implementar una ventana

La implementación de una ventana típica abarca tanto su aspecto como su comportamiento, donde el aspecto define la apariencia de la ventana para los usuarios y el comportamiento define cómo funciona una ventana cuando los usuarios interactúan con ella. En WPF, puede implementar el aspecto y el comportamiento de una ventana utilizando código o marcado XAML.

En general, sin embargo, el aspecto de una ventana se implementa utilizando el marcado XAML, y su comportamiento se implementa utilizando código subyacente, como se muestra en el ejemplo siguiente.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">

  <!-- Client area (for content) -->

</Window>

using System.Windows; // Window

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

Para permitir que un archivo de marcado XAML y un archivo de código subyacente funcionen juntos, se requiere lo siguiente:

• En el marcado, el elemento Window debe incluir el atributo x:Class. Al generar la aplicación, la existencia de x:Class en el archivo de marcado permite que Microsoft build engine (MSBuild) cree una clase partial que se deriva de Windowy tenga el nombre especificado por el atributo x:Class. Para ello, es necesario agregar una declaración de espacio de nombres XML para el esquema XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). La clase partial generada implementa el método InitializeComponent, al que se llama para registrar los eventos y establecer las propiedades implementadas en el marcado.

• En el archivo de código subyacente, la clase debe ser una clase partial con el mismo nombre que el que especificó el atributo x:Class en el marcado, y debe derivarse de Window. Esto permite que el archivo de código subyacente se asocie a la clase partial que se genera para el archivo de marcado cuando se crea la aplicación (vea Generar una aplicación de WPF (WPF)).

• En el archivo de código subyacente, la clase Window debe implementar un constructor que llame al método InitializeComponent. InitializeComponent se implementa mediante la clase partial generada del archivo de marcado para registrar eventos y establecer las propiedades que se definen en el marcado.

Con esta configuración activa, puede centrarse en definir el aspecto de la ventana en el marcado XAML y en implementar su comportamiento en el código subyacente. En el ejemplo siguiente se muestra una ventana con un botón, implementado en marcado XAML y un controlador de eventos para el evento Click del botón, implementado en código subyacente.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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.");
        }
    }
}

Configurar una definición de ventana para MSBuild

La forma de implementar la ventana determina cómo se configura para MSBuild. Para una ventana que se define utilizando tanto marcado XAML como código subyacente:

• Los archivos de marcado XAML se configuran como elementos MSBuild Page.

• Los archivos de código subyacente se configuran como elementos MSBuildCompile.

Esto se muestra en el siguiente archivo de proyecto MSBuild.

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

Para obtener información sobre la compilación de aplicaciones WPF, vea Generar una aplicación de WPF (WPF).

Duración de la ventana

Como con cualquier clase, una ventana tiene una duración que comienza cuando se crea por primera vez la instancia, después de lo cual se abre, se activa, se desactiva y, finalmente, se cierra.

Este tema contiene las subsecciones siguientes.

• Abrir una ventana
• Activación de la ventana
• Cerrar una ventana
• Eventos de duración de ventana

Abrir una ventana

Para abrir una ventana, crea primero una instancia de ella, como se muestra en el ejemplo siguiente.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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, se crea una instancia de MarkupAndCodeBehindWindow cuando se inicia la aplicación, lo que ocurre cuando se produce el evento Startup.

Cuando se crea una instancia de una ventana, automáticamente se agrega una referencia a la ventana a la lista de ventanas administrada por el objeto Application (vea Application.Windows). Además, Application establece la primera ventana de la que se crea una instancia, de forma predeterminada, como la ventana principal de la aplicación (vea Application.MainWindow).

La ventana se abre finalmente llamando al método Show; el resultado se muestra en la figura siguiente.

Una ventana que se abre llamando 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.

Cuando se llama a Show, una ventana realiza antes de mostrarse un trabajo de inicialización que establece la infraestructura necesaria para recibir la entrada del usuario. Cuando se inicializa la ventana, se provoca el evento SourceInitialized y se muestra la ventana.

Como método abreviado, se puede establecer StartupUri para especificar la primera ventana que se abre automáticamente cuando se inicia una aplicación.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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 de forma no modal; internamente, la ventana se abre llamando a su método Show.

Propiedad de la ventana

Una ventana que se abre utilizando el método Show no tiene una relación implícita con la ventana que la creó; los usuarios pueden interactuar con cualquier ventana independientemente de las demás, lo que significa que cualquier ventana puede hacer lo siguiente:

• Cubrir las demás (a menos que una de las ventanas tenga su propiedad Topmost establecida en true).

• Minimizarse, maximizarse y restaurarse sin afectar a las demás.

Algunas ventanas requieren una relación con la ventana que las abre. Por ejemplo, una aplicación Entorno de desarrollo integrado (IDE) puede abrir ventanas de propiedades y ventanas de herramientas cuyo comportamiento típico es cubrir la ventana que las crea. Además, tales ventanas siempre se deben cerrar, minimizar, maximizar y restaurar de acuerdo con la ventana que las creó. Este tipo de relación se puede establecer haciendo que una ventana posea otra y se logra estableciendo la propiedad Owner de la ventana poseída con una referencia a la ventana propietaria. Esto se muestra en el ejemplo siguiente.

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();

Una vez establecida la propiedad:

• La ventana poseída puede hacer referencia a su ventana propietaria inspeccionando el valor de su propiedad Owner.

• La ventana propietaria puede detectar todas las ventanas que posee inspeccionando el valor de su propiedad OwnedWindows.

Evitar la activación de ventanas

Hay escenarios en que las ventanas no deben activarse al mostrarlas, como las ventanas de conversación de una aplicación de mensajería de Internet o las ventanas de notificación de una aplicación de correo electrónico.

Si la aplicación tiene una ventana que no debe activarse al mostrarla, puede establecer su propiedad ShowActivated en false antes de llamar por primera vez al método Show. Como consecuencia:

• No se activa la ventana.

• No se provoca el evento Activated de la ventana.

• La ventana que esté activada en ese momento, permanece activada.

No obstante, la ventana se activará en cuanto el usuario la active haciendo clic en el área cliente o no cliente. En este caso:

• Se activa la ventana.

• Se provoca el evento Activated de la ventana.

• La ventana activada previamente se desactiva.

• En lo sucesivo, los eventos Deactivated y Activated de la ventana se provocan como cabe esperar, en respuesta a las acciones del usuario.

Para obtener un ejemplo en que se muestra cómo mostrar una ventana sin activarla, vea Ejemplo Show a Window Without Activating.

Activación de la ventana

Cuando se abre una ventana por primera vez, pasa a ser la ventana activa (a menos que se muestre con la propiedad ShowActivated establecida en false). La ventana activa es la ventana que está capturando los datos proporcionados por el usuario, tales como la presión de las teclas y los clics del mouse. Cuando una ventana se activa, provoca el evento Activated.

Una vez que una ventana se activa, un usuario puede activar otra ventana de la misma aplicación o activar otra aplicación. Cuando ocurre así, la ventana activa actualmente se desactiva y produce el evento Deactivated. Igualmente, cuando el usuario selecciona una ventana actualmente desactivada, la ventana se vuelve a activar y se produce Activated.

Una razón común para administrar Activated y Deactivated es habilitar y deshabilitar funcionalidad que solamente se puede ejecutar cuando una ventana está activa. Por ejemplo, algunas ventanas muestran contenido interactivo que requiere constantemente los datos proporcionados por el usuario o su atención, por ejemplo los juegos y los reproductores de vídeo. El ejemplo siguiente es un reproductor de vídeo simplificado que muestra cómo administrar Activated y Deactivated para implementar este comportamiento.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // EventArgs
using System.Windows; // Window

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();
        }
    }
}

Otros tipos de aplicación pueden continuar ejecutando código en segundo plano cuando se desactiva una ventana. Por ejemplo, un cliente de correo puede continuar sondeando el servidor de correo mientras el usuario está utilizando otras aplicaciones. Aplicaciones como éstas suelen ofrecer un comportamiento diferente o adicional mientras la ventana principal está desactivada. Con respecto al programa de correo, esto puede significar tanto agregar el nuevo elemento de correo a la bandeja de entrada como agregar un icono de notificación a la bandeja del sistema. Solamente es necesario mostrar un icono de notificación cuando la ventana de correo no está activa, lo que se puede determinar inspeccionando la propiedad IsActive.

Si se completa una tarea en segundo plano, puede ser preferible que una ventana avise al usuario más urgentemente llamando al método Activate. Si el usuario está interactuando con otra aplicación activada cuando se llama a Activate, el botón de la barra de tareas de la ventana parpadea. Si un usuario está interactuando con la aplicación actual, al llamar a Activate, se trae la ventana al primero plano.

Cerrar una ventana

La duración de una ventana empieza a acabarse cuando un usuario la cierra. Una ventana se puede cerrar utilizando los elementos del área de no cliente, incluidos los siguientes:

• El elemento Cerrar del menú Sistema.

• Presionar ALT + F4.

• Presionar el botón Cerrar.

Puede proporcionar mecanismos adicionales al área cliente para cerrar una ventana; algunos de los más comunes son los siguientes:

• Un elemento Salir en el menú Archivo, normalmente para las ventanas principales de la aplicación.

• Un elemento Cerrar en el menú Archivo, normalmente en una ventana secundaria de la aplicación.

• Un botón Cancelar, normalmente en un cuadro de diálogo modal.

• Un botón Cerrar, normalmente en un cuadro de diálogo no modal.

Para cerrar una ventana en respuesta a uno de estos mecanismos personalizados, debe llamar al método Close. En el ejemplo siguiente se implementa la capacidad de cerrar una ventana eligiendo Salir en el menú Archivo.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // window, RoutedEventArgs

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

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

Cuando una ventana se cierra, provoca dos eventos: Closing y Closed.

Closing se provoca antes de que la ventana se cierre y proporciona un mecanismo para evitar el cierre de la ventana. Una razón común para evitar el cierre de la ventana es que el contenido de la ventana contenga datos modificados. En esta situación, se puede administrar el evento Closing para determinar si los datos se han modificado y, en ese caso, preguntar al usuario si desea continuar cerrando la ventana sin guardar los datos o si desea cancelar el cierre de la ventana. En el ejemplo siguiente se muestran los aspectos clave de la administración de 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;


...


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

Al controlador del evento Closing se le pasa un objeto CancelEventArgs, que implementa la propiedad BooleanCancel que se establece en true para evitar que una ventana se cierre.

Si no se administra Closing, o se administra pero no se cancela, la ventana se cierra. El evento Closed se produce inmediatamente antes de que una ventana se cierre realmente. En este punto, no se puede evitar que la ventana se cierre.

Aunque una ventana se puede cerrar explícitamente a través de los mecanismos proporcionados en las áreas cliente y no cliente, una ventana también se puede cerrar implícitamente como resultado del comportamiento de otras partes de la aplicación o de Windows, incluido lo siguiente:

• Un usuario cierra la sesión o apaga Windows.

• Se cierra la ventana propietaria de una ventana (vea Owner).

• La ventana principal de la aplicación se cierra y ShutdownMode es OnMainWindowClose.

• Se llama a Shutdown.

Eventos de duración de ventana

La ilustración siguiente muestra la secuencia de eventos principales en la duración de una ventana.

En la ilustración siguiente se muestra la secuencia de eventos principales en la duración de una ventana que se muestra sin activarla (con la propiedad ShowActivated establecida en false antes de mostrar la ventana).

Ubicación de la ventana

Mientras una ventana está abierta, tiene una ubicación en las dimensiones x e y respecto al escritorio. Esta ubicación se puede determinar inspeccionando las propiedades Left y Top, respectivamente. Puede establecer estas propiedades para cambiar la ubicación de la ventana.

También puede especificar la ubicación inicial de un objeto Window la primera vez que aparece estableciendo la propiedad WindowStartupLocation en uno de los siguientes valores de la enumeración WindowStartupLocation:

• Manual (predeterminado)

• CenterScreen

• CenterOwner

Si la ubicación de inicio se especifica como Manual, y no se han establecido las propiedades Left y Top, Window preguntará a Windows dónde debe aparecer.

Ventanas de nivel superior y orden z

Además de tener una ubicación x e y, una ventana tiene también una ubicación en la dimensión z, que determina su posición vertical con respecto a otras ventanas. Esto se conoce como el orden z de la ventana y hay dos tipos: orden z normal y orden z superior. La ubicación de una ventana en el orden z normal se determina por si está actualmente activa o no. De forma predeterminada, una ventana se encuentra en el orden z normal. La ubicación de una ventana en el orden z superior también se determina por si está actualmente activa o no. Además, las ventanas del orden z superior siempre se encuentran por encima de las ventanas del orden z normal. Una ventana se encuentra en orden z superior estableciendo su propiedad Topmost en true.

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


...


</Window>

Dentro de cada orden z, ventana actualmente activa aparece por encima de todas las demás ventanas del mismo orden z.

Tamaño de la ventana

Además de tener una ubicación en el escritorio, una ventana tiene un tamaño determinado por varias propiedades, incluidas las diversas propiedades de alto y ancho, y SizeToContent.

MinWidth, Widthy MaxWidth se utilizan para administrar el intervalo de anchos que una ventana puede tener durante su duración y se configuran como se muestra en el ejemplo siguiente.

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


...


</Window>

El alto de la ventana se administra mediante MinHeight, Height y MaxHeight, y se configura como se muestra en el ejemplo siguiente.

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


...


</Window>

Dado que los diversos valores de ancho y alto especifican cada uno un intervalo, es posible que el ancho y alto de una ventana de tamaño variable estén en cualquier punto dentro del intervalo especificado para la dimensión respectiva. Para detectar su ancho y alto actuales, inspeccione ActualWidth y ActualHeight, respectivamente.

Si desea que el ancho y el alto de la ventana tengan un tamaño que se ajuste al tamaño del contenido de la ventana, puede utilizar la propiedad SizeToContent, que tiene los valores siguientes:

• Manual. Ningún efecto (valor predeterminado).

• Width. Ajustar al ancho del contenido, que tiene el mismo efecto que establecer tanto MinWidth como MaxWidth en el ancho del contenido.

• Height. Ajustar al alto del contenido, que tiene el mismo efecto que establecer MinHeight y MaxHeight en el alto del contenido.

• WidthAndHeight. Ajustar al ancho y al alto del contenido, que tiene el mismo efecto que establecer tanto MinHeight como MaxHeight en el alto del contenido, y establecer tanto MinWidth como MaxWidth en el ancho del contenido.

En el código siguiente se muestra una ventana cuyo tamaño se ajusta automáticamente a su contenido, tanto vertical como horizontalmente, cuando se muestra por primera vez.

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


...


</Window>

Orden de prioridad para las propiedades de tamaño

Esencialmente, las diversas propiedades de tamaño de una ventana se combinan para definir el intervalo de ancho y alto para una ventana de tamaño variable. Para asegurarse de que se mantenga un intervalo válido, Window evalúa los valores de las propiedades de tamaño utilizando los órdenes de prioridad siguientes.

Para las propiedades de alto:

1. FrameworkElement.MinHeight >

2. FrameworkElement.MaxHeight >

3. SizeToContent.Height/SizeToContent.WidthAndHeight >

4. FrameworkElement.Height

Para las propiedades de ancho:

1. FrameworkElement.MinWidth >

2. FrameworkElement.MaxWidth >

3. SizeToContent.Width/SizeToContent.WidthAndHeight >

4. FrameworkElement.Width

Puede utilizar el Ejemplo Window Sizing Order of Precedence para experimentar con el orden de prioridad.

El orden de prioridad también puede determinar el tamaño de una ventana cuando se maximiza, lo que se administra con la propiedad WindowState.

Estado de la ventana

Durante la duración de una ventana de tamaño variable, puede tener tres estados: normal, minimizado y maximizado. Una ventana con un estado normal es el estado predeterminado de una ventana. Una ventana con este estado permite al usuario moverla y cambiar su tamaño utilizando los controladores de tamaño o el borde, si es de tamaño variable.

Una ventana con el estado minimizado se contrae a su botón de la barra de tareas si ShowInTaskbar está establecido en true; de lo contrario, se contrae al mínimo tamaño posible y se reubica en la esquina inferior izquierda del escritorio. Ningún tipo de ventana minimizada puede cambiar su tamaño mediante el borde ni controladores de tamaño, aunque una ventana minimizada que no se muestre en la barra de tareas puede arrastrarse por el escritorio.

Una ventana con un estado maximizado se expande a su tamaño máximo, que solamente puede ser tan grande como dicten sus propiedades MaxWidth, MaxHeight y SizeToContent. Como ocurre con una ventana minimizada, no se puede cambiar el tamaño de una ventana maximizada utilizando un controlador de tamaño ni arrastrando el borde.

El estado de una ventana se puede configurar estableciendo su propiedad WindowState, que puede tener uno de los siguientes valores de la enumeración WindowState:

• Normal (predeterminado)

• Maximized

• Minimized

En el ejemplo siguiente se muestra cómo crear una ventana que se muestra como maximizada al abrirse.

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


...


</Window>

En general, es recomendable establecer WindowState para configurar el estado inicial de una ventana. Una vez mostrada una ventana de tamaño variable, los usuarios pueden presionar los botones de minimizar, maximizar y restablecer de la barra de título de la ventana para cambiar el estado de la ventana.

Aspecto de la ventana

Para cambiar el aspecto del área cliente de una ventana, agréguele contenido específico tal como botones, etiquetas y cuadros de texto. Para configurar el área no cliente, Window proporciona varias propiedades, entre las que se incluye Icon para establecer el icono de una ventana y Title para establecer su título.

También puede cambiar el aspecto y comportamiento del borde del área de no cliente configurando el modo de cambio de tamaño de la ventana, su estilo y si aparece como un botón de la barra de tarea del escritorio.

Este tema contiene las subsecciones siguientes.

• Modo de cambio de tamaño
• Estilo de ventana
• Presencia de la barra de tareas

Modo de cambio de tamaño

En función de la propiedad WindowStyle, puede controlar cómo (y si) los usuarios pueden cambiar el tamaño de la ventana. La elección de estilo de ventana determina si un usuario puede cambiar el tamaño de la ventana arrastrando su borde con el mouse, si los botones Minimizar, Maximizar y Cambiar tamaño aparecen en el área de no cliente, y, si aparecen, si están habilitados.

Puede configurar cómo cambia de tamaño una ventana estableciendo su propiedad ResizeMode, que puede ser uno de los siguientes valores de la enumeración ResizeMode:

• NoResize

• CanMinimize

• CanResize (predeterminado)

• CanResizeWithGrip

Como ocurre con WindowStyle, es improbable que el modo de cambio de tamaño de una ventana cambie durante su duración, los que significa que probablemente se establecerá desde el marcado XAML.

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


...


</Window>

Observe que puede detectar si una ventana está maximizada, minimizada o restaurada inspeccionando la propiedad WindowState.

Estilo de ventana

El borde que se expone desde el área de no cliente de una ventana es adecuado para la mayoría de las aplicaciones. Sin embargo, hay circunstancias en las que se necesitan diferentes tipos de borde, o no se necesita ningún borde en absoluto, según el tipo de ventana.

Para controlar qué tipo de borde obtiene una ventana, establezca su propiedad WindowStyle con uno de los siguientes valores de la enumeración WindowStyle:

• None

• SingleBorderWindow (predeterminado)

• ThreeDBorderWindow

• ToolWindow

El efecto de estos estilos de ventana se muestra en la figura siguiente.

Puede establecer WindowStyle mediante marcado XAML o mediante código; dado que es improbable que cambie durante la duración de una ventana, lo más probable es que lo configure utilizando el marcado XAML.

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


...


</Window>

Estilo de ventana no rectangular

También hay situaciones en las que los estilos de borde que permite WindowStyle no serán suficientes. Por ejemplo, quizá desee crear una aplicación con un borde no rectangular, como el que utiliza Microsoft Windows Media Player.

Por ejemplo, considere la ventana de burbuja de voz que se muestra en la figura siguiente.

Este tipo de ventana se puede crear estableciendo la propiedad WindowStyle en None y utilizando la compatibilidad especial de Window para la transparencia.

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


...


</Window>

Esta combinación de valores indica a la ventana que debe representarse completamente transparente. En este estado, las opciones gráficas del área de no cliente de la ventana (el menú Cerrar, los botones Minimizar, Maximizar y Restaurar, etc.) no se pueden utilizar. Por consiguiente, necesita proporcionar opciones propias. Para obtener más detalles, vea Ejemplo Non-Rectangular Windows.

Presencia de la barra de tareas

El aspecto predeterminado de una ventana incluye un botón de barra de tareas, como el que se muestra en la figura siguiente.

Algunos tipos de ventana no tienen botón de barra de tareas, como los cuadros de mensaje y los cuadros de diálogo (vea Información general sobre cuadros de diálogo). Puede controlar si se muestra el botón de barra de tareas para una ventana estableciendo la propiedad ShowInTaskbar (true de forma predeterminada).

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


...


</Window>

Consideraciones de seguridad

Window requiere permiso de seguridad UnmanagedCode para crear instancias. Para las aplicaciones instaladas en el equipo local e iniciadas desde él, esto pertenece al conjunto de permisos que se conceden a la aplicación.

Sin embargo, esto no pertenece al conjunto de permisos concedido a las aplicaciones que se inician desde la zona de Internet o de Intranet local mediante ClickOnce. Por consiguiente, los usuarios recibirán una advertencia de seguridad ClickOnce y deberán elevar permisos establecido para la aplicación a plena confianza.

Además, las XBAPs no pueden mostrar ventanas ni cuadros de diálogo de forma predeterminada. Para obtener una explicación sobre las consideraciones de seguridad de las aplicaciones independientes, vea Estrategia de seguridad de Windows Presentation Foundation: Seguridad de la plataforma.

Otros tipos de ventanas

NavigationWindow es una ventana diseñada para hospedar contenido navegable. Para obtener más información, vea Información general sobre navegación.

Los cuadros de diálogo son ventanas que se suelen utilizar para recopilar información de un usuario para completar una función. Por ejemplo, cuando un usuario desea abrir un archivo, una aplicación muestra normalmente el cuadro de diálogo Abrir archivo para obtener el nombre de archivo del usuario. Para obtener más información, vea Información general sobre cuadros de diálogo.

Vea también

Conceptos

Información general sobre cuadros de diálogo

Generar una aplicación de WPF (WPF)

Referencia

Window

MessageBox

NavigationWindow

Application

Historial de cambios

Fecha	Historial	Motivo
Julio de 2008	Se ha agregado la sección Evitar la activación de ventanas.	Cambio de características de SP1.