Visão geral das janelas do WPF

2025-05-07

Os usuários interagem com aplicativos do WPF (Windows Presentation Foundation) por meio das janelas. A principal finalidade de uma janela é hospedar o conteúdo que visualiza os dados e permite que os usuários interajam com os dados. Os aplicativos WPF fornecem suas próprias janelas usando a Window classe. Este artigo apresenta Window antes de abordar os conceitos básicos de criação e gerenciamento de janelas em aplicativos.

Importante

Este artigo usa XAML gerado a partir de um projeto em C# . Se você estiver usando o Visual Basic, o XAML poderá parecer um pouco diferente. Normalmente, essas diferenças estão presentes em x:Class valores de atributo. O C# inclui o namespace raiz do projeto, enquanto o Visual Basic não.

Os modelos de projeto para C# criam um App tipo contido no arquivo app.xaml . No Visual Basic, o tipo é nomeado Application e o arquivo é nomeado Application.xaml.

A classe Window

No WPF, uma janela é encapsulada pela Window classe que você usa para fazer o seguinte:

Exibir uma janela.
Configure o tamanho, a posição e a aparência de uma janela.
Conteúdo específico do aplicativo hospedeiro.
Gerenciar o tempo de vida de uma janela.

A figura a seguir ilustra as partes constituintes de uma janela:

Captura de tela que mostra partes de uma janela do WPF.

Uma janela é dividida em duas áreas: a área não cliente e a área do cliente.

A área não cliente de uma janela é implementada pelo WPF e inclui as partes de uma janela que são comuns à maioria das janelas, incluindo as seguintes:

Uma barra de título (1-5).
Um ícone (1).
Título (2).
Botões Minimizar (3), Maximizar (4) e Fechar (5).
Menu do sistema (6) com itens de menu. Aparece ao clicar no ícone (1).
Borda (7).

A área do cliente de uma janela é a área dentro da área não cliente de uma janela e é usada pelos desenvolvedores para adicionar conteúdo específico do aplicativo, como barras de menus, barras de ferramentas e controles.

Área do cliente (8).
Ajustador de tamanho (9). Esse é um controle adicionado à área cliente (8).

Implementando uma janela

A implementação de uma janela típica inclui aparência e comportamento, em que a aparência define a aparência de uma janela para os usuários e o comportamento define a maneira como uma janela funciona à medida que os usuários interagem com ela. No WPF, você pode implementar a aparência e o comportamento de uma janela usando código ou marcação XAML.

Em geral, no entanto, a aparência de uma janela é implementada usando a marcação XAML e seu comportamento é implementado usando code-behind, conforme mostrado no exemplo a seguir.

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

O código a seguir é o code-behind para o XAML.

using System.Windows;

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

Public Class Window1

End Class

Para habilitar um arquivo de marcação XAML e um arquivo code-behind para trabalhar em conjunto, o seguinte é necessário:

Na marcação, o Window elemento deve incluir o x:Class atributo. Quando o aplicativo é criado, a existência do atributo x:Class faz com que o mecanismo de build da Microsoft (MSBuild) gere uma classe partial que deriva de Window com o nome especificado pelo atributo x:Class. Isso requer a adição de uma declaração de namespace XML para o esquema XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). A classe gerada partial implementa o InitializeComponent método, que é chamado para registrar os eventos e definir as propriedades que são implementadas na marcação.
No code-behind, a classe deve ser uma partial classe com o mesmo nome especificado pelo atributo x:Class no markup, e deve derivar de Window. Isso permite que o arquivo code-behind seja associado à classe gerada para o arquivo de marcação quando o aplicativo for criado; para mais informações, consulte partial.
No code-behind, a classe Window deve implementar um construtor que chame o método InitializeComponent. InitializeComponent é implementado pela classe gerada partial do arquivo de marcação para registrar eventos e definir propriedades definidas na marcação.

Observação

Quando você adiciona um novo Window ao seu projeto usando o Visual Studio, Window é implementado usando marcação e código-behind e inclui a configuração necessária para criar a associação entre os arquivos de marcação e código-behind, conforme descrito aqui.

Com essa configuração em vigor, você pode se concentrar em definir a aparência da janela na marcação XAML e implementar seu comportamento em code-behind. O exemplo a seguir mostra uma janela com um botão que define um manipulador de eventos para o Click evento. Isso foi implementado no XAML e o manipulador foi implementado no code-behind.

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

O código a seguir é o code-behind para o 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

Configurando uma janela para o MSBuild

Como você implementa sua janela determina como ela está configurada para o MSBuild. Para uma janela definida usando marcação XAML e código subjacente:

Os arquivos de marcação XAML são configurados como itens do MSBuild Page .
Os arquivos de code-behind são configurados como itens do MSBuild Compile.

Os projetos do .NET SDK importam automaticamente os itens Page e Compile corretos para você, e você não precisa declará-los. Quando o projeto é configurado para WPF, os arquivos de marcação XAML são importados automaticamente como Page itens e o arquivo code-behind correspondente é importado como Compile.

Os projetos do MSBuild não importarão automaticamente os tipos e você deve declará-los por conta própria:

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

Para obter informações sobre como criar aplicativos WPF, consulte Compilar um aplicativo WPF.

Tempo de vida da janela

Assim como acontece com qualquer classe, uma janela tem um tempo de vida que começa quando é instanciado pela primeira vez, após o qual é aberto, ativado/desativado e, eventualmente, fechado.

Abrindo uma janela

Para abrir uma janela, primeiro crie uma instância dela, o que é demonstrado no exemplo a seguir:

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

Neste exemplo Window1 , é instanciado quando o aplicativo é iniciado, o que ocorre quando o Startup evento é acionado. Para obter mais informações sobre a janela de inicialização, consulte Como obter ou definir a janela principal do aplicativo.

Quando uma janela é instanciada, uma referência a ela é adicionada automaticamente a uma lista de janelas gerenciadas pelo Application objeto. A primeira janela a ser instanciada é definida Application automaticamente como a janela principal do aplicativo.

A janela é finalmente aberta chamando o Show método, conforme mostrado na imagem a seguir:

Uma janela aberta ao chamar Show é uma janela não modal, e o aplicativo não impede que os usuários interajam com outras janelas no aplicativo. Abrir uma janela com ShowDialog abre uma janela como modal e restringe a interação do usuário à janela específica. Para obter mais informações, consulte a visão geral das caixas de diálogo.

Quando Show é chamada, uma janela faz o trabalho de inicialização antes de ser mostrada para estabelecer a infraestrutura que permite que ela receba a entrada do usuário. Quando a janela é inicializada, o SourceInitialized evento é acionado e a janela é mostrada.

Para obter mais informações, consulte Como abrir uma janela ou caixa de diálogo.

Janela de inicialização

O exemplo anterior usou o evento para executar o Startup código que exibia a janela inicial do aplicativo. Como atalho, em vez disso, use StartupUri para especificar o caminho para um arquivo XAML em seu aplicativo. O aplicativo cria e exibe automaticamente a janela especificada por essa propriedade.

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

Propriedade da janela

Uma janela aberta usando o Show método não tem uma relação implícita com a janela que a criou. Os usuários podem interagir com qualquer janela independentemente da outra, o que significa que qualquer janela pode fazer o seguinte:

Cubra o outro (a menos que uma das janelas tenha sua Topmost propriedade definida como true).
Seja minimizado, maximizado e restaurado sem afetar o outro.

Algumas janelas exigem uma relação com a janela que as abre. Por exemplo, um aplicativo IDE (Ambiente de Desenvolvimento Integrado) pode abrir janelas de propriedades e janelas de ferramentas cujo comportamento típico é cobrir a janela que os cria. Além disso, essas janelas devem sempre fechar, minimizar, maximizar e restaurar em conjunto com a janela que as criou. Essa relação pode ser estabelecida fazendo com que uma janela possua outra e seja obtida definindo a Owner propriedade da janela de propriedade com uma referência à janela do proprietário. Isso é mostrado no exemplo a seguir.

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

Depois que a propriedade é estabelecida:

A janela de propriedade pode referenciar sua janela de proprietário inspecionando o valor de sua Owner propriedade.
A janela principal pode descobrir todas as janelas que possui inspecionando o valor de seu atributo OwnedWindows.

Ativação da janela

Quando uma janela é aberta pela primeira vez, ela se torna a janela ativa. A janela ativa é a janela que está capturando a entrada do usuário no momento, como traços de chave e cliques do mouse. Quando uma janela se torna ativa, ela aciona o Activated evento.

Observação

Quando uma janela é aberta pela primeira vez, os eventos Loaded e ContentRendered são gerados somente depois que o evento Activated é levantado. Com isso em mente, uma janela pode ser efetivamente considerada aberta quando ContentRendered é levantada.

Depois que uma janela ficar ativa, um usuário poderá ativar outra janela no mesmo aplicativo ou ativar outro aplicativo. Quando isso acontece, a janela ativa no momento é desativada e aciona o Deactivated evento. Da mesma forma, quando o usuário seleciona uma janela desativada no momento, a janela fica ativa novamente e Activated é acionada.

Um motivo comum para lidar Activated e Deactivated é habilitar e desabilitar a funcionalidade que só pode ser executada quando uma janela está ativa. Por exemplo, algumas janelas exibem conteúdo interativo que requer a entrada ou a atenção constantes do usuário, incluindo jogos e jogadores de vídeo. O exemplo a seguir é um player de vídeo simplificado que demonstra como lidar com Activated e Deactivated para implementar esse comportamento.

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

O código a seguir é o code-behind para o 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

Outros tipos de aplicativos ainda podem executar código em segundo plano quando uma janela é desativada. Por exemplo, um cliente de email pode continuar sondando o servidor de email enquanto o usuário estiver usando outros aplicativos. Aplicativos como esses geralmente fornecem comportamento diferente ou extra enquanto a janela principal é desativada. Para um programa de email, isso pode significar adicionar o novo item de email à caixa de entrada e adicionar um ícone de notificação à bandeja do sistema. Um ícone de notificação só precisa ser exibido quando a janela de email não estiver ativa, o que é determinado inspecionando a IsActive propriedade.

Se uma tarefa em segundo plano for concluída, talvez uma janela queira notificar o usuário com mais urgência chamando Activate o método. Se o usuário estiver interagindo com outro aplicativo ativado quando Activate for chamado, o botão da barra de tarefas da janela piscará. No entanto, se um usuário estiver interagindo com o aplicativo atual, a chamada Activate colocará a janela em primeiro plano.

Observação

Você pode lidar com a ativação do escopo do aplicativo usando os eventos Application.Activated e Application.Deactivated.

Impedindo a ativação da janela

Há cenários em que as janelas não devem ser ativadas quando mostradas, como janelas de conversa de um aplicativo de chat ou janelas de notificação de um aplicativo de email.

Se o aplicativo tiver uma janela que não deve ser ativada quando mostrada, você poderá definir sua ShowActivated propriedade para false antes de chamar o Show método pela primeira vez. Como conseqüência:

A janela não está ativada.
O evento da Activated janela não é acionado.
A janela ativada no momento permanece ativada.

No entanto, a janela será ativada assim que o usuário clicar na área do cliente ou na área externa. Nesse caso:

A janela é ativada.
O evento da Activated janela é acionado.
A janela ativada anteriormente é desativada.
Os eventos Deactivated e Activated das janelas são gerados conforme o esperado em resposta às ações do usuário.

Fechando uma janela

A vida útil de uma janela começa a chegar ao fim quando um usuário a fecha. Depois que uma janela é fechada, ela não pode ser reaberta. Uma janela pode ser fechada usando elementos na área não cliente, incluindo o seguinte:

O item do menu SistemaFechar.
Pressionando ALT + F4.
Pressionando o botão Fechar .
Pressionando ESC quando um botão tem a propriedade IsCancel definida true em uma janela modal.

Você pode fornecer mais mecanismos para a área do cliente para fechar uma janela, o mais comum dos quais incluem o seguinte:

Um item Exit no menu Arquivo , normalmente para as janelas principais do aplicativo.
Um item Fechar no menu Arquivo , normalmente em uma janela de aplicativo secundária.
Um botão Cancelar , normalmente em uma caixa de diálogo modal.
Um botão Fechar , normalmente em uma caixa de diálogo modeless.

Para fechar uma janela em resposta a um desses mecanismos personalizados, você precisa chamar o Close método. O exemplo a seguir implementa a capacidade de fechar uma janela escolhendo Sair de um menu Arquivo .

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

O código a seguir é o code-behind para o 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

Observação

Um aplicativo pode ser configurado para desligar automaticamente quando a janela principal do aplicativo fecha (veja MainWindow) ou a última janela é fechada. Para obter mais informações, consulte ShutdownMode.

Embora uma janela possa ser fechada explicitamente por meio de mecanismos fornecidos nas áreas não cliente e cliente, uma janela também pode ser fechada implicitamente como resultado do comportamento em outras partes do aplicativo ou do Windows, incluindo o seguinte:

Um usuário faz logoff ou desliga o Windows.
Uma janela Owner fecha.
A janela principal do aplicativo está fechada e ShutdownMode é OnMainWindowClose.
Shutdown é chamado.

Importante

Uma janela não pode ser reaberta depois de fechada.

Cancelar fechamento da janela

Quando uma janela fecha, ela gera dois eventos: Closing e Closed.

Closing é gerado antes do fechamento da janela e fornece um mecanismo pelo qual o fechamento da janela pode ser evitado. Um motivo comum para impedir o fechamento da janela é se o conteúdo da janela contém dados modificados. Nessa situação, o Closing evento pode ser tratado para determinar se os dados estão sujos e, nesse caso, perguntar ao usuário se deseja continuar fechando a janela sem salvar os dados ou cancelar o fechamento da janela. O exemplo a seguir mostra os principais aspectos do tratamento 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>

O código a seguir é o code-behind para o 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

O manipulador de eventos Closing recebe um CancelEventArgs, que implementa a propriedade Cancel para o qual você define true para impedir que uma janela seja fechada.

Se Closing não for tratado, ou for tratado mas não cancelado, a janela será fechada. Pouco antes de uma janela realmente fechar, Closed é acionada. Neste ponto, uma janela não pode ser impedida de fechar.

Eventos de ciclo de vida da janela

A ilustração a seguir mostra a sequência dos eventos principais no tempo de vida de uma janela:

Diagrama que mostra eventos no tempo de vida de uma janela.

A ilustração a seguir mostra a sequência dos eventos principais no tempo de vida de uma janela que é mostrada sem ativação (ShowActivated é definida para false antes que a janela seja mostrada):

Diagrama que mostra eventos no tempo de vida de uma janela sem ativação.

Local da janela

Enquanto uma janela está aberta, ela tem um local nas dimensões x e y em relação à área de trabalho. Esse local pode ser determinado inspecionando as propriedades Left e Top, respectivamente. Defina essas propriedades para alterar o local da janela.

Você também pode especificar o local inicial de um Window quando ele aparece pela primeira vez definindo a WindowStartupLocation propriedade com um dos seguintes WindowStartupLocation valores de enumeração:

Se o local de inicialização for especificado como Manual, e as propriedades Left e Top não tiverem sido definidas, Window solicitará ao sistema operacional um local para aparecer.

Janelas mais altas e ordem z

Além de ter um local x e y, uma janela também tem um local na dimensão z, que determina sua posição vertical em relação a outras janelas. Isso é conhecido como a ordem z da janela e há dois tipos: ordem z normal e ordem z superior . O local de uma janela na ordem z normal é determinado por se ela está ativa ou não no momento. Por padrão, uma janela está localizada na ordem z normal. A localização de uma janela na ordem z superior também é determinada por se ela está ativa ou não no momento. Além disso, as janelas na ordem z superior estão sempre localizadas acima das janelas na ordem z normal. Uma janela está localizada na ordem z superior definindo sua Topmost propriedade como true.

Dentro de cada tipo de ordem z, a janela ativa atualmente aparece acima de todas as outras janelas na mesma ordem z.

Tamanho da janela

Além de ter um local de área de trabalho, uma janela tem um tamanho que é determinado por várias propriedades, incluindo as várias propriedades de largura e altura e SizeToContent.

MinWidth, Widthe MaxWidth são usados para gerenciar o intervalo de larguras que uma janela pode ter durante seu tempo de vida.

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

A altura da janela é gerenciada por MinHeight, Heighte MaxHeight.

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

Como os vários valores de largura e valores de altura especificam um intervalo, é possível que a largura e a altura de uma janela redimensionável estejam em qualquer lugar dentro do intervalo especificado para a respectiva dimensão. Para detectar sua largura e altura atuais, inspecione ActualWidth e ActualHeight, respectivamente.

Se você quiser que a largura e a altura da janela tenham um tamanho que se ajuste ao tamanho do conteúdo da janela, você poderá usar a SizeToContent propriedade, que tem os seguintes valores:

SizeToContent.Manual
Nenhum efeito (padrão).
SizeToContent.Width
Ajuste à largura do conteúdo, que tem o mesmo efeito que definir MinWidth e MaxWidth para a largura do conteúdo.
SizeToContent.Height
Ajustar à altura do conteúdo, o que tem o mesmo efeito que definir tanto MinHeight quanto MaxHeight para a altura do conteúdo.
SizeToContent.WidthAndHeight
Ajustar à largura e à altura do conteúdo, o que tem o mesmo efeito que definir tanto MinHeight quanto MaxHeight para a altura do conteúdo, e definir tanto MinWidth quanto MaxWidth para a largura do conteúdo.

O exemplo a seguir mostra uma janela que é dimensionada automaticamente para ajustar seu conteúdo, vertical e horizontalmente, quando mostrada pela primeira vez.

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

O exemplo a seguir mostra como definir a SizeToContent propriedade no código para especificar como uma janela redimensiona para ajustar seu conteúdo.

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

Ordem de precedência para dimensionar propriedades

Essencialmente, as propriedades de vários tamanhos de uma janela se combinam para definir o intervalo de largura e altura para uma janela redimensionável. Para garantir que um intervalo válido seja mantido, Window avalia os valores das propriedades de tamanho usando as seguintes ordens de precedência.

Para propriedades de altura:

Para propriedades de largura:

A ordem de precedência também pode determinar o tamanho de uma janela quando ela é maximizada, que é gerenciada com a propriedade WindowState.

Estado da janela

Durante a duração de uma janela redimensionável, ela pode ter três estados: normal, minimizado e maximizado. Uma janela com um estado normal é o estado padrão de uma janela. Uma janela com esse estado permite que um usuário o mova e redimensione usando uma alça de redimensionamento ou a borda, se for redimensionável.

Uma janela com um estado minimizado será recolhida no botão da barra de tarefas se ShowInTaskbar estiver definido como true; caso contrário, ela será recolhida para o menor tamanho possível e se moverá para o canto inferior esquerdo da área de trabalho. Nenhum tipo de janela minimizada pode ser redimensionado usando uma borda ou uma alça de redimensionamento, embora uma janela minimizada que não esteja visível na barra de tarefas possa ser arrastada pela área de trabalho.

Uma janela com um estado maximizado se expande para o tamanho máximo que pode ser, que será apenas tão grande quanto seu MaxWidth, MaxHeighte SizeToContent as propriedades ditam. Como uma janela minimizada, uma janela maximizada não pode ser redimensionada usando uma alça de ajuste ou arrastando a borda.

Observação

Os valores de Top, , Left Widthe Height propriedades de uma janela sempre representam os valores para o estado normal, mesmo quando a janela está maximizada ou minimizada no momento.

O estado de uma janela pode ser configurado definindo sua WindowState propriedade, que pode ter um dos seguintes WindowState valores de enumeração:

O exemplo a seguir mostra como criar uma janela que é mostrada como maximizada quando ela é aberta.

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

Em geral, você deve definir WindowState para configurar o estado inicial de uma janela. Depois que uma janela redimensionável é mostrada, os usuários podem pressionar os botões minimizar, maximizar e restaurar na barra de título da janela para alterar o estado da janela.

Aparência da janela

Você altera a aparência da área do cliente de uma janela adicionando conteúdo específico da janela a ela, como botões, rótulos e caixas de texto. Para configurar a área não cliente, Window fornece várias propriedades, que incluem Icon definir o ícone de uma janela e Title definir seu título.

Você também pode alterar a aparência e o comportamento da borda da área não cliente configurando o modo de redimensionamento de uma janela, o estilo da janela e se ele aparece como um botão na barra de tarefas da área de trabalho.

Modo de redimensionamento

Dependendo da WindowStyle propriedade, você pode controlar se e como, os usuários redimensionam a janela. O estilo da janela afeta o seguinte:

Permitir ou desabilitar o redimensionamento arrastando a borda da janela com o mouse.
Se os botões Minimizar, Maximizar e Fechar aparecem na área que não é cliente.
Se os botões Minimizar, Maximizar e Fechar estão habilitados.

Você pode configurar como uma janela redimensiona definindo sua ResizeMode propriedade, que pode ser um dos seguintes ResizeMode valores de enumeração:

Assim como acontece com WindowStyle, é improvável que o modo de redimensionamento de uma janela mude ao longo de sua vida útil, o que significa que você provavelmente o definirá a partir da marcação XAML.

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

Observe que você pode detectar se uma janela é maximizada, minimizada ou restaurada inspecionando a WindowState propriedade.

Estilo de janela

A borda exposta da área não cliente de uma janela é adequada para a maioria dos aplicativos. No entanto, há circunstâncias em que diferentes tipos de bordas são necessários ou nenhuma borda é necessária, dependendo do tipo de janela.

Para controlar que tipo de borda uma janela obtém, defina sua WindowStyle propriedade com um dos seguintes valores da WindowStyle enumeração:

O efeito da aplicação de um estilo de janela é ilustrado na imagem a seguir:

Captura de tela que mostra como o WindowStyle afeta uma janela no WPF.

Observe que a imagem acima não mostra nenhuma diferença perceptível entre SingleBorderWindow e ThreeDBorderWindow. De volta ao Windows XP, ThreeDBorderWindow isso afetou a forma como a janela foi desenhada, adicionando uma borda 3D à área do cliente. A partir do Windows 7, as diferenças entre os dois estilos são mínimas.

Você pode definir WindowStyle usando a marcação XAML ou o código. Como é improvável que ele mude durante o tempo de vida de uma janela, provavelmente você a configurará usando a marcação XAML.

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

Estilo de janela não retangular

Também há situações em que os estilos de borda que WindowStyle permite que você tenha não são suficientes. Por exemplo, talvez você queira criar um aplicativo com uma borda não retangular, como o Microsoft Windows Media Player usa.

Por exemplo, considere a janela de bolha de fala mostrada na imagem a seguir:

Captura de tela de uma janela do WPF que tem uma área recortada e uma forma personalizada.

Esse tipo de janela pode ser criado definindo a WindowStyle propriedade como None, e usando suporte especial que Window tem para transparência.

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

Essa combinação de valores instrui a janela a tornar transparente. Nesse estado, os botões de decoração da área não cliente da janela não podem ser usados e você precisa criar seus próprios.

Presença da barra de tarefas

A aparência padrão de uma janela inclui um botão de barra de tarefas. Alguns tipos de janelas não têm um botão de barra de tarefas, como caixas de mensagem, caixas de diálogo ou janelas com a WindowStyle propriedade definida como ToolWindow. Você pode controlar se o botão da barra de tarefas de uma janela é mostrado definindo a ShowInTaskbar propriedade, que é true por padrão.

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

Outros tipos de janelas

NavigationWindow é uma janela projetada para hospedar conteúdo navegável.

As caixas de diálogo são janelas que geralmente são usadas para coletar informações de um usuário para concluir uma função. Por exemplo, quando um usuário deseja abrir um arquivo, a caixa de diálogo Abrir Arquivo é exibida por um aplicativo para obter o nome do arquivo do usuário. Para obter mais informações, consulte a visão geral das caixas de diálogo.

Compartilhar via

Visão geral das janelas do WPF

A classe Window

Implementando uma janela

Configurando uma janela para o MSBuild

Tempo de vida da janela

Abrindo uma janela

Janela de inicialização

Propriedade da janela

Ativação da janela

Impedindo a ativação da janela

Fechando uma janela

Cancelar fechamento da janela

Eventos de ciclo de vida da janela

Local da janela

Janelas mais altas e ordem z

Tamanho da janela

Ordem de precedência para dimensionar propriedades

Estado da janela

Aparência da janela

Modo de redimensionamento

Estilo de janela

Estilo de janela não retangular

Presença da barra de tarefas

Outros tipos de janelas

Consulte também

Comentários

Recursos adicionais