Dialog Boxes Overview

Artigo
08/25/2010

Aplicativos autônomos geralmente têm uma janela principal que exibe os principais dados sobre os quais o aplicativo opera e expõe a funcionalidade para processar os dados através de mecanismos da interface do usuário (UI) (barras de menu, barras de ferramentas, e barras de status). Um aplicativo não trivial também pode exibir janelas adicionais para fazer o seguinte:

Exibir informações específicas aos usuários
Coletar informações a partir dos usuários.
Exibir e coletar informações.

Esses tipos de janelas são conhecidos sistema autônomo caixas de diálogo, e há dois tipos: janela restrita e sem janela restrita.

Uma caixa de diálogo modal é exibida por uma função quando a função precisa de dados adicionais vindos do usuário para continuar. Como a função depende da caixa de diálogo modal para coletar dados, a caixa de diálogo modal também impede que o usuário ative outras janelas no aplicativo enquanto ela permanecer aberta. Na maioria dos casos, um caixa de diálogo modal permite que o usuário sinalize quando ele tiver terminado de usá-la pressionando um botão OK ou Cancel. Ao pressionar o botão OK, o usuário indica que ele inseriu os dados e quer que a função continue o processamento com esses dados. Ao pressionar o botão Cancel, ele indica que ele deseja que a função interrompa sua execução totalmente. Os exemplos de caixas de diálogo modais mais comuns são mostrados para abrir, salvar, e imprimir dados.

Uma caixa de diálogo sem-modo, por outro lado, não impede que o usuário ative outras janelas enquanto ela estiver aberta. Por exemplo, se o usuário desejar localizar ocorrências de uma palavra específica em um documento, uma janela principal geralmente abrirá um caixa de diálogo para pedir ao usuário qual palavra ele está procurando. Como a busca por uma palavra não impede que o usuário edite o documento, no entanto, a caixa de diálogo não precisa ser modal. Uma caixa de diálogo sem-modo fornece pelo menos um botão para fechar a caixa de diálogo, Close, e pode fornecer outros botões para executar funções específicas, como um botão Localizar próximo para localizar a próxima palavra que corresponde aos critérios de localização de uma pesquisa por palavra.

Windows Presentation Foundation (WPF) permite que você crie vários tipos de caixas de diálogo, incluindo caixas de mensagem, caixas de diálogo comum, e caixas de diálogo personalizadas. Este tópico aborda cada um desses casos, e o Exemplo de caixa de diálogo fornece os exemplos correspondentes.

Este tópico contém as seguintes seções.

Caixas de mensagem
Caixas de Diálogo Comuns
Caixas de diálogo personalizadas
Tópicos relacionados

Caixas de mensagem

Uma caixa de mensagem é um caixa de diálogo que pode ser usada para exibir informações textuais e para permitir que os usuários tomem decisões com botões. A figura a seguir mostra um caixa de mensagem que exibe informações textuais, faz uma pergunta, e oferece ao usuário três botões para responder à pergunta.

Caixa de diálogo Processador de Texto

Para criar uma caixa de mensagem, use o MessageBox classe. MessageBox permite configurar o texto da caixa de mensagem, título, ícone e botões, usando código semelhante ao seguinte.

Para mostrar uma caixa de mensagem, você chama o método static Show, conforme demonstrado no código a seguir.

Quando o código que mostra uma caixa de mensagem precisa detectar e processar a decisão do usuário (qual botão foi pressionado), o código pode inspecionar o resultado da caixa de mensagem, conforme mostrado no código o seguir.

Para mais informações sobre o uso das caixas de mensagens, consulte MessageBox, Exemplo de MessageBox e Exemplo de caixa de diálogo.

Embora MessageBox possa oferecer ao usuário uma experiência simples de caixa de diálogo, a vantagem de usar MessageBox é que é o único tipo de janela que pode ser mostrado por aplicativos executados em uma proteção de segurança parcialmente confiável (consulte Windows Presentation Foundation Security), como aplicativos de navegador XAML (XBAPs).

A maioria das caixas de diálogo exibem e coletam dados mais complexos do que o resultado de uma caixa de mensagem, inclusive texto, seleção (check boxes), seleção mutuamente exclusiva (botões de opção), e seleção a partir de uma lista (caixas de listagem, caixas de combinação, caixas drop-down). Para esses, Windows Presentation Foundation (WPF) fornece várias caixas de diálogo comuns e permite que você crie suas próprias caixas de diálogo, embora o uso de ambas as técnicas seja limitado a aplicativos executados com confiança total.

Caixas de Diálogo Comuns

Windows implementa uma variedade de caixas de diálogo reutilizáveis que são comuns a todos os aplicativos, incluindo caixas de diálogo para abrir arquivos, salvar arquivos, e impressão. Como essas caixas de diálogo são implementadas pelo sistema operacional, eles podem ser compartilhados entre todos os aplicativos executados no sistema operacional, o que ajuda a manter a consistência da experiência do usuário; quando os usuários estiverem familiarizados com o uso de uma caixa de diálogo fornecida pelo sistema operaciona em um aplicativo, eles não precisarão aprender a usar aquela caixa de diálogo em outros aplicativos. Como essas caixas de diálogo estão disponíveis para todos os aplicativos e como elas ajudam a fornecer um experiência de usuário consistente, elas são conhecidas como caixas de diálogo comuns.

Windows Presentation Foundation (WPF) encapsula as caixas de diálogo comuns para abertura de arquivo, salvamento de arquivo, e impressão e as expõe como classes gerenciadas para que você as use em aplicativos autônomos. Este tópico fornece uma breve visão geral de cada.

Diálogo para abertura de arquivo

A caixa de diálogo para abertura de arquivo, mostrada na figura a seguir, é usada pela funcionalidade de abertura de arquivo para recuperar o nome de um arquivo a abrir.

Caixa de diálogo Abrir

A caixa de diálogo para abertura de arquivo comum é implementada como a classe OpenFileDialog e está localizada no namespace Microsoft.Win32. O código a seguir mostra como criar, configurar e mostrar uma, e como processar o resultado.

Para mais informações sobre a caixa de diálogo para abertura de arquivo, consulte Microsoft.Win32.OpenFileDialog.

Observação:
OpenFileDialog pode ser usado para recuperar nomes de arquivos com segurança por aplicativos executados com confiança parcial (consulte Windows Presentation Foundation Security). Consulte Carregar de arquivo seguro de um exemplo XBAP para ver uma demonstração.

Caixa de diálogo para salvamento de arquivo

A caixa de diálogo para salvamento de arquivo, mostrada na figura a seguir, é usada pela funcionalidade de salvamento de arquivo para recuperar o nome de um arquivo a salvar.

Caixa de diálogo Salvar como

A caixa de diálogo para salvamento de arquivo comum é implementada como a classe SaveFileDialog e está localizada no namespace Microsoft.Win32. O código a seguir mostra como criar, configurar e mostrar uma, e como processar o resultado.

Para mais informações sobre a caixa de diálogo para salvamento de arquivo, consulte Microsoft.Win32.SaveFileDialog.

Caixa de diálogo para impressão

A caixa de diálogo para impressão, mostrada na figura a seguir, é usada pela funcionalidade de impressão para escolher e configurar a impressora onde o usuário deseja imprimir dados.

Caixa de diálogo Imprimir

A caixa de diálogo para impressão comum é implementada como a classe PrintDialog e está localizada no namespace System.Windows.Controls. O código a seguir mostra como criar, configurar, e mostrar uma dessas caixas.

Para obter mais informações sobre a caixa de diálogo para impressão, consulte System.Windows.Controls.PrintDialog. Para uma discussão detalhada sobre a impressão em WPF, consulte Visão Geral de Impressão.

Caixas de diálogo personalizadas

Enquanto caixas de diálogo comuns são úteis e devem ser usadas quando possível, elas não têm suporte para os requisitos de caixas de diálogo específicas do domínio. Nesses casos, você precisará criar suas próprias caixas de diálogo. sistema autônomo você verá uma caixa de diálogo é uma janela com comportamentos especiais. Window implementa esses comportamentos e, conseqüentemente, usar Window Para criar caixas de diálogo personalizada de janela restrita e sem janela restrita.

Este tópico mostra como usar Window para criar uma implementação de uma caixa de diálogo modal típica, usando a caixa de diálogo Margins como um exemplo (consulte Exemplo de caixa de diálogo). A caixa de diálogo Margins é mostrada na figura a seguir.

Caixa de diálogo Margens

A interface do usuário para uma caixa de diálogo típica inclui o seguinte:

Os vários controles que são necessários para coletar os dados desejados.
Mostrando um botão OK que os usuários clicam para fechar a caixa de diálogo, retornar à função, e continuar o processamento.
Mostrar um botão Cancel que os usuários clicam para fechar a caixa de diálogo e parar o processamento da função.
Mostrar um botão Close na barra de título.
Mostrar um ícone.
Mostrar botões Minimize, Maximize e Restore.
Mostrar um menu System para minimizar, maximizar, restaurar e fechar a caixa de diálogo.
Abrindo acima e no centro da janela que abriu a caixa de diálogo.
Caixas de diálogo devem ser redimensionáveis sempre que possível então, para impedir que esta seja muito pequena e fornecer ao usuário um tamanho padrão útil, você precisa definir dimensões mínimas e padrão, respectivamente.
Pressionar a tecla ESC deve ser configurado como um atalho de teclado que faz com que o botão Cancel seja pressionado. Isso é conseguido definindo a propriedade IsCancel do botão Cancel como true.
Pressionando a tecla ENTER (ou RETURN) deve ser configurado como um atalho de teclado que faz com que o botão OK seja pressionado. Isso é conseguido definindo a propriedade IsDefault do botão OK como true.

O código a seguir demonstra essa configuração:

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarginsDialogBox"
    xmlns:local="clr-namespace:SDKSample"
    Title="Margins"
    Height="190"
    Width="300"
    MinHeight="10"
    MinWidth="300"
    ResizeMode="CanResizeWithGrip"
    ShowInTaskbar="False"
    WindowStartupLocation="CenterOwner" 
    FocusManager.FocusedElement="{Binding ElementName=leftMarginTextBox}">

  <Grid>


...


    <!-- Accept or Cancel -->
    <StackPanel Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="4">
      <Button Name="okButton" Click="okButton_Click" IsDefault="True">OK</Button>
      <Button Name="cancelButton" IsCancel="True">Cancel</Button>
    </StackPanel>

  </Grid >

</Window>

Imports System.Windows ' Window, RoutedEventArgs, IInputElement, DependencyObject
Imports System.Windows.Controls ' Validation
Imports System.Windows.Input ' Keyboard

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window
    Public Sub New()
        Me.InitializeComponent()
    End Sub


...


End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

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


...


    }
}

A experiência do usuário para um caixa de diálogo também se estende à barra de menu da janela que abre a caixa de diálogo. Quando um item de menu executa uma função que requer interação do usuário através de uma caixa de diálogo antes de continuar a função, o item de menu para a função terá reticências em seu cabeçalho, conforme mostrado aqui.

<!--Main Window-->


...


<MenuItem Name="formatMarginsMenuItem" Header="_Margins..." Click="formatMarginsMenuItem_Click" />

Quando um item de menu executa uma função que exibe um caixa de diálogo que não requer interação do usuário, como uma caixa de diálogo "Sobre", reticências não são necessárias.

Um caixa de diálogo geralmente é mostrada como resultado de uma seleção que o usuário fez em um menu para executar uma função específica de domínio, como definir as margens de um documento em um processador de texto. Mostrar uma janela como um caixa de diálogo é semelhante a mostrar uma janela normal, embora ele exija configuração adicional específica das caixas de diálogo. Todo o processo de criar uma instância, configurar e abrir um caixa de diálogo é mostrado no código a seguir.

Imports System '  EventArgs
Imports System.ComponentModel '  CancelEventArgs
Imports System.Windows '  Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls '  TextChangedEventArgs
Imports Microsoft.Win32 '  OpenFileDialog

Namespace SDKSample

Public Class MainWindow
    Inherits Window


...


Private Sub formatMarginsMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Instantiate the dialog box
    Dim dlg As New MarginsDialogBox

    ' Configure the dialog box
    dlg.Owner = Me
    dlg.DocumentMargin = Me.documentTextBox.Margin

    ' Open the dialog box modally 
    dlg.ShowDialog()



...


End Sub


...


End Class

End Namespace

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {


...


void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)
{
    // Instantiate the dialog box
    MarginsDialogBox dlg = new MarginsDialogBox();

    // Configure the dialog box
    dlg.Owner = this;
    dlg.DocumentMargin = this.documentTextBox.Margin;

    // Open the dialog box modally 
    dlg.ShowDialog();



...


}


...


    }
}

Aqui, o código está passando informações padrão (as margens atuais) para a caixa de diálogo. Ele também define a propriedade Window.Owner com uma referência para a janela que está mostrando a caixa de diálogo. Em geral, você deve sempre definir o proprietário de uma caixa de diálogo para fornecer comportamentos relacionados a estados de janelas que são comuns a todas as caixas de diálogo (consulte Visão geral do WPF do Windows para mais informações).

Observação:
Você deve fornecer um proprietário para oferecer suporte a interface do usuário (UI) automação para caixas de diálogo (consulte UI Automation Overview).

Depois que a caixa de diálogo tiver sido configurada, ela é mostrada modalmente chamando o método ShowDialog.

Validação de dados fornecidos pelo usuário

Quando um caixa de diálogo é aberta e o usuário fornece os dados necessários, a caixa de diálogo é responsável por garantir que os dados fornecidos são válidos pelos seguintes motivos:

A partir de uma perspectiva de segurança, todas as entradas devem ser validadas.
A partir de uma perspectiva específica de domínio, a validação de dados impede que dados errados sejam processadas pelo código, o que pode potencialmente lançar exceções.
A partir de uma perspectiva da experiência do usuário, uma caixa de diálogo pode ajudar os usuários mostrando-lhes quais dados que eles digitam são inválidos.
A partir de uma perspectiva de desempenho, a validação de dados em um aplicativo de várias camadas pode reduzir o número de viagens entre o cliente e as camadas do aplicativo, particularmente quando o aplicativo é composto de serviços da Web ou baseado em um servidor bancos de dados.

Para validar um controle limite em WPF, você precisa definir uma regra de validação e associá-lo a ligação. Uma regra de validação é uma classe personalizada derivada de ValidationRule. O exemplo a seguir mostra um regra de validação, MarginValidationRule, que verifica se um valor vinculado é um Double e está dentro de um intervalo especificado.

Imports System.Globalization
Imports System.Windows.Controls

Namespace SDKSample

Public Class MarginValidationRule
    Inherits ValidationRule

    Private _maxMargin As Double
    Private _minMargin As Double

    Public Property MaxMargin() As Double
        Get
            Return Me._maxMargin
        End Get
        Set(ByVal value As Double)
            Me._maxMargin = value
        End Set
    End Property

    Public Property MinMargin() As Double
        Get
            Return Me._minMargin
        End Get
        Set(ByVal value As Double)
            Me._minMargin = value
        End Set
    End Property

    Public Overrides Function Validate(ByVal value As Object, ByVal cultureInfo As CultureInfo) As ValidationResult

        Dim margin As Double

        ' Is a number?
        If Not Double.TryParse(CStr(value), margin) Then
            Return New ValidationResult(False, "Not a number.")
        End If

        ' Is in range?
        If ((margin < Me.MinMargin) OrElse (margin > Me.MaxMargin)) Then
            Dim msg As String = String.Format("Margin must be between {0} and {1}.", Me.MinMargin, Me.MaxMargin)
            Return New ValidationResult(False, msg)
        End If

        ' Number is valid
        Return New ValidationResult(True, Nothing)

    End Function

End Class

End Namespace

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

namespace SDKSample
{
    public class MarginValidationRule : ValidationRule
    {
        double minMargin;
        double maxMargin;

        public double MinMargin
        {
            get { return this.minMargin; }
            set { this.minMargin = value; }
        }

        public double MaxMargin
        {
            get { return this.maxMargin; }
            set { this.maxMargin = value; }
        }

        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            double margin;

            // Is a number?
            if (!double.TryParse((string)value, out margin))
            {
                return new ValidationResult(false, "Not a number.");
            }

            // Is in range?
            if ((margin < this.minMargin) || (margin > this.maxMargin))
            {
                string msg = string.Format("Margin must be between {0} and {1}.", this.minMargin, this.maxMargin);
                return new ValidationResult(false, msg);
            }

            // Number is valid
            return new ValidationResult(true, null);
        }
    }
}

Nesse código, a lógica de validação de uma regra de validação é implementada ao substituir o método Validate, que valida os dados e retorna um ValidationResult adequado.

Para associar a regra de validação ao controle vinculado, use a marcação a seguir.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarginsDialogBox"
    xmlns:local="clr-namespace:SDKSample"
    Title="Margins"
    Height="190"
    Width="300"
    MinHeight="10"
    MinWidth="300"
    ResizeMode="CanResizeWithGrip"
    ShowInTaskbar="False"
    WindowStartupLocation="CenterOwner" 
    FocusManager.FocusedElement="{Binding ElementName=leftMarginTextBox}">

  <Grid>



...


<Label Grid.Column="0" Grid.Row="0">Left Margin:</Label>
<TextBox Name="leftMarginTextBox" Grid.Column="1" Grid.Row="0">
  <TextBox.Text>
    <Binding Path="Left" UpdateSourceTrigger="PropertyChanged">
      <Binding.ValidationRules>
        <local:MarginValidationRule MinMargin="0" MaxMargin="10" />
      </Binding.ValidationRules>
    </Binding>
  </TextBox.Text>
</TextBox>


...


</Window>

Depois que a regra de validação estiver associada, WPF automaticamente aplicá-la-á quando dados forem inseridos no controle vinculado. Quando um controle contiver dados inválidos, WPF exibirá uma borda vermelha ao redor do controle inválido, como mostrado na figura a seguir.

Margem esquerda inválida

WPF não restringe um usuário ao controle inválido até que ele tenha inserido dados válidos. Isso é um bom comportamento para uma caixa de diálogo; um usuário deve poder navegar livremente entre os controles em um caixa de diálogo independentemente da validade dos dados. No entanto, isso significa que um usuário pode inserir dados inválidos e pressionar o botão OK. Por esse motivo, o código também precisa validar todos os controles em um caixa de diálogo quando o botão OK for pressionado, tratando o evento Click.

Imports System.Windows ' Window, RoutedEventArgs, IInputElement, DependencyObject
Imports System.Windows.Controls ' Validation
Imports System.Windows.Input ' Keyboard

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window


...


Private Sub okButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Don't accept the dialog box if there is invalid data
    If Not Me.IsValid(Me) Then Return


...


    End Sub

    ' Validate all dependency objects in a window
    Private Function IsValid(ByVal node As DependencyObject) As Boolean

        ' Check if dependency object was passed and if dependency object is valid.
        ' NOTE: Validation.GetHasError works for controls that have validation rules attached 
        If ((Not node Is Nothing) AndAlso Validation.GetHasError(node)) Then
            ' If the dependency object is invalid, and it can receive the focus,
            ' set the focus
            If TypeOf node Is IInputElement Then
                Keyboard.Focus(DirectCast(node, IInputElement))
            End If
            Return False
        End If

        ' If this dependency object is valid, check all child dependency objects
        Dim subnode As Object
        For Each subnode In LogicalTreeHelper.GetChildren(node)
            If (TypeOf subnode Is DependencyObject AndAlso Not Me.IsValid(DirectCast(subnode, DependencyObject))) Then
                ' If a child dependency object is invalid, return false immediately,
                ' otherwise keep checking
                Return False
            End If
        Next

        ' All dependency objects are valid
        Return True

    End Function

End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {


...


void okButton_Click(object sender, RoutedEventArgs e)
{
    // Don't accept the dialog box if there is invalid data
    if (!IsValid(this)) return;


...


        }

        // Validate all dependency objects in a window
        bool IsValid(DependencyObject node)
        {
            // Check if dependency object was passed
            if (node != null)
            {
                // Check if dependency object is valid.
                // NOTE: Validation.GetHasError works for controls that have validation rules attached 
                bool isValid = !Validation.GetHasError(node);
                if (!isValid)
                {
                    // If the dependency object is invalid, and it can receive the focus,
                    // set the focus
                    if (node is IInputElement) Keyboard.Focus((IInputElement)node);
                    return false;
                }
            }

            // If this dependency object is valid, check all child dependency objects
            foreach (object subnode in LogicalTreeHelper.GetChildren(node))
            {
                if (subnode is DependencyObject)
                {   
                    // If a child dependency object is invalid, return false immediately,
                    // otherwise keep checking
                    if (IsValid((DependencyObject)subnode) == false) return false;
                }
            }

            // All dependency objects are valid
            return true;
        }
    }
}

Esse código enumera todos os objetos de dependência em uma janela e, se qualquer um estiver inválido (como retornado por GetHasError, o controle inválido obtém o foco, o método IsValid retorna false, e a janela é considerada inválida.

Depois que um caixa de diálogo for válida, ele pode fechar e retornar com segurança. Como parte do processo de retorno, ela precisa retornar um resultado para a função que a chamou.

Abrir uma caixa de diálogo usando ShowDialog é basicamente como chamar um método: o código que abriu a caixa de diálogo usando ShowDialog aguarda até que ShowDialog Retorna. Quando ShowDialog retorna, o código que a chamou precisa decidir se deve continuar o processamento ou parar o processamento, dependendo se o usuário pressionou o botão OK ou Cancel. Para facilitar essa decisão, a caixa de diálogo precisa retornar a opção do usuário como um valor Boolean que é retornado pelo método ShowDialog.

Ao clicar no botão OK, ShowDialog deve retornar true. Isso é conseguido definindo a propriedade DialogResult da caixa de diálogo quando o botão OK é clicado.

Observe que a configuração da propriedade DialogResult também faz com que a janela feche automaticamente, o que minimiza a necessidade de se chamar Close explicitamente.

Ao clicar no botão Cancel, ShowDialog deve retornar false, que também requer a definição da propriedade DialogResult.

Imports System.Windows ' Window, RoutedEventArgs, IInputElement, DependencyObject
Imports System.Windows.Controls ' Validation
Imports System.Windows.Input ' Keyboard

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window


...


Private Sub cancelButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Dialog box canceled
    Me.DialogResult = False
End Sub


...


End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {


...


void cancelButton_Click(object sender, RoutedEventArgs e)
{
    // Dialog box canceled
    this.DialogResult = false;
}


...


    }
}

Quando a propriedade IsCancel de um botão for definida como true e o usuário pressionar o botão Cancel ou o tecla ESC, DialogResult é automaticamente definida como false. A marcação a seguir tem o mesmo efeito do código anterior, sem precisar tratar o evento Click.

<Button Name="cancelButton" IsCancel="True">Cancel</Button>

Um caixa de diálogo retorna automaticamente true quando um usuário pressiona o botão Close na barra de título ou escolhe o item de menu Close do menu System.

Quando DialogResult é definido por uma caixa de diálogo, a função que a abriu pode obter o resultado da caixa de diálogo verificando a propriedade DialogResult quando ShowDialog retornar.

Imports System '  EventArgs
Imports System.ComponentModel '  CancelEventArgs
Imports System.Windows '  Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls '  TextChangedEventArgs
Imports Microsoft.Win32 '  OpenFileDialog

Namespace SDKSample

Public Class MainWindow
    Inherits Window


...


Private Sub formatMarginsMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)


...


    ' Process data entered by user if dialog box is accepted
    If (dlg.DialogResult.GetValueOrDefault = True) Then
        Me.documentTextBox.Margin = dlg.DocumentMargin
    End If
End Sub


...


End Class

End Namespace

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {


...


void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)
{


...


    // Process data entered by user if dialog box is accepted
    if (dlg.DialogResult == true)
    {
        // Update fonts
        this.documentTextBox.Margin = dlg.DocumentMargin;
    }
}


...


    }
}

Se o resultado do diálogo for true, a função usa isso como uma deixa para recuperar e processar os dados fornecidos pelo usuário.

Observação:
Depois de ShowDialog foi retornada, uma caixa de diálogo não pode ser reaberta. Em vez disso, você precisará criar uma nova instância.

Se o resultado de diálogo for false, a função deve terminar o processamento de forma adequada.

Criando uma caixa de diálogo personalizada sem-modo

Um caixa de diálogo sem-modo, como a caixa de diálogo Localizar mostrada na figura a seguir, tem a mesma aparência fundamental que a caixa de diálogo modal.

Caixa de diálogo Localizar

No entanto, o comportamento é ligeiramente diferente, conforme descrito nas seções a seguir.

Abrindo uma caixa de diálogo sem-modo

Um caixa de diálogo sem-modo é aberta chamando o método Show.

<!--Main Window-->

Imports System '  EventArgs
Imports System.ComponentModel '  CancelEventArgs
Imports System.Windows '  Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls '  TextChangedEventArgs
Imports Microsoft.Win32 '  OpenFileDialog

Namespace SDKSample

Public Class MainWindow
    Inherits Window


...


Private Sub editFindMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    Dim dlg As New FindDialogBox(Me.documentTextBox)
    dlg.Owner = Me
    AddHandler dlg.TextFound, New TextFoundEventHandler(AddressOf Me.dlg_TextFound)
    dlg.Show()
End Sub

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {


...


void editFindMenuItem_Click(object sender, RoutedEventArgs e)
{
    // Instantiate the dialog box
    FindDialogBox dlg = new FindDialogBox(this.documentTextBox);

    // Configure the dialog box
    dlg.Owner = this;
    dlg.TextFound += new TextFoundEventHandler(dlg_TextFound);

    // Open the dialog box modally
    dlg.Show();
}


...


    }
}

Ao contrário de ShowDialog, Show retorna imediatamente. Consequentemente, a janela que fez a chamada não pode saber quando a caixa de diálogo sem-modo está fechada e, portanto, não sabe quando procurar um resultado na caixa de diálogo ou obter dados a partir de caixa de diálogo para processamento adicional. Em vez disso, a caixa de diálogo precisa criar uma maneira alternativa de retornar dados para que a janela que fez a chamada os processe.

Processamento de dados retornados de uma caixa de diálogo sem-modo

Nesse exemplo, o FindDialogBox pode retornar um ou mais resultados para a janela principal, dependendo do texto que está sendo procurado sem qualquer frequência específica. Como ocorre com uma caixa de diálogo modal, uma caixa de diálogo sem-modo pode retornar resultados usando propriedades. No entanto, a janela que é proprietária da caixa de diálogo precisa saber quando verificar essas propriedades. Uma maneira de habilitar esse é para a caixa de diálogo implementar um evento gerado sempre que o texto é encontrado. FindDialogBox implementa o TextFoundEvent para essa finalidade, que primeiro exige um delegado.

Namespace SDKSample
Public Delegate Sub TextFoundEventHandler(ByVal sender As Object, ByVal e As EventArgs)
End Namespace

using System;
namespace SDKSample
{
    public delegate void TextFoundEventHandler(object sender, EventArgs e);
}

Usando o representante TextFoundEventHandler, FindDialogBox implementa o TextFoundEvent.

Imports System ' EventArgs
Imports System.Windows ' Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls ' TextBox, TextChangedEventArgs
Imports System.Text.RegularExpressions ' Regex

Namespace SDKSample

Public Class FindDialogBox
    Inherits Window
    Public Event TextFound As TextFoundEventHandler
    Protected Overridable Sub OnTextFound()
        RaiseEvent TextFound(Me, EventArgs.Empty)
    End Sub


...


End Class

End Namespace

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {
        public event TextFoundEventHandler TextFound;
        protected virtual void OnTextFound()
        {
            TextFoundEventHandler textFound = this.TextFound;
            if (textFound != null) textFound(this, EventArgs.Empty);
        }


...


    }
}

Consequentemente, Find pode gerar o evento quando um resultado de pesquisa for encontrado.

Imports System ' EventArgs
Imports System.Windows ' Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls ' TextBox, TextChangedEventArgs
Imports System.Text.RegularExpressions ' Regex

Namespace SDKSample

Public Class FindDialogBox
    Inherits Window


...


Private Sub findNextButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)


...


Me.Index = match.Index
Me.Length = match.Length
RaiseEvent TextFound(Me, EventArgs.Empty)


...


End Sub


...


End Class

End Namespace

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {


...


void findNextButton_Click(object sender, RoutedEventArgs e)
{


...


// Text found
this.index = match.Index;
this.length = match.Length;
OnTextFound();


...


}


...


    }
}

A janela proprietária precisará registrar e tratar esse evento.

Imports System '  EventArgs
Imports System.ComponentModel '  CancelEventArgs
Imports System.Windows '  Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls '  TextChangedEventArgs
Imports Microsoft.Win32 '  OpenFileDialog

Namespace SDKSample

Public Class MainWindow
    Inherits Window


...


    Private Sub dlg_TextFound(ByVal sender As Object, ByVal e As EventArgs)
        Dim dlg As FindDialogBox = DirectCast(sender, FindDialogBox)
        Me.documentTextBox.Select(dlg.Index, dlg.Length)
        Me.documentTextBox.Focus()
    End Sub

End Class

End Namespace

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {


...


        void dlg_TextFound(object sender, EventArgs e)
        {
            // Get the find dialog box that raised the event
            FindDialogBox dlg = (FindDialogBox)sender;

            // Get find results and select found text
            this.documentTextBox.Select(dlg.Index, dlg.Length);
            this.documentTextBox.Focus();
        }
    }
}

Fechando uma caixa de diálogo sem-modo

Porque DialogResult não precisa ser definida, uma caixa de diálogo sem-modo pode ser fechada usando mecanismos fornecidos pelo sistema, incluindo o seguinte:

Clicando no botão Close na barra de título.
Pressionando ALT+F4.
Escolhendo Close no menu System.

Como alternativa, seu código pode chamar Close quando o botão Close for clicado.

Imports System ' EventArgs
Imports System.Windows ' Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls ' TextBox, TextChangedEventArgs
Imports System.Text.RegularExpressions ' Regex

Namespace SDKSample

Public Class FindDialogBox
    Inherits Window


...


    Private Sub closeButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        MyBase.Close()
    End Sub
End Class

End Namespace

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {


...


        void closeButton_Click(object sender, RoutedEventArgs e)
        {
            // Close dialog box
            this.Close();
        }
    }
}