Introducción a las ventanas de WPF

2025-05-07

Los usuarios interactúan con las aplicaciones de Windows Presentation Foundation (WPF) a través de ventanas. El propósito principal de una ventana es hospedar el contenido que visualiza los datos y permite a los usuarios interactuar con los datos. Las aplicaciones WPF proporcionan sus propias ventanas mediante la Window clase . En este artículo se introduce Window antes de presentar los aspectos básicos de la creación y gestión de ventanas en aplicaciones.

Importante

En este artículo se usa XAML generado a partir de un proyecto de C# . Si usas Visual Basic, el XAML puede tener un aspecto ligeramente diferente. Estas diferencias suelen estar presentes en los valores de atributo x:Class. C# incluye el espacio de nombres raíz del proyecto mientras Visual Basic no lo hace.

Las plantillas de proyecto para C# crean un App tipo contenido en el archivo app.xaml . En Visual Basic, el tipo se denomina Application y el archivo se denomina Application.xaml.

La clase Window

En WPF, la Window clase que usa para hacer lo siguiente encapsula una ventana:

Mostrar una ventana.
Configure el tamaño, la posición y la apariencia de una ventana.
Hospedar contenido específico de la aplicación.
Administrar la duración de una ventana.

En la ilustración siguiente se muestran las partes constituyentes de una ventana:

Captura de pantalla que muestra partes de una ventana de WPF.

Una ventana se divide en dos áreas: el área no cliente y el área cliente.

El área no cliente de una ventana es implementada por WPF e incluye partes de la ventana que son comúnmente comunes a la mayoría de las ventanas, incluida lo siguiente:

Barra de título (1-5).
Un icono (1).
Título (2)
Minimizar (3), Maximizar (4) y Cerrar (5) botones.
Menú del sistema (6) con elementos de menú. Aparece al hacer clic en el icono (1).
Borde (7).

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

Área cliente (8).
Cambiar el tamaño del control (9). Se trata de un control agregado al área Cliente (8).

Implementación de una ventana

La implementación de una ventana típica incluye tanto la apariencia como el comportamiento, donde la apariencia define cómo una ventana se ve a los usuarios y el comportamiento define la forma en que una ventana funciona a medida que los usuarios interactúan con ella. En WPF, puedes implementar la apariencia y el comportamiento de una ventana mediante código o marcado XAML.

Sin embargo, en general, la apariencia de una ventana se implementa mediante el marcado XAML y su comportamiento se implementa mediante código subyacente, como se muestra en el ejemplo siguiente.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

</Window>

El código siguiente es el código subyacente para xaml.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}

Public Class Window1

End Class

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

En el marcado, el elemento Window debe incluir el atributo x:Class. Cuando se compila la aplicación, la existencia del atributo x:Class hace que el motor de compilación de Microsoft (MSBuild) genere una clase partial que se deriva de Window con el nombre especificado por el atributo x:Class. Esto requiere la adición de una declaración de espacio de nombres XML para el esquema XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). La clase generada partial implementa el InitializeComponent método , al que se llama para registrar los eventos y establecer las propiedades que se implementan en el marcado.
En el código subyacente, la clase debe ser de tipo partial con el mismo nombre que especifica el atributo x:Class en el marcado, y debe derivar de Window. Esto permite asociar el archivo de código subyacente a la partial clase que se genera para el archivo de marcado cuando se compila la aplicación, para obtener más información, vea Compilar una aplicación WPF.
En el código subyacente, la Window clase debe implementar un constructor que llame al InitializeComponent método . InitializeComponent se implementa mediante la clase generada partial del archivo de marcado para registrar eventos y establecer propiedades definidas en el marcado.

Nota:

Al agregar un nuevo Window al proyecto mediante Visual Studio, Window se implementa usando tanto el marcado como el código detrás, e incluye la configuración necesaria para crear la asociación entre los archivos de marcado y código detrás, según se describe aquí.

Con esta configuración en contexto, puedes centrarte en definir la apariencia de la ventana en el marcado XAML e implementar su comportamiento en el código subyacente. En el ejemplo siguiente se muestra una ventana con un botón que define un controlador de eventos para el Click evento. Esto se implementa en xaml y el controlador se implementa en código subyacente.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

    <Button Click="Button_Click">Click This Button</Button>

</Window>

El código siguiente es el código subyacente para xaml.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

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

Public Class Window1

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MessageBox.Show("Button was clicked.")
    End Sub

End Class

Configuración de una ventana para MSBuild

La forma de implementar la ventana determina cómo está configurada para MSBuild. Para una ventana que se define mediante el marcado XAML y el código subyacente:

Los archivos de marcado XAML se configuran como elementos de MSBuild Page .
Los archivos de código subyacente se configuran como elementos de MSBuild Compile .

Los proyectos del SDK de .NET importan automáticamente los elementos Page y Compile correctos, y no es necesario declararlos. Cuando el proyecto está configurado para WPF, los archivos de marcado XAML se importan automáticamente como Page elementos y el archivo de código subyacente correspondiente se importa como Compile.

Los proyectos de MSBuild no importarán automáticamente los tipos y debe declararlos usted mismo:

<Project>
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Para obtener información sobre cómo compilar aplicaciones WPF, vea Compilar una aplicación WPF.

Duración de la ventana

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

Abrir una ventana

Para abrir una ventana, primero debe crear una instancia de ella, que se muestra en el ejemplo siguiente:

using System.Windows;

namespace WindowsOverview
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Create the window
            Window1 window = new Window1();

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

Class Application

    Private Sub Application_Startup(sender As Object, e As StartupEventArgs)
        ' Create the window
        Dim window As New Window1

        ' Open the window
        window.Show()
    End Sub

End Class

En este ejemplo, Window1 se instancia cuando se inicia la aplicación, lo cual ocurre cuando se genera el evento Startup. Para obtener más información sobre la ventana de inicio, consulte Cómo obtener o establecer la ventana principal de la aplicación.

Cuando se crea una instancia de una ventana, se agrega automáticamente una referencia a ella a una lista de ventanas administradas por el Application objeto . La primera ventana que se instancie se establece automáticamente por Application como la ventana principal de la aplicación.

La ventana se abre finalmente llamando al Show método , como se muestra en la siguiente imagen:

Una ventana que se abre al llamar a Show es una ventana sin modalidad, y la aplicación no impide que los usuarios interactúen con otras ventanas de la aplicación. Al abrir una ventana con ShowDialog se abre una ventana como modal y se restringe la interacción del usuario a la ventana específica. Para obtener más información, vea Información general sobre cuadros de diálogo.

Cuando se llama a Show, una ventana lleva a cabo el proceso de inicialización antes de mostrarse para establecer la infraestructura necesaria para recibir las entradas del usuario. Cuando se inicializa la ventana, se genera el SourceInitialized evento y se muestra la ventana.

Para obtener más información, vea Cómo abrir una ventana o un cuadro de diálogo.

Ventana de inicio

En el ejemplo anterior se usó el Startup evento para ejecutar código que mostraba la ventana de aplicación inicial. En su lugar, como acceso directo, use StartupUri para especificar la ruta de acceso a un archivo XAML en la aplicación. La aplicación crea y muestra automáticamente la ventana especificada por esa propiedad.

<Application x:Class="WindowsOverview.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WindowsOverview"
             StartupUri="ClippedWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

Propiedad de la ventana

Una ventana que se abre mediante el Show método no tiene una relación implícita con la ventana que la creó. Los usuarios pueden interactuar con cualquiera de las ventanas independientemente del otro, lo que significa que cualquiera de las ventanas puede hacer lo siguiente:

Cubra el otro (a menos que una de las ventanas tenga su Topmost propiedad establecida en true).
Se puede minimizar, maximizar y restaurar sin afectar a los demás.

Algunas ventanas requieren una relación con la ventana que las abre. Por ejemplo, una aplicación del 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, estas ventanas siempre deben cerrarse, minimizar, maximizar y restaurar en conjunto con la ventana que las creó. Dicha relación se puede establecer haciendo que una ventana sea propietaria de otra y se consigue estableciendo la Owner propiedad de la ventana propiedad con una referencia a la ventana de propietario. Esto se muestra en el ejemplo siguiente.

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Create a window and make the current window its owner
    var ownedWindow = new ChildWindow1();
    ownedWindow.Owner = this;
    ownedWindow.Show();
}

Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Create a window and make the current window its owner
    Dim ownedWindow As New ChildWindow1
    ownedWindow.Owner = Me
    ownedWindow.Show()
End Sub

Una vez establecida la propiedad:

La ventana propiedad puede hacer referencia a su ventana de propietario inspeccionando el valor de su Owner propiedad.
La ventana del propietario puede detectar todas las ventanas que posee inspeccionando el valor de su OwnedWindows propiedad.

Activación de ventana

Cuando se abre una ventana por primera vez, se convierte en la ventana activa. La ventana activa es la ventana que está capturando actualmente la entrada del usuario, como trazos de tecla y clics del mouse. Cuando una ventana se activa, genera el Activated evento .

Nota:

Cuando se abre una ventana por primera vez, los Loaded eventos y ContentRendered solo se generan después de que se genere el Activated evento. Teniendo esto en cuenta, una ventana puede considerarse abierta eficazmente cuando ContentRendered se levanta.

Después de activar una ventana, un usuario puede activar otra ventana en la misma aplicación o activar otra aplicación. Cuando esto sucede, la ventana activa se desactiva y genera el Deactivated evento. Del mismo modo, cuando el usuario selecciona una ventana desactivada actualmente, la ventana vuelve a estar activa y Activated se genera.

Una razón común para controlar Activated y Deactivated es habilitar y deshabilitar la funcionalidad que solo se puede ejecutar cuando una ventana está activa. Por ejemplo, algunas ventanas muestran contenido interactivo que requiere una entrada o atención constantes del usuario, incluidos los juegos y reproductores de vídeo. El ejemplo siguiente es un reproductor de vídeo simplificado que muestra cómo controlar Activated e Deactivated implementar este comportamiento.

<Window x:Class="WindowsOverview.CustomMediaPlayerWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Activated="Window_Activated"
        Deactivated="Window_Deactivated"
        Title="CustomMediaPlayerWindow" Height="450" Width="800">
    <Grid>
        <MediaElement x:Name="mediaElement" Stretch="Fill"
                      LoadedBehavior="Manual" Source="numbers.mp4" />
    </Grid>
</Window>

El código siguiente es el código subyacente para xaml.

using System;
using System.Windows;

namespace WindowsOverview
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow() =>
            InitializeComponent();

        private void Window_Activated(object sender, EventArgs e)
        {
            // Continue playing media if window is activated
            mediaElement.Play();
        }

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

Public Class CustomMediaPlayerWindow
    Private Sub Window_Activated(sender As Object, e As EventArgs)
        ' Continue playing media if window Is activated
        mediaElement.Play()
    End Sub

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

Es posible que otros tipos de aplicaciones sigan 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 usa otras aplicaciones. Las aplicaciones como estas a menudo proporcionan un comportamiento diferente o adicional mientras se desactiva la ventana principal. Para un programa de correo, esto puede significar agregar el nuevo elemento de correo a la bandeja de entrada y agregar un icono de notificación a la bandeja del sistema. Solo se debe mostrar un icono de notificación cuando la ventana de correo no está activa, que viene determinada por inspeccionar la IsActive propiedad .

Si se completa una tarea en segundo plano, es posible que una ventana quiera notificar al usuario con más urgencia llamando al Activate método . Si el usuario interactúa con otra aplicación que se activa cuando se llama a Activate, el botón de la barra de tareas de la ventana parpadea. Sin embargo, si un usuario interactúa con la aplicación actual, la llamada Activate llevará la ventana al primer plano.

Nota:

Puede controlar la activación de ámbito de aplicación mediante los eventos Application.Activated y Application.Deactivated.

Prevención de la activación de ventanas

Hay escenarios en los que las ventanas no deben activarse cuando se muestran, como ventanas de conversación de una aplicación de chat o ventanas de notificación de una aplicación de correo electrónico.

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

La ventana no está activada.
No se genera el evento de ventana Activated.
La ventana activada actualmente permanece activada.

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

La ventana está activada.
Se genera el evento de la Activated ventana.
La ventana activada anteriormente está desactivada.
Los eventos Deactivated y Activated de la ventana se generan según lo esperado en respuesta a las acciones del usuario.

Cerrar una ventana

La vida útil de una ventana comienza a llegar a un final cuando un usuario lo cierra. Una vez cerrada una ventana, no se puede volver a abrir. Se puede cerrar una ventana mediante elementos del área que no son cliente, incluidos los siguientes:

Elemento Cerrar del menú Sistema .
Presione ALT + F4.
Presionando el botón Cerrar .
Al presionar ESC cuando un botón tiene la propiedad IsCancel establecida en true en una ventana modal.

Puede proporcionar más mecanismos al área de cliente para cerrar una ventana, entre las que se incluyen las siguientes:

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 de aplicación secundaria.
Un botón Cancelar , normalmente en un cuadro de diálogo modal.
Un botón Cerrar , normalmente en un cuadro de diálogo modelado.

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 seleccionando Salir en un menú Archivo .

<Window x:Class="WindowsOverview.ClosingWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClosingWindow" Height="450" Width="800">
    <StackPanel>
        <Menu>
            <MenuItem Header="_File">
                <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
            </MenuItem>
        </Menu>
    </StackPanel>
</Window>

El código siguiente es el código subyacente para xaml.

using System.Windows;

namespace WindowsOverview
{
    public partial class ClosingWindow : Window
    {
        public ClosingWindow() =>
            InitializeComponent();

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

Public Class ClosingWindow
    Private Sub fileExitMenuItem_Click(sender As Object, e As RoutedEventArgs)
        ' Close the current window
        Me.Close()
    End Sub
End Class

Nota:

Una aplicación se puede configurar para apagarse automáticamente cuando se cierra la ventana principal de la aplicación (vea MainWindow) o se cierra la última ventana. Para obtener más información, consulte ShutdownMode.

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

Un usuario cierra sesión o cierra Windows.
Se cierra una ventana Owner .
La ventana principal de la aplicación está cerrada y ShutdownMode es OnMainWindowClose.
Se llama a Shutdown.

Importante

Una ventana no se puede volver a abrir después de cerrarla.

Cancelar cierre de ventana

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

Closing se genera antes de que se cierre la ventana y proporciona un mecanismo por el que se puede impedir el cierre de la ventana. Una razón común para evitar el cierre de ventana es si el contenido de la ventana contiene datos modificados. En esta situación, el Closing evento se puede controlar para determinar si los datos están sucios 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. En el ejemplo siguiente se muestran los aspectos clave del manejo de Closing.

<Window x:Class="WindowsOverview.DataWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataWindow" Height="450" Width="800"
        Closing="Window_Closing">
    <Grid>
        <TextBox x:Name="documentTextBox" TextChanged="documentTextBox_TextChanged" />
    </Grid>
</Window>

El código siguiente es el código subyacente para xaml.

using System.Windows;
using System.Windows.Controls;

namespace WindowsOverview
{
    public partial class DataWindow : Window
    {
        private bool _isDataDirty;

        public DataWindow() =>
            InitializeComponent();

        private void documentTextBox_TextChanged(object sender, TextChangedEventArgs e) =>
            _isDataDirty = true;

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // If data is dirty, prompt user and ask for a response
            if (_isDataDirty)
            {
                var result = MessageBox.Show("Document has changed. Close without saving?",
                                             "Question",
                                             MessageBoxButton.YesNo);

                // User doesn't want to close, cancel closure
                if (result == MessageBoxResult.No)
                    e.Cancel = true;
            }
        }
    }
}

Public Class DataWindow

    Private _isDataDirty As Boolean

    Private Sub documentTextBox_TextChanged(sender As Object, e As TextChangedEventArgs)
        _isDataDirty = True
    End Sub

    Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs)

        ' If data is dirty, prompt user and ask for a response
        If _isDataDirty Then
            Dim result = MessageBox.Show("Document has changed. Close without saving?",
                                         "Question",
                                         MessageBoxButton.YesNo)

            ' User doesn't want to close, cancel closure
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End If

    End Sub
End Class

Al controlador de eventos Closing se le pasa un CancelEventArgs, que implementa la propiedad Cancel que estableces en true para evitar que se cierre una ventana.

Si Closing no se gestiona, o si se gestiona pero no se cancela, la ventana se cerrará. Justo antes de que se cierre una ventana, Closed se activa. En este momento, no se puede impedir que se cierre una ventana.

Eventos de vida útil de la ventana

En la ilustración siguiente se muestra la secuencia de los eventos de entidad de seguridad durante la vigencia de una ventana:

Diagrama que muestra los eventos en la duración de una ventana.

En la ilustración siguiente se muestra la secuencia de los eventos de entidad de seguridad en la duración de una ventana que se muestra sin activación (ShowActivated se establece en false antes de que se muestre la ventana):

Diagrama que muestra los eventos en la duración de una ventana sin activación.

Ubicación de la ventana

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

También puede especificar la ubicación inicial de una Window cuando aparece por primera vez estableciendo la WindowStartupLocation propiedad con uno de los siguientes WindowStartupLocation valores de enumeración:

CenterOwner (valor predeterminado)
CenterScreen
Manual

Si la ubicación de inicio se especifica como Manualy las Left propiedades y Top no se han establecido, Window pedirá al sistema operativo que aparezca una ubicación.

Ventanas principales y orden z

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. Esto se conoce como 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 viene determinada por si está 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 más alto también viene determinada por si está activa o no. Además, las ventanas del orden Z más arriba siempre se encuentran encima de las ventanas en el orden z normal. Una ventana se coloca en el orden z más alto al establecer su propiedad Topmost en true.

Dentro de cada tipo de orden z, la ventana activa aparece encima de todas las demás ventanas en el mismo orden z.

Tamaño de ventana

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

MinWidth, Widthy MaxWidth se usan para administrar el intervalo de anchos que puede tener una ventana durante su vigencia.

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

El alto de la ventana se administra mediante MinHeight, Heighty MaxHeight.

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

Dado que los distintos valores de ancho y alto especifican un intervalo, es posible que el ancho y el alto de una ventana redimensionable estén en cualquier punto dentro del rango especificado para la dimensión correspondiente. 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 usar la SizeToContent propiedad , que tiene los siguientes valores:

SizeToContent.Manual
Sin efecto (valor predeterminado).
SizeToContent.Width
Ajustar al ancho del contenido, lo que tiene el mismo efecto que establecer tanto MinWidth como MaxWidth al ancho del contenido.
SizeToContent.Height
Ajuste al alto del contenido, que tiene el mismo efecto que establecer y MinHeight MaxHeight al alto del contenido.
SizeToContent.WidthAndHeight
Ajuste al ancho y alto del contenido, que tiene el mismo efecto que establecer tanto a MinHeight como a MaxHeight en el alto del contenido, y establecer tanto a MinWidth como a MaxWidth en el ancho del contenido.

En el ejemplo siguiente se muestra una ventana que ajusta automáticamente el tamaño de su contenido, tanto vertical como horizontalmente, cuando se muestra por primera vez.

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

En el ejemplo siguiente se muestra cómo establecer la SizeToContent propiedad en el código para especificar cómo cambia el tamaño de una ventana para ajustarse a su contenido .

// 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 para las propiedades de ajuste de tamaño

Básicamente, las distintas propiedades de tamaño de una ventana se combinan para definir el intervalo de ancho y alto para una ventana de tamaño redimensionable. Para asegurarse de que se mantiene un intervalo válido, Window evalúa los valores de las propiedades de tamaño mediante los siguientes órdenes de prioridad.

Para propiedades de altura:

Para Propiedades de ancho:

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

Estado de la ventana

Durante la vigencia de una ventana redimensionable, 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 mediante un control de cambio de tamaño o el borde, si se puede cambiar el tamaño.

Una ventana con un estado minimizado se contrae en su botón de la barra de tareas si ShowInTaskbar se establece en true; de lo contrario, se contrae al menor tamaño posible y se mueve ella misma a la esquina inferior izquierda del escritorio. No se puede cambiar el tamaño de ningún tipo de ventana minimizada mediante un borde o un control de cambio de tamaño, aunque se puede arrastrar una ventana minimizada que no se muestra en la barra de tareas alrededor del escritorio.

Una ventana con un estado maximizado se expande hasta el tamaño máximo que puede ser, que solo será tan grande como dictan sus MaxWidthpropiedades , MaxHeighty SizeToContent . Al igual que una ventana minimizada, no se puede cambiar el tamaño de una ventana maximizada mediante un control de cambio de tamaño o arrastrando el borde.

Nota:

Los valores de las Toppropiedades , Left, Width, y Height de una ventana siempre representan los valores del estado normal, incluso cuando la ventana está maximizada o minimizada actualmente.

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

Normal (valor predeterminado)
Maximized
Minimized

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

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

En general, debe establecer WindowState para configurar el estado inicial de una ventana. Una vez que se muestra una ventana redimensionable, los usuarios pueden presionar los botones de minimizar, maximizar y restaurar en la barra de título de la ventana para cambiar el estado de la ventana.

Apariencia de la ventana

Para cambiar la apariencia del área de cliente de una ventana, agregue contenido específico de la ventana, como botones, etiquetas y cuadros de texto. Para configurar el área que no es cliente, Window proporciona varias propiedades, que incluyen Icon para establecer el icono de una ventana y Title para establecer su título.

También puede cambiar la apariencia y el comportamiento de los bordes de área que no son cliente configurando el modo de cambio de tamaño de una ventana, el estilo de ventana y si aparece como un botón en la barra de tareas de escritorio.

Modo de cambio de tamaño

Dependiendo de la WindowStyle propiedad , puede controlar si, y cómo, los usuarios cambian el tamaño de la ventana. El estilo de ventana afecta a lo siguiente:

Permite o no permite cambiar el tamaño arrastrando el borde de la ventana con el mouse.
Indica si los botones Minimizar, Maximizar y Cerrar aparecen en el área que no es de cliente.
Indica si los botones Minimizar, Maximizar y Cerrar están habilitados.

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

Al igual que con WindowStyle, es poco probable que el modo de cambio de tamaño de una ventana cambie durante su duración, lo que significa que lo más probable es que lo establezcas desde el marcado XAML.

<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 la WindowState propiedad .

Estilo de ventana

El borde que se expone desde el área que no es cliente de una ventana es adecuado para la mayoría de las aplicaciones. Sin embargo, hay circunstancias en las que se necesitan distintos tipos de bordes, o no se necesitan bordes en absoluto, en función del tipo de ventana.

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

None
SingleBorderWindow (valor predeterminado)
ThreeDBorderWindow
ToolWindow

El efecto de aplicar un estilo de ventana se muestra en la siguiente imagen:

Captura de pantalla que muestra cómo WindowStyle afecta a una ventana en WPF.

Observe que la imagen anterior no muestra ninguna diferencia notable entre SingleBorderWindow y ThreeDBorderWindow. De nuevo en Windows XP, ThreeDBorderWindow afectaba a cómo se dibujaba la ventana, agregando un borde 3D al área de cliente. A partir de Windows 7, las diferencias entre los dos estilos son mínimas.

Puedes establecer WindowStyle con código o marcado XAML. Dado que es poco probable que cambie durante la vigencia de una ventana, lo más probable es configurarlo mediante el marcado XAML.

<Window
    xmlns="http://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 WindowStyle le permiten tener no son suficientes. Por ejemplo, puede que quiera crear una aplicación con un borde no rectangular, como usa el Reproductor de Microsoft Windows Media.

Por ejemplo, considere la ventana de burbuja de voz que se muestra en la siguiente imagen:

Captura de pantalla de una ventana de WPF que tiene un área recortada y una forma personalizada.

Este tipo de ventana se puede crear estableciendo la propiedad WindowStyle a None, y usando el soporte especial que Window tiene para la transparencia.

<Window x:Class="WindowsOverview.ClippedWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClippedWindow" SizeToContent="WidthAndHeight"
        WindowStyle="None" AllowsTransparency="True" Background="Transparent">
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>

        <Rectangle Stroke="#FF000000" RadiusX="10" RadiusY="10"/>
        <Path Fill="White" Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="15,-5.597,0,-0.003" Width="30" Grid.Row="1" Data="M22.166642,154.45381 L29.999666,187.66699 40.791059,154.54395"/>
        <Rectangle Fill="White" RadiusX="10" RadiusY="10" Margin="1"/>
        
        <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" FontSize="25" Text="Greetings!" TextWrapping="Wrap" Margin="5,5,50,5"/>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Background="Transparent" BorderBrush="{x:Null}" Foreground="Red" Content="❌" FontSize="15" />

        <Grid.Effect>
            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Color="LightBlue"/>
        </Grid.Effect>
    </Grid>
</Window>

Esta combinación de valores indica a la ventana que se renderice de manera transparente. En este estado, los botones de decoración del área no cliente de la ventana no se pueden usar y debe proporcionar sus propios botones.

Presencia de la barra de tareas

La apariencia predeterminada de una ventana incluye un botón de barra de tareas. Algunos tipos de ventanas no tienen un botón de barra de tareas, como cuadros de mensaje, cuadros de diálogo o ventanas con la WindowStyle propiedad establecida ToolWindowen . Puede controlar si el botón de la barra de tareas de una ventana se muestra estableciendo la ShowInTaskbar propiedad , que es true de forma predeterminada.

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

Otros tipos de ventanas

NavigationWindow es una ventana diseñada para hospedar contenido navegable.

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

Comparteix a través de

Introducción a las ventanas de WPF

La clase Window

Implementación de una ventana

Configuración de una ventana para MSBuild

Duración de la ventana

Abrir una ventana

Ventana de inicio

Propiedad de la ventana

Activación de ventana

Prevención de la activación de ventanas

Cerrar una ventana

Cancelar cierre de ventana

Eventos de vida útil de la ventana

Ubicación de la ventana

Ventanas principales y orden z

Tamaño de ventana

Orden de prioridad para las propiedades de ajuste de tamaño

Estado de la ventana

Apariencia de la ventana

Modo de cambio de tamaño

Estilo de ventana

Estilo de ventana no rectangular

Presencia de la barra de tareas

Otros tipos de ventanas

Consulte también

Comentaris

Recursos addicionals