Vue d’ensemble des boîtes de dialogueDialog boxes overview

En général, les applications autonomes ont une fenêtre principale qui affiche les données principales sur lesquelles l’application s’exécute et expose les fonctionnalités permettant interface utilisateur (UI)user interface (UI) de traiter ces données via des mécanismes tels que des barres de menus, des barres d’outils et des barres d’État.Standalone applications typically have a main window that both displays the main data over which the application operates and exposes the functionality to process that data through interface utilisateur (UI)user interface (UI) mechanisms like menu bars, tool bars, and status bars. Une application non triviale peut également afficher des fenêtres supplémentaires pour effectuer les opérations suivantes :A non-trivial application may also display additional windows to do the following:

  • Présenter des informations spécifiques aux utilisateursDisplay specific information to users.

  • Recueillir des informations auprès des utilisateursGather information from users.

  • Afficher et recueillir des informationsBoth display and gather information.

Ces types de fenêtres sont appelés boîtes de dialogueet il existe deux types: modal et non modal.These types of windows are known as dialog boxes, and there are two types: modal and modeless.

Une boîte de dialogue modale est affichée par une fonction quand la fonction a besoin de données supplémentaires d’un utilisateur pour continuer.A modal dialog box is displayed by a function when the function needs additional data from a user to continue. Étant donné que la fonction dépend de la boîte de dialogue modale pour recueillir des données, celle-ci empêche également un utilisateur d’activer d’autres fenêtres de l’application pendant qu’elle reste ouverte.Because the function depends on the modal dialog box to gather data, the modal dialog box also prevents a user from activating other windows in the application while it remains open. Dans la plupart des cas, une boîte de dialogue modale permet à un utilisateur de signaler une fois qu’il a fini d’utiliser la boîte de dialogue modale en appuyant sur un bouton OK ou Annuler .In most cases, a modal dialog box allows a user to signal when they have finished with the modal dialog box by pressing either an OK or Cancel button. Le fait d’appuyer sur le bouton OK indique qu’un utilisateur a entré des données et souhaite que la fonction continue le traitement avec ces données.Pressing the OK button indicates that a user has entered data and wants the function to continue processing with that data. Appuyez sur le bouton Annuler pour indiquer qu’un utilisateur souhaite empêcher la fonction de s’exécuter entièrement.Pressing the Cancel button indicates that a user wants to stop the function from executing altogether. Les exemples les plus courants de boîtes de dialogue modales sont présentés pour ouvrir, enregistrer et imprimer des données.The most common examples of modal dialog boxes are shown to open, save, and print data.

En revanche, une boîte de dialogue non modale n’empêche pas un utilisateur d’activer d’autres fenêtres pendant qu’elle est ouverte.A modeless dialog box, on the other hand, does not prevent a user from activating other windows while it is open. Par exemple, si un utilisateur souhaite rechercher des occurrences d’un mot particulier dans un document, une fenêtre principale peut ouvrir une boîte de dialogue pour l’inviter à spécifier le mot qu’il recherche.For example, if a user wants to find occurrences of a particular word in a document, a main window will often open a dialog box to ask a user what word they are looking for. Puisque rechercher un mot n’empêche pas l’utilisateur de modifier le document, la boîte de dialogue n’a pas besoin d’être modale.Since finding a word doesn't prevent a user from editing the document, however, the dialog box doesn't need to be modal. Une boîte de dialogue non modale au moins fournit un bouton Fermer pour fermer la boîte de dialogue, et peut fournir des boutons supplémentaires pour exécuter des fonctions spécifiques, comme un bouton suivant pour rechercher le mot suivant qui correspond aux critères de recherche d’une recherche de mots.A modeless dialog box at least provides a Close button to close the dialog box, and may provide additional buttons to execute specific functions, such as a Find Next button to find the next word that matches the find criteria of a word search.

Windows Presentation Foundation (WPF) vous permet de créer plusieurs types de boîtes de dialogue, notamment des boîtes de message, des boîtes de dialogue communes et des boîtes de dialogue personnalisées.Windows Presentation Foundation (WPF) allows you to create several types of dialog boxes, including message boxes, common dialog boxes, and custom dialog boxes. Cette rubrique décrit chaque, et l' exemple de boîte de dialogue fournit des exemples correspondants.This topic discusses each, and the Dialog Box Sample provides matching examples.

Boîtes de messageMessage boxes

Une boîte de message est une boîte de dialogue qui peut être utilisée pour afficher des informations textuelles et permettre aux utilisateurs de prendre des décisions avec des boutons.A message box is a dialog box that can be used to display textual information and to allow users to make decisions with buttons. L’illustration suivante montre une boîte de message qui affiche des informations textuelles, pose une question et fournit à l’utilisateur trois boutons pour répondre à la question.The following figure shows a message box that displays textual information, asks a question, and provides the user with three buttons to answer the question.

Une boîte de dialogue traitement de texte vous demandant si vous souhaitez enregistrer les modifications apportées au document avant la fermeture de l’application.

Pour créer une boîte de message, vous utilisez MessageBox la classe.To create a message box, you use the MessageBox class. MessageBoxvous permet de configurer le texte de la boîte de message, le titre, l’icône et les boutons à l’aide d’un code similaire à ce qui suit.MessageBox lets you configure the message box text, title, icon, and buttons, using code like the following.

// Configure the message box to be displayed
string messageBoxText = "Do you want to save changes?";
string caption = "Word Processor";
MessageBoxButton button = MessageBoxButton.YesNoCancel;
MessageBoxImage icon = MessageBoxImage.Warning;
' Configure the message box to be displayed
Dim messageBoxText As String = "Do you want to save changes?"
Dim caption As String = "Word Processor"
Dim button As MessageBoxButton = MessageBoxButton.YesNoCancel
Dim icon As MessageBoxImage = MessageBoxImage.Warning

Pour afficher une boîte de message, vous appelez static la Show méthode, comme illustré dans le code suivant.To show a message box, you call the staticShow method, as demonstrated in the following code.

// Display message box
MessageBox.Show(messageBoxText, caption, button, icon);
' Display message box
MessageBox.Show(messageBoxText, caption, button, icon)

Quand le code qui affiche une boîte de message doit détecter et traiter la décision de l’utilisateur (quel bouton a été enfoncé), le code peut inspecter le résultat de la boîte de message, comme indiqué dans le code suivant.When code that shows a message box needs to detect and process the user's decision (which button was pressed), the code can inspect the message box result, as shown in the following code.

// Display message box
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, button, icon);

// Process message box results
switch (result)
{
    case MessageBoxResult.Yes:
        // User pressed Yes button
        // ...
        break;
    case MessageBoxResult.No:
        // User pressed No button
        // ...
        break;
    case MessageBoxResult.Cancel:
        // User pressed Cancel button
        // ...
        break;
}
' Display message box
Dim result As MessageBoxResult = MessageBox.Show(messageBoxText, caption, button, icon)

' Process message box results
Select Case result
    Case MessageBoxResult.Yes
        ' User pressed Yes button
        ' ...
    Case MessageBoxResult.No
        ' User pressed No button
        ' ...
    Case MessageBoxResult.Cancel
        ' User pressed Cancel button
        ' ...
End Select

Pour plus d’informations sur l’utilisation des boîtes MessageBoxde message, consultez exemple MessageBoxet exemple de boîte de dialogue.For more information on using message boxes, see MessageBox, MessageBox Sample, and Dialog Box Sample.

Bien MessageBox que puisse offrir une expérience utilisateur simple de boîte de dialogue, l' MessageBox avantage de l’utilisation de est que est le seul type de fenêtre qui peut être affiché par les applications qui s’exécutent dans un bac à sable (sandbox) de sécurité de confiance partielle (voir sécurité), par exemple applications du navigateur XAML (XBAP)XAML browser applications (XBAPs).Although MessageBox may offer a simple dialog box user experience, the advantage of using MessageBox is that is the only type of window that can be shown by applications that run within a partial trust security sandbox (see Security), such as applications du navigateur XAML (XBAP)XAML browser applications (XBAPs).

La plupart des boîtes de dialogue affichent et recueillent des données plus complexes que le résultat d’une boîte de message, notamment du texte, une sélection (cases à cocher), une sélection mutuellement exclusive (boutons radio) et une sélection dans une liste (zones de liste, zones de liste modifiable, zones de liste déroulante).Most dialog boxes display and gather more complex data than the result of a message box, including text, selection (check boxes), mutually exclusive selection (radio buttons), and list selection (list boxes, combo boxes, drop-down list boxes). Pour ces, Windows Presentation Foundation (WPF) fournit plusieurs boîtes de dialogue communes et vous permet de créer vos propres boîtes de dialogue, bien que l’utilisation de soit limitée aux applications qui s’exécutent avec un niveau de confiance totale.For these, Windows Presentation Foundation (WPF) provides several common dialog boxes and allows you to create your own dialog boxes, although the use of either is limited to applications running with full trust.

Boîtes de dialogue communesCommon dialog boxes

Windows implémente une variété de boîtes de dialogue réutilisables communes à toutes les applications, y compris les boîtes de dialogue permettant d’ouvrir des fichiers, d’enregistrer des fichiers et d’imprimer.Windows implements a variety of reusable dialog boxes that are common to all applications, including dialog boxes for opening files, saving files, and printing. Ces boîtes de dialogue étant implémentées par le système d’exploitation, elles peuvent être partagées par toutes les applications qui s’exécutent sur le système d’exploitation, ce qui favorise la cohérence de l’expérience utilisateur. Quand les utilisateurs sont habitués à utiliser une boîte de dialogue fournie par le système d’exploitation dans une application, ils n’ont pas besoin d’apprendre à utiliser cette boîte de dialogue dans d’autres applications.Since these dialog boxes are implemented by the operating system, they can be shared among all the applications that run on the operating system, which helps user experience consistency; when users are familiar with the use of an operating system-provided dialog box in one application, they don't need to learn how to use that dialog box in other applications. Étant donné que ces boîtes de dialogue sont disponibles pour toutes les applications et qu’elles permettent d’offrir une expérience utilisateur cohérente, elles sont appelées boîtes de dialogue communes.Because these dialog boxes are available to all applications and because they help provide a consistent user experience, they are known as common dialog boxes.

Windows Presentation Foundation (WPF) encapsule les boîtes de dialogue courantes ouvrir un fichier, enregistrer le fichier et imprimer et les expose en tant que classes managées que vous pouvez utiliser dans des applications autonomes.Windows Presentation Foundation (WPF) encapsulates the open file, save file, and print common dialog boxes and exposes them as managed classes for you to use in standalone applications. Cette rubrique fournit une brève présentation de chacune de ces boîtes de dialogue.This topic provides a brief overview of each.

Boîte de dialogue Ouvrir un fichierOpen File dialog

La boîte de dialogue d’ouverture de fichier, illustrée ci-dessous, est utilisée par la fonctionnalité d’ouverture de fichier pour récupérer le nom d’un fichier à ouvrir.The open file dialog box, shown in the following figure, is used by file opening functionality to retrieve the name of a file to open.

Boîte de dialogue ouverte qui indique l’emplacement de récupération du fichier.

La boîte de dialogue Common Open file est implémentée OpenFileDialog en tant que classe et se Microsoft.Win32 trouve dans l’espace de noms.The common open file dialog box is implemented as the OpenFileDialog class and is located in the Microsoft.Win32 namespace. Le code suivant montre comment en créer, configurer et afficher une, et comment traiter le résultat.The following code shows how to create, configure, and show one, and how to process the result.

// Configure open file dialog box
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".txt"; // Default file extension
dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

// Show open file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process open file dialog box results
if (result == true)
{
    // Open document
    string filename = dlg.FileName;
}
' Configure open file dialog box
Dim dlg As New Microsoft.Win32.OpenFileDialog()
dlg.FileName = "Document" ' Default file name
dlg.DefaultExt = ".txt" ' Default file extension
dlg.Filter = "Text documents (.txt)|*.txt" ' Filter files by extension

' Show open file dialog box
Dim result? As Boolean = dlg.ShowDialog()

' Process open file dialog box results
If result = True Then
    ' Open document
    Dim filename As String = dlg.FileName
End If

Pour plus d’informations sur la boîte de dialogue Ouvrir un Microsoft.Win32.OpenFileDialogfichier, consultez.For more information on the open file dialog box, see Microsoft.Win32.OpenFileDialog.

Notes

OpenFileDialogpeut être utilisé pour récupérer en toute sécurité des noms de fichiers par des applications qui s’exécutent avec une confiance partielle (voir sécurité).OpenFileDialog can be used to safely retrieve file names by applications running with partial trust (see Security).

Enregistrer le fichier (boîte de dialogue)Save File dialog box

La boîte de dialogue d’enregistrement de fichier, illustrée ci-dessous, est utilisée par la fonctionnalité d’enregistrement de fichier pour récupérer le nom d’un fichier à enregistrer.The save file dialog box, shown in the following figure, is used by file saving functionality to retrieve the name of a file to save.

Une boîte de dialogue Enregistrer sous indique l’emplacement d’enregistrement du fichier.

La boîte de dialogue fichier d’enregistrement commun est implémentée en tant que SaveFileDialog classe et se trouve dans l' Microsoft.Win32 espace de noms.The common save file dialog box is implemented as the SaveFileDialog class, and is located in the Microsoft.Win32 namespace. Le code suivant montre comment en créer, configurer et afficher une, et comment traiter le résultat.The following code shows how to create, configure, and show one, and how to process the result.

// Configure save file dialog box
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".txt"; // Default file extension
dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

// Show save file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process save file dialog box results
if (result == true)
{
    // Save document
    string filename = dlg.FileName;
}
' Configure save file dialog box
Dim dlg As New Microsoft.Win32.SaveFileDialog()
dlg.FileName = "Document" ' Default file name
dlg.DefaultExt = ".txt" ' Default file extension
dlg.Filter = "Text documents (.txt)|*.txt" ' Filter files by extension

' Show save file dialog box
Dim result? As Boolean = dlg.ShowDialog()

' Process save file dialog box results
If result = True Then
    ' Save document
    Dim filename As String = dlg.FileName
End If

Pour plus d’informations sur la boîte de dialogue Enregistrer le Microsoft.Win32.SaveFileDialogfichier, consultez.For more information on the save file dialog box, see Microsoft.Win32.SaveFileDialog.

La boîte de dialogue d’impression, illustrée ci-dessous, est utilisée par la fonctionnalité d’impression pour choisir et configurer l’imprimante sur laquelle un utilisateur souhaite imprimer des données.The print dialog box, shown in the following figure, is used by printing functionality to choose and configure the printer that a user would like to print data to.

Capture d’écran montrant une boîte de dialogue Imprimer.

La boîte de dialogue d’impression courante est implémentée en tant que PrintDialog classe et se trouve dans l' System.Windows.Controls espace de noms.The common print dialog box is implemented as the PrintDialog class, and is located in the System.Windows.Controls namespace. Le code suivant montre comment en créer, configurer et afficher une.The following code shows how to create, configure, and show one.

// Configure printer dialog box
System.Windows.Controls.PrintDialog dlg = new System.Windows.Controls.PrintDialog();
dlg.PageRangeSelection = PageRangeSelection.AllPages;
dlg.UserPageRangeEnabled = true;

// Show save file dialog box
Nullable<bool> result = dlg.ShowDialog();

// Process save file dialog box results
if (result == true)
{
    // Print document
}
' Configure printer dialog box
Dim dlg As New PrintDialog()
dlg.PageRangeSelection = PageRangeSelection.AllPages
dlg.UserPageRangeEnabled = True

' Show save file dialog box
Dim result? As Boolean = dlg.ShowDialog()

' Process save file dialog box results
If result = True Then
    ' Print document
End If

Pour plus d’informations sur la boîte de dialogue Imprimer System.Windows.Controls.PrintDialog, consultez.For more information on the print dialog box, see System.Windows.Controls.PrintDialog. Pour plus d’informations sur l’impression dans WPF, consultez vue d’ensemble de l’impression.For detailed discussion of printing in WPF, see Printing Overview.

Boîtes de dialogue personnaliséesCustom dialog boxes

Bien que les boîtes de dialogue communes soient utiles (et doivent être utilisées dans la mesure du possible), elles ne prennent pas en charge les exigences des boîtes de dialogue propres au domaine.While common dialog boxes are useful, and should be used when possible, they do not support the requirements of domain-specific dialog boxes. Dans ces cas-là, vous devez créer vos propres boîtes de dialogue.In these cases, you need to create your own dialog boxes. Comme nous allons le voir, une boîte de dialogue est une fenêtre avec des comportements spéciaux.As we'll see, a dialog box is a window with special behaviors. Windowimplémente ces comportements et, par conséquent, vous utilisez Window pour créer des boîtes de dialogue modales et non modales personnalisées.Window implements those behaviors and, consequently, you use Window to create custom modal and modeless dialog boxes.

Création d’une boîte de dialogue personnalisée modaleCreating a modal custom dialog box

Cette rubrique montre comment utiliser Window pour créer une implémentation de boîte de dialogue modale standard, à l’aide de la Margins boîte de dialogue comme exemple (consultez exemple de boîte de dialogue).This topic shows how to use Window to create a typical modal dialog box implementation, using the Margins dialog box as an example (see Dialog Box Sample). La Margins boîte de dialogue est présentée dans la figure suivante.The Margins dialog box is shown in the following figure.

Boîte de dialogue marges avec des champs pour définir la marge de gauche, la marge supérieure, la marge droite et la marge inférieure.

Configuration d’une boîte de dialogue modaleConfiguring a modal dialog box

L’interface utilisateur pour une boîte de dialogue classique comprend les éléments suivants :The user interface for a typical dialog box includes the following:

  • Les différents contrôles nécessaires pour recueillir les données souhaitéesThe various controls that are required to gather the desired data.

  • Un bouton OK sur lequel les utilisateurs cliquent pour fermer la boîte de dialogue, revenir à la fonction et continuer le traitement.An OK button that users click to close the dialog box, return to the function, and continue processing.

  • Bouton Annuler sur lequel les utilisateurs cliquent pour fermer la boîte de dialogue et empêcher la fonction d’effectuer un traitement supplémentaire.A Cancel button that users click to close the dialog box and stop the function from further processing.

  • Bouton Fermer dans la barre de titre.A Close button in the title bar.

  • icône ;An icon.

  • Boutons de réduction, d' agrandissementet de restauration .Minimize, Maximize, and Restore buttons.

  • Menu système pour réduire, agrandir, restaurer et fermer la boîte de dialogue.A System menu to minimize, maximize, restore, and close the dialog box.

  • Position au-dessus et au centre de la fenêtre qui A ouvert la boîte de dialogue.A position above and in the center of the window that opened the dialog box.

  • Possibilité de redimensionner si possible pour empêcher la boîte de dialogue d’être trop petite et de fournir à l’utilisateur une taille par défaut utile.The ability to be resized where possible to prevent the dialog box from being too small, and to provide the user with a useful default size. Pour cela, vous devez définir les dimensions par défaut et les dimensions minimales.This requires that you set both the default and a minimum dimensions.

  • Touche Échap comme raccourci clavier qui entraîne l’activation du bouton Annuler .The ESC key as a keyboard shortcut that causes the Cancel button to be pressed. Pour ce faire, affectez IsCancel la valeur à truela propriété du bouton Annuler.You do this by setting the IsCancel property of the Cancel button to true.

  • Touche entrée (ou retour) sous la forme d’un raccourci clavier qui entraîne l’appui sur le bouton OK .The ENTER (or RETURN) key as a keyboard shortcut that causes the OK button to be pressed. Pour ce faire, vous devez IsDefault définir la propriété du bouton true OK .You do this by setting the IsDefault property of the OK button true.

Le code suivant illustre cette configuration.The following code demonstrates this configuration.

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

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {
        public MarginsDialogBox()
        {
            InitializeComponent();
        }
    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace SDKSample
    Public Class MarginsDialogBox
        Inherits Window

        Public Sub New()
            Me.InitializeComponent()
        End Sub
    End Class
End Namespace

L’expérience utilisateur pour une boîte de dialogue s’étend également à la barre de menus de la fenêtre qui ouvre la boîte de dialogue.The user experience for a dialog box also extends into the menu bar of the window that opens the dialog box. Quand un élément de menu exécute une fonction qui nécessite une interaction utilisateur par l’intermédiaire d’une boîte de dialogue pour que la fonction puisse se poursuivre, l’élément de menu de la fonction a des points de suspension dans son en-tête, comme illustré ici.When a menu item runs a function that requires user interaction through a dialog box before the function can continue, the menu item for the function will have an ellipsis in its header, as shown here.

<!--Main Window-->
<MenuItem Name="formatMarginsMenuItem" Header="_Margins..." Click="formatMarginsMenuItem_Click" />

Quand un élément de menu exécute une fonction qui affiche une boîte de dialogue qui ne nécessite pas d’intervention de l’utilisateur, par exemple une boîte de dialogue À propos, les points de suspension ne sont pas nécessaires.When a menu item runs a function that displays a dialog box which does not require user interaction, such as an About dialog box, an ellipsis is not required.

Ouverture d’une boîte de dialogue modaleOpening a modal dialog box

Une boîte de dialogue apparaît généralement quand un utilisateur sélectionne un élément de menu pour exécuter une fonction propre à un domaine, par exemple pour définir les marges d’un document dans un traitement de texte.A dialog box is typically shown as a result of a user selecting a menu item to perform a domain-specific function, such as setting the margins of a document in a word processor. Afficher une fenêtre sous forme de boîte de dialogue s’apparente à afficher une fenêtre normale, bien que cela nécessite une configuration supplémentaire propre à la boîte de dialogue.Showing a window as a dialog box is similar to showing a normal window, although it requires additional dialog box-specific configuration. L’ensemble du processus d’instanciation, de configuration et d’ouverture d’une boîte de dialogue est illustré dans le code suivant.The entire process of instantiating, configuring, and opening a dialog box is shown in the following code.

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

namespace SDKSample
{
    public partial class MainWindow : Window
    {
        bool needsToBeSaved;
        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();
        }
    }
}
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

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

Ici, le code passe les informations par défaut (les marges actuelles) à la boîte de dialogue.Here, the code passes default information (the current margins) to the dialog box. Elle définit également la Window.Owner propriété avec une référence à la fenêtre qui présente la boîte de dialogue.It also sets the Window.Owner property with a reference to the window that is showing the dialog box. En général, vous devez toujours définir le propriétaire d’une boîte de dialogue pour fournir les comportements liés à l’état de la fenêtre qui sont communs à toutes les boîtes de dialogue (consultez vue d’ensemble des fenêtres WPF pour plus d’informations).In general, you should always set the owner for a dialog box to provide window state-related behaviors that are common to all dialog boxes (see WPF Windows Overview for more information).

Notes

Vous devez fournir un propriétaire pour prendre en charge l’automatisation de l’interface utilisateur pour les boîtes de dialogue (consultez vue d’ensemble d’UI Automation).You must provide an owner to support user interface (UI) automation for dialog boxes (see UI Automation Overview).

Une fois la boîte de dialogue configurée, elle s’affiche de façon modale en appelant la ShowDialog méthode.After the dialog box is configured, it is shown modally by calling the ShowDialog method.

Validation des données fournies par l’utilisateurValidating user-provided data

Quand une boîte de dialogue est ouverte et que l’utilisateur fournit les données requises, une boîte de dialogue est chargée de vérifier que les données fournies sont valides pour les raisons suivantes :When a dialog box is opened and the user provides the required data, a dialog box is responsible for ensuring that the provided data is valid for the following reasons:

  • Du point de vue de la sécurité, toutes les entrées doivent être validées.From a security perspective, all input should be validated.

  • D’un point de vue propre au domaine, la validation des données empêche que des données erronées soient traitées par le code, ce qui pourrait éventuellement lever des exceptions.From a domain-specific perspective, data validation prevents erroneous data from being processed by the code, which could potentially throw exceptions.

  • Du point de vue de l’expérience utilisateur, une boîte de dialogue peut aider les utilisateurs en leur montrant lesquelles des données entrées ne sont pas valides.From a user-experience perspective, a dialog box can help users by showing them which data they have entered is invalid.

  • Du point de vue des performances, la validation des données dans une application multicouche peut réduire le nombre d’allers-retours entre le client et les couches Application, en particulier quand l’application est composée de services web ou de bases de données basées sur serveur.From a performance perspective, data validation in a multi-tier application can reduce the number of round trips between the client and the application tiers, particularly when the application is composed of Web services or server-based databases.

Pour valider un contrôle lié dans WPF, vous devez définir une règle de validation et l’associer à la liaison.To validate a bound control in WPF, you need to define a validation rule and associate it with the binding. Une règle de validation est une classe personnalisée qui dérive ValidationRulede.A validation rule is a custom class that derives from ValidationRule. L’exemple suivant montre une règle de validation MarginValidationRule,, qui vérifie qu’une valeur liée est Double un et se trouve dans une plage spécifiée.The following example shows a validation rule, MarginValidationRule, which checks that a bound value is a Double and is within a specified range.

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

Dans ce code, la logique de validation d’une règle de validation est implémentée en Validate remplaçant la méthode, qui valide les données et retourne un ValidationResultapproprié.In this code, the validation logic of a validation rule is implemented by overriding the Validate method, which validates the data and returns an appropriate ValidationResult.

Pour associer la règle de validation au contrôle dépendant, vous utilisez le balisage suivant.To associate the validation rule with the bound control, you use the following markup.

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

    <!-- Left Margin -->
    <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>
  </Grid >
</Window>

Une fois la règle de validation associée, WPF l’applique automatiquement lorsque les données sont entrées dans le contrôle lié.Once the validation rule is associated, WPF will automatically apply it when data is entered into the bound control. Lorsqu’un contrôle contient des données non valides, WPF affiche une bordure rouge autour du contrôle non valide, comme indiqué dans l’illustration suivante.When a control contains invalid data, WPF will display a red border around the invalid control, as shown in the following figure.

Boîte de dialogue marges avec une bordure rouge autour de la valeur de marge de gauche non valide.

WPF ne limite pas un utilisateur au contrôle non valide tant qu’il n’a pas entré de données valides.WPF does not restrict a user to the invalid control until they have entered valid data. Il s’agit d’un bon comportement pour une boîte de dialogue. En effet, un utilisateur doit pouvoir naviguer librement entre les contrôles d’une boîte de dialogue, que les données soient valides ou non.This is good behavior for a dialog box; a user should be able to freely navigate the controls in a dialog box whether or not data is valid. Toutefois, cela signifie qu’un utilisateur peut entrer des données non valides et appuyer sur le bouton OK .However, this means a user can enter invalid data and press the OK button. Pour cette raison, votre code doit également valider tous les contrôles dans une boîte de dialogue lorsque le bouton OK est enfoncé en gérant Click l’événement.For this reason, your code also needs to validate all controls in a dialog box when the OK button is pressed by handling the Click event.

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

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;
        }
    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

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

Ce code énumère tous les objets de dépendance sur une fenêtre et, si ceux-ci sont non valides (tels qu’ils sont retournés par GetHasError, falsele contrôle non valide obtient le focus, la IsValid méthode retourne et la fenêtre est considérée comme non valide.This code enumerates all dependency objects on a window and, if any are invalid (as returned by GetHasError, the invalid control gets the focus, the IsValid method returns false, and the window is considered invalid.

Une fois qu’une boîte de dialogue est valide, elle peut être fermée et retourner un résultat en toute sécurité.Once a dialog box is valid, it can safely close and return. Dans le cadre du processus de retour, elle doit retourner un résultat à la fonction appelante.As part of the return process, it needs to return a result to the calling function.

Définition du résultat de la boîte de dialogue modaleSetting the modal dialog result

L’ouverture d’une boîte ShowDialog de dialogue à l’aide de est fondamentalement semblable à l’appel d’une méthode: ShowDialog le code qui ShowDialog a ouvert la boîte de dialogue à l’aide de attend jusqu’à ce que retourne.Opening a dialog box using ShowDialog is fundamentally like calling a method: the code that opened the dialog box using ShowDialog waits until ShowDialog returns. Lorsque ShowDialog retourne, le code qui l’a appelé doit décider s’il faut continuer le traitement ou arrêter le traitement, selon que l’utilisateur a appuyé sur le bouton OK ou sur le bouton Annuler .When ShowDialog returns, the code that called it needs to decide whether to continue processing or stop processing, based on whether the user pressed the OK button or the Cancel button. Pour faciliter cette décision, la boîte de dialogue doit retourner le choix de l’utilisateur sous Boolean la forme d’une valeur retournée par la ShowDialog méthode.To facilitate this decision, the dialog box needs to return the user's choice as a Boolean value that is returned from the ShowDialog method.

Lorsque l' utilisateur clique sur le bouton ShowDialog OK, truedoit retourner.When the OK button is clicked, ShowDialog should return true. Pour ce faire, définissez la DialogResult propriété de la boîte de dialogue lorsque l’utilisateur clique sur le bouton OK .This is achieved by setting the DialogResult property of the dialog box when the OK button is clicked.

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

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {

        void okButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
        }
    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace SDKSample
    Public Class MarginsDialogBox
        Inherits Window

        Private Sub okButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Dialog box accepted
            MyBase.DialogResult = New Nullable(Of Boolean)(True)
        End Sub
    End Class
End Namespace

Notez que la définition DialogResult de la propriété entraîne également la fermeture automatique de la fenêtre, ce qui évite d’avoir Closeà appeler explicitement.Note that setting the DialogResult property also causes the window to close automatically, which alleviates the need to explicitly call Close.

Quand l' utilisateur clique sur le bouton ShowDialog annuler, falsedoit retourner, ce qui nécessite DialogResult également la définition de la propriété.When the Cancel button is clicked, ShowDialog should return false, which also requires setting the DialogResult property.

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

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {

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

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

Lorsque la propriété d' IsCancel un bouton a la true valeur et que l’utilisateur appuie sur le bouton Annuler ou la touche DialogResult falseÉCHAP, a automatiquement la valeur.When a button's IsCancel property is set to true and the user presses either the Cancel button or the ESC key, DialogResult is automatically set to false. Le balisage suivant a le même effet que le code précédent, sans qu’il soit nécessaire Click de gérer l’événement.The following markup has the same effect as the preceding code, without the need to handle the Click event.

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

Une boîte de dialogue s' false affiche automatiquement lorsqu’un utilisateur appuie sur le bouton Fermer dans la barre de titre ou choisit l’élément de menu Fermer dans le menu système .A dialog box automatically returns false when a user presses the Close button in the title bar or chooses the Close menu item from the System menu.

Traitement des données retournées par une boîte de dialogue modaleProcessing data returned from a modal dialog box

Lorsque DialogResult est défini par une boîte de dialogue, la fonction qui l’a ouvert peut obtenir le résultat de la boîte de DialogResult dialogue en ShowDialog inspectant la propriété lorsque retourne.When DialogResult is set by a dialog box, the function that opened it can get the dialog box result by inspecting the DialogResult property when ShowDialog returns.

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

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;
            }
        }
    }
}
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

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

Si le résultat de la trueboîte de dialogue est, la fonction l’utilise en tant que signal pour récupérer et traiter les données fournies par l’utilisateur.If the dialog result is true, the function uses that as a cue to retrieve and process the data provided by the user.

Notes

Une ShowDialog fois retourné, une boîte de dialogue ne peut pas être rouverte.After ShowDialog has returned, a dialog box cannot be reopened. Au lieu de cela, vous devez créer une nouvelle instance.Instead, you need to create a new instance.

Si le résultat de la falseboîte de dialogue est, la fonction doit terminer le traitement de manière appropriée.If the dialog result is false, the function should end processing appropriately.

Création d’une boîte de dialogue personnalisée non modaleCreating a modeless custom dialog box

Une boîte de dialogue non modale, telle que la boîte de dialogue Rechercher affichée ci-dessous, a la même apparence fondamentale que la boîte de dialogue modale.A modeless dialog box, such as the Find Dialog Box shown in the following figure, has the same fundamental appearance as the modal dialog box.

Capture d’écran montrant une boîte de dialogue Rechercher.

Toutefois, le comportement est légèrement différent, comme décrit dans les sections suivantes.However, the behavior is slightly different, as described in the following sections.

Ouverture d’une boîte de dialogue non modaleOpening a modeless dialog box

Une boîte de dialogue non modale est ouverte en Show appelant la méthode.A modeless dialog box is opened by calling the Show method.

<!--Main Window-->
<MenuItem Name="editFindMenuItem" Header="_Find" InputGestureText="Ctrl+F" Click="editFindMenuItem_Click" />
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

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();
        }
    }
}
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

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
    End Class
End Namespace

Contrairement ShowDialogà Show , retourne immédiatement.Unlike ShowDialog, Show returns immediately. Ainsi, la fenêtre appelante ne peut pas savoir quand la boîte de dialogue non modale est fermée, et ne sait pas quand vérifier le résultat d’une boîte de dialogue ou obtenir des données à partir de la boîte de dialogue pour un traitement ultérieur.Consequently, the calling window cannot tell when the modeless dialog box is closed and, therefore, does not know when to check for a dialog box result or get data from the dialog box for further processing. Au lieu de cela, la boîte de dialogue doit créer un autre moyen pour retourner des données à la fenêtre appelante en vue de leur traitement.Instead, the dialog box needs to create an alternative way to return data to the calling window for processing.

Traitement des données retournées par une boîte de dialogue non modaleProcessing data returned from a modeless dialog box

Dans cet exemple, FindDialogBox peut retourner un ou plusieurs résultats de recherche à la fenêtre principale, en fonction du texte recherché sans fréquence spécifique.In this example, the FindDialogBox may return one or more find results to the main window, depending on the text being searched for without any specific frequency. Comme avec une boîte de dialogue modale, une boîte de dialogue non modale peut retourner des résultats à l’aide de propriétés.As with a modal dialog box, a modeless dialog box can return results using properties. Toutefois, la fenêtre propriétaire de la boîte de dialogue doit savoir quand vérifier ces propriétés.However, the window that owns the dialog box needs to know when to check those properties. L’une des solutions consiste à ce que la boîte de dialogue implémente un événement déclenché chaque fois que le texte est trouvé.One way to enable this is for the dialog box to implement an event that is raised whenever text is found. FindDialogBoximplémente TextFoundEvent à cet effet, qui requiert d’abord un délégué.FindDialogBox implements the TextFoundEvent for this purpose, which first requires a delegate.

using System;

namespace SDKSample
{
    public delegate void TextFoundEventHandler(object sender, EventArgs e);
}
Namespace SDKSample
   Public Delegate Sub TextFoundEventHandler(ByVal sender As Object, ByVal e As EventArgs)
End Namespace

À l' TextFoundEventHandler aide du FindDialogBox délégué, implémente TextFoundEvent.Using the TextFoundEventHandler delegate, FindDialogBox implements the TextFoundEvent.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Text.RegularExpressions;

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

    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Text.RegularExpressions

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

Par conséquent Find , peut déclencher l’événement lorsqu’un résultat de recherche est trouvé.Consequently, Find can raise the event when a search result is found.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Text.RegularExpressions;

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();
        }
    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Text.RegularExpressions

Namespace SDKSample

    Public Class FindDialogBox
        Inherits Window



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

    End Class
End Namespace

La fenêtre propriétaire doit ensuite s’inscrire pour cet événement et le gérer.The owner window then needs to register with and handle this event.

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

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();
        }
    }
}
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

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

Fermeture d’une boîte de dialogue non modaleClosing a modeless dialog box

Étant DialogResult donné qu’elle n’a pas besoin d’être définie, une boîte de dialogue non modale peut être fermée à l’aide de mécanismes fournis par le système, notamment les suivants:Because DialogResult does not need to be set, a modeless dialog can be closed using system provide mechanisms, including the following:

  • Cliquez sur le bouton Fermer dans la barre de titre.Clicking the Close button in the title bar.

  • en appuyant sur Alt+F4 ;Pressing ALT+F4.

  • Choisissez Fermer dans le menu système .Choosing Close from the System menu.

Votre code peut également appeler Close lorsque l’utilisateur clique sur le bouton Fermer .Alternatively, your code can call Close when the Close button is clicked.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Text.RegularExpressions;

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {

        void closeButton_Click(object sender, RoutedEventArgs e)
        {
            // Close dialog box
            this.Close();
        }
    }
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Text.RegularExpressions

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

Voir aussiSee also