Visão geral das caixas de diálogo (WPF .NET)
O Windows Presentation Foundation (WPF) fornece maneiras de criar suas próprias caixas de diálogo. As caixas de diálogo são janelas, mas com uma intenção específica e experiência do usuário. Este artigo descreve como uma caixa de diálogo funciona e que tipos de caixas de diálogo você pode criar e usar. As caixas de diálogo são usadas para:
- Exibir informações específicas aos usuários.
- Coletar informações de usuários.
- Exibir e coletar informações.
- Exibir um prompt do sistema operacional, como a janela de impressão.
- Selecione um arquivo ou pasta.
Esses tipos de janelas são conhecidos como caixas de diálogo. Uma caixa de diálogo pode ser exibida de duas maneiras: modal e sem modo.
Exibir uma caixa de diálogo modal para o usuário é uma técnica com a qual o aplicativo interrompe o que estava fazendo até que o usuário feche a caixa de diálogo. Isso geralmente vem na forma de um prompt ou alerta. Outras janelas no aplicativo não podem ser interagidas até que a caixa de diálogo seja fechada. Depois que a caixa de diálogo modal for fechada, o aplicativo continuará. As caixas de diálogo mais comuns são usadas para mostrar um prompt de arquivo aberto ou salvar arquivo, exibir a caixa de diálogo da impressora ou enviar mensagens ao usuário com algum status.
Uma caixa de diálogo sem janela restrita não impede que um usuário ative outras janelas enquanto estiver aberta. Por exemplo, se um usuário quiser localizar ocorrências de uma palavra específica em um documento, uma janela principal geralmente abrirá uma caixa de diálogo para perguntar a um usuário qual palavra ele está procurando. Como o aplicativo não deseja impedir que o usuário edite o documento, a caixa de diálogo não precisa ser modal. Uma caixa de diálogo sem moderação pelo menos fornece um botão Fechar para fechar a caixa de diálogo. Outros botões podem ser fornecidos para executar funções específicas, como um botão Localizar próximo para localizar a próxima palavra em uma pesquisa de palavras.
Com o WPF, você pode criar vários tipos de caixas de diálogo, como caixas de mensagem, caixas de diálogo comuns e caixas de diálogo personalizadas. Este artigo discute cada um e o exemplo de caixa de diálogo fornece exemplos correspondentes.
Caixas de mensagens
Uma caixa de mensagem é uma caixa de diálogo que pode ser usada para exibir informações textuais e permitir que os usuários tomem decisões com os botões. A figura a seguir mostra uma caixa de mensagem que faz uma pergunta e fornece ao usuário três botões para responder à pergunta.
Para criar uma caixa de mensagem, use a MessageBox classe. MessageBox Permite configurar o texto, o título, o ícone e os botões da caixa de mensagem.
Para obter mais informações, consulte Como abrir uma caixa de mensagem.
Caixas de diálogo comuns
O Windows implementa diferentes tipos de caixas de diálogo reutilizáveis que são comuns a todos os aplicativos, incluindo caixas de diálogo para selecionar arquivos e impressão.
Como essas caixas de diálogo são fornecidas pelo sistema operacional, elas são compartilhadas entre todos os aplicativos executados no sistema operacional. Essas caixas de diálogo fornecem uma experiência de usuário consistente e são conhecidas como caixas de diálogo comuns. Como um usuário usa uma caixa de diálogo comum em um aplicativo, ele não precisa aprender a usar essa caixa de diálogo em outros aplicativos.
O WPF encapsula o arquivo aberto, o arquivo salvo, a pasta aberta e imprime caixas de diálogo comuns e as expõe como classes gerenciadas para você usar.
Para saber mais sobre caixas de diálogo comuns, consulte os seguintes artigos:
- Como exibir uma caixa de diálogo comum
- Mostrar a caixa de diálogo Abrir arquivo
- Mostrar a caixa de diálogo Salvar arquivo
- Caixa de diálogo Abrir pasta
- Mostrar a caixa de diálogo Imprimir
Caixas de diálogo personalizadas
Embora as caixas de diálogo comuns sejam úteis e devam ser usadas quando possível, elas não oferecem suporte aos requisitos de caixas de diálogo específicas do domínio. Nesses casos, você precisa criar suas próprias caixas de diálogo. Como veremos, uma caixa de diálogo é uma janela com comportamentos especiais. Window Implementa esses comportamentos e você usa a janela para criar caixas de diálogo modais e sem moderação personalizadas.
Há muitas considerações de design a serem levadas em conta ao criar sua própria caixa de diálogo. Embora uma janela do aplicativo e uma caixa de diálogo contenham semelhanças, como o compartilhamento da mesma classe base, uma caixa de diálogo é usada para uma finalidade específica. Normalmente, uma caixa de diálogo é necessária quando você precisa solicitar a um usuário algum tipo de informação ou resposta. Normalmente, o aplicativo pausará enquanto a caixa de diálogo (modal) for exibida, restringindo o acesso ao restante do aplicativo. Quando a caixa de diálogo for fechada, o aplicativo continuará. Limitar as interações apenas à caixa de diálogo, no entanto, não é um requisito.
Quando uma janela do WPF é fechada, ela não pode ser reaberta. As caixas de diálogo personalizadas são janelas WPF e a mesma regra se aplica. Para saber como fechar uma janela, consulte Como fechar uma janela ou caixa de diálogo.
Como implementar uma caixa de diálogo
Ao criar uma caixa de diálogo, siga estas sugestões para criar uma boa experiência do usuário:
❌ NÃO bagunça a janela de diálogo. A experiência de diálogo é para o usuário inserir alguns dados ou fazer uma escolha.
✔️ DO forneça um botão OK para fechar a janela.
✔️ DO defina a propriedade do IsDefault botão OK para permitir que o usuário pressione a tecla ENTER para true aceitar e fechar a janela.
✔️ CONSIDERE adicionar um botão Cancelar para que o usuário possa fechar a janela e indicar que não deseja continuar.
✔️ DO defina a propriedade do IsCancel botão Cancelar para permitir que o usuário pressione a tecla ESC para true fechar a janela.
✔️ DO defina o título da janela para descrever com precisão o que a caixa de diálogo representa ou o que o usuário deve fazer com a caixa de diálogo.
✔️ DO defina valores mínimos de largura e altura para a janela, impedindo que o usuário redimensione a janela muito pequena.
✔️ CONSIDERE desabilitar a capacidade de redimensionar a janela se ShowInTaskbar estiver definida como false. Você pode desabilitar o redimensionamento definindo ResizeMode como NoResize
O código a seguir demonstra essa configuração.
<Window x:Class="Dialogs.Margins"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Change Margins"
Closing="Window_Closing"
MinHeight="200"
MinWidth="300"
SizeToContent="WidthAndHeight"
ResizeMode="NoResize"
ShowInTaskbar="False"
WindowStartupLocation="CenterOwner"
FocusManager.FocusedElement="{Binding ElementName=leftMarginTextBox}">
<Grid Margin="10">
<Grid.Resources>
<!-- Default settings for controls -->
<Style TargetType="{x:Type Label}">
<Setter Property="Margin" Value="0,3,5,5" />
<Setter Property="Padding" Value="0,0,0,5" />
</Style>
<Style TargetType="{x:Type TextBox}">
<Setter Property="Margin" Value="0,0,0,5" />
</Style>
<Style TargetType="{x:Type Button}">
<Setter Property="Width" Value="70" />
<Setter Property="Height" Value="25" />
<Setter Property="Margin" Value="5,0,0,0" />
</Style>
</Grid.Resources>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition />
</Grid.RowDefinitions>
<!-- Left,Top,Right,Bottom margins-->
<Label Grid.Column="0" Grid.Row="0">Left Margin:</Label>
<TextBox Name="leftMarginTextBox" Grid.Column="1" Grid.Row="0" />
<Label Grid.Column="0" Grid.Row="1">Top Margin:</Label>
<TextBox Name="topMarginTextBox" Grid.Column="1" Grid.Row="1"/>
<Label Grid.Column="0" Grid.Row="2">Right Margin:</Label>
<TextBox Name="rightMarginTextBox" Grid.Column="1" Grid.Row="2" />
<Label Grid.Column="0" Grid.Row="3">Bottom Margin:</Label>
<TextBox Name="bottomMarginTextBox" Grid.Column="1" Grid.Row="3" />
<!-- Accept or Cancel -->
<StackPanel Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="Right">
<Button Name="okButton" Click="okButton_Click" IsDefault="True">OK</Button>
<Button Name="cancelButton" IsCancel="True">Cancel</Button>
</StackPanel>
</Grid >
</Window>
O XAML acima cria uma janela semelhante à seguinte imagem:
Elementos da interface do usuário abrindo uma caixa de diálogo
A experiência do usuário para uma caixa de diálogo também se estende para a barra de menus ou o botão da janela que a abre. Quando um item de menu ou botão executa uma função que requer interação do usuário por meio de uma caixa de diálogo antes que a função possa continuar, o controle deve usar reticências no final do texto do cabeçalho:
<MenuItem Header="_Margins..." Click="formatMarginsMenuItem_Click" />
<!-- or -->
<Button Content="_Margins..." Click="formatMarginsButton_Click" />
Quando um item de menu ou botão executa uma função que exibe uma caixa de diálogo que não requer interação do usuário, como uma caixa de diálogo Sobre, uma reticência não é necessária.
Itens de menu
Os itens de menu são uma maneira comum de fornecer aos usuários ações de aplicativo que são agrupadas em temas relacionados. Você provavelmente já viu o menu Arquivo em muitos aplicativos diferentes. Em um aplicativo típico, o item de menu Arquivo fornece maneiras de salvar um arquivo, carregar um arquivo e imprimir um arquivo. Se a ação for exibir uma janela modal, o cabeçalho normalmente incluirá reticências conforme mostrado na imagem a seguir:
Dois dos itens do menu têm uma reticência: .... Isso ajuda o usuário a identificar que, ao selecionar esses itens de menu, uma janela modal é exibida, pausando o aplicativo até que o usuário o feche.
Essa técnica de design é uma maneira fácil de você comunicar aos seus usuários o que eles devem esperar.
Buttons
Você pode seguir o mesmo princípio descrito na seção Itens de menu. Use reticências no texto do botão para indicar que, quando o usuário pressionar o botão, uma caixa de diálogo modal será exibida. Na imagem a seguir, há dois botões e é fácil entender qual botão exibe uma caixa de diálogo:
Retornar um resultado
Abrir outra janela, especialmente uma caixa de diálogo modal, é uma ótima maneira de retornar status e informações para o código de chamada.
Diálogos modais
Quando uma caixa de diálogo é mostrada chamando ShowDialog(), o código que abriu a caixa de diálogo aguarda até que o ShowDialog método retorne. Quando o método retorna, o código que o chamou precisa decidir se deseja continuar o processamento ou parar o processamento. O usuário geralmente indica isso pressionando um botão OK ou Cancelar na caixa de diálogo.
Quando o botão OK é pressionado, deve ser projetado para retornar , ShowDialog e o botão Cancelar para retornar truefalse. Isso é conseguido definindo a DialogResult propriedade quando o botão é pressionado.
private void okButton_Click(object sender, RoutedEventArgs e) =>
DialogResult = true;
private void cancelButton_Click(object sender, RoutedEventArgs e) =>
DialogResult = false;
Private Sub okButton_Click(sender As Object, e As RoutedEventArgs)
DialogResult = True
End Sub
Private Sub cancelButton_Click(sender As Object, e As RoutedEventArgs)
DialogResult = False
End Sub
A DialogResult propriedade só pode ser definida se a caixa de diálogo foi exibida com ShowDialog(). Quando a propriedade é definida, a DialogResult caixa de diálogo é fechada.
Se a propriedade de IsCancel um botão estiver definida como true, e a janela for aberta com ShowDialog(), a tecla ESC fechará a janela e definirá DialogResult como false.
Para obter mais informações sobre como fechar caixas de diálogo, consulte Como fechar uma janela ou caixa de diálogo.
Processar a resposta
O ShowDialog() retorna um valor booleano para indicar se o usuário aceitou ou cancelou a caixa de diálogo. Se você estiver alertando o usuário sobre algo, mas não exigir que ele tome uma decisão ou forneça dados, poderá ignorar a resposta. A resposta também pode ser inspecionada verificando a DialogResult propriedade. O código a seguir mostra como processar a resposta:
var dialog = new Margins();
// Display the dialog box and read the response
bool? result = dialog.ShowDialog();
if (result == true)
{
// User accepted the dialog box
MessageBox.Show("Your request will be processed.");
}
else
{
// User cancelled the dialog box
MessageBox.Show("Sorry it didn't work out, we'll try again later.");
}
Dim marginsWindow As New Margins
Dim result As Boolean? = marginsWindow.ShowDialog()
If result = True Then
' User accepted the dialog box
MessageBox.Show("Your request will be processed.")
Else
' User cancelled the dialog box
MessageBox.Show("Sorry it didn't work out, we'll try again later.")
End If
marginsWindow.Show()
Caixa de diálogo sem moderação
Para mostrar uma caixa de diálogo sem modo, chame Show(). A caixa de diálogo deve pelo menos fornecer um botão Fechar . Outros botões e elementos interativos podem ser fornecidos para executar uma função específica, como um botão Localizar próximo para localizar a próxima palavra em uma pesquisa de palavras.
Como uma caixa de diálogo sem janela restrita não bloqueia a continuação do código de chamada, você deve fornecer uma maneira diferente de retornar um resultado. Você tem as seguintes opções:
- Exponha uma propriedade de objeto de dados na janela.
- Manipule o Window.Closed evento no código de chamada.
- Crie eventos na janela que são gerados quando o usuário seleciona um objeto ou pressiona um botão específico.
O exemplo a seguir usa o evento para exibir uma caixa de mensagem para o usuário quando a Window.Closed caixa de diálogo é fechada. A mensagem exibida faz referência a uma propriedade da caixa de diálogo fechada. Para obter mais informações sobre como fechar caixas de diálogo, consulte Como fechar uma janela ou caixa de diálogo.
var marginsWindow = new Margins();
marginsWindow.Closed += (sender, eventArgs) =>
{
MessageBox.Show($"You closed the margins window! It had the title of {marginsWindow.Title}");
};
marginsWindow.Show();
Dim marginsWindow As New Margins
AddHandler marginsWindow.Closed, Sub(sender As Object, e As EventArgs)
MessageBox.Show($"You closed the margins window! It had the title of {marginsWindow.Title}")
End Sub
marginsWindow.Show()
Confira também
.NET Desktop feedback
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de