Cenni preliminari sulle finestre di dialogoDialog Boxes Overview

Applicazioni autonome sono in genere una finestra principale in cui vengono visualizzati i dati principali in cui viene eseguita l'applicazione ed espone la funzionalità di elaborazione dei dati tramite interfaccia utenteuser interface (UI) meccanismi come barre dei menu, barre degli strumenti e le barre di stato.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 interfaccia utenteuser interface (UI) mechanisms like menu bars, tool bars, and status bars. In un'applicazione più complessa sono inoltre disponibili finestre aggiuntive per l'esecuzione delle operazioni riportate di seguito:A non-trivial application may also display additional windows to do the following:

  • Visualizzazione di informazioni specifiche agli utenti.Display specific information to users.

  • Raccolta delle informazioni immesse dagli utenti.Gather information from users.

  • Visualizzazione e raccolta di informazioni.Both display and gather information.

Questi tipi di windows sono note come finestre di dialogo, e sono disponibili due tipi: modali e non modali.These types of windows are known as dialog boxes, and there are two types: modal and modeless.

Oggetto modale la finestra di dialogo viene visualizzata da una funzione quando la funzione richiede dati aggiuntivi da un utente di continuare.A modal dialog box is displayed by a function when the function needs additional data from a user to continue. Poiché la raccolta dei dati da parte della funzione dipende dalla finestra di dialogo modale, finché quest'ultima rimane aperta l'utente non potrà attivare altre finestre nell'applicazione.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. Nella maggior parte dei casi, una finestra di dialogo modale consente a un utente segnalare quando hanno finito con la finestra di dialogo modale premendo un OK o Annulla pulsante.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. Premendo il OK pulsante indica che un utente ha immesso dati che desidera continuare l'elaborazione dei dati dalla funzione.Pressing the OK button indicates that a user has entered data and wants the function to continue processing with that data. Premendo il Annulla pulsante indica che un utente desidera arrestare l'esecuzione della funzione.Pressing the Cancel button indicates that a user wants to stop the function from executing altogether. Gli esempi più comuni di finestre di dialogo modali sono dati dalle finestre di apertura, salvataggio e stampa dei dati.The most common examples of modal dialog boxes are shown to open, save, and print data.

Oggetto non modale la finestra di dialogo, d'altra parte, non impedisce a un utente di attivare altre finestre mentre è aperto.A modeless dialog box, on the other hand, does not prevent a user from activating other windows while it is open. Ad esempio, se un utente desidera cercare occorrenze di una determinata parola in un documento, dalla finestra principale verrà spesso aperta una finestra di dialogo in cui l'utente dovrà immettere la parola che desidera cercare.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. Poiché la ricerca di una parola non impedisce all'utente di modificare il documento, la finestra di dialogo non deve essere modale.Since finding a word doesn't prevent a user from editing the document, however, the dialog box doesn't need to be modal. Una finestra di dialogo non modale fornisce almeno un chiudere per chiudere la finestra di dialogo e può fornire pulsanti aggiuntivi per eseguire funzioni specifiche, ad esempio un Trova successivo per trovare la successiva di word che corrisponde ai criteri di ricerca di una parola.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) consente di creare diversi tipi di finestre di dialogo, incluse le finestre di messaggio, finestre di dialogo comuni e finestre di dialogo personalizzate.Windows Presentation Foundation (WPF) allows you to create several types of dialog boxes, including message boxes, common dialog boxes, and custom dialog boxes. In questo argomento vengono illustrate le singole e esempio finestra di dialogo sono disponibili alcuni esempi.This topic discusses each, and the Dialog Box Sample provides matching examples.

Finestre di messaggioMessage Boxes

Oggetto finestra di messaggio è una finestra di dialogo che può essere utilizzata per visualizzare informazioni testuali e consentire agli utenti di prendere decisioni con i pulsanti.A message box is a dialog box that can be used to display textual information and to allow users to make decisions with buttons. Di seguito è illustrata una finestra di messaggio in cui vengono visualizzate informazioni di testo, viene posta una domanda e sono disponibili tre pulsanti per fornire una risposta.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.

Finestra di dialogo Elaboratore di testoWord Processor dialog box

Per creare una finestra di messaggio, utilizzare la MessageBox classe.To create a message box, you use the MessageBox class. MessageBox Consente di configurare il testo della finestra di messaggio, titolo, icona e i pulsanti, utilizzando codice simile al seguente.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

Per visualizzare una finestra di messaggio, si chiama il static Show (metodo), come illustrato nel codice seguente.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)

Quando il codice per la visualizzazione di una finestra di messaggio deve rilevare ed elaborare la decisione dell'utente (quale pulsante è stato premuto), può analizzare il risultato della finestra di messaggio, come illustrato nel codice riportato di seguito.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

Per ulteriori informazioni sull'utilizzo delle finestre di messaggio, vedere MessageBox, esempio MessageBox, e esempio finestra di dialogo.For more information on using message boxes, see MessageBox, MessageBox Sample, and Dialog Box Sample.

Sebbene MessageBox può offrire una semplice finestra di dialogo dell'utente, il vantaggio dell'utilizzo MessageBox è l'unico tipo di finestra che può essere visualizzata dalle applicazioni in esecuzione in un sandbox di sicurezza parzialmente attendibile (vedere sicurezza), ad esempio applicazioni browser 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 applicazioni browser XAML (XBAP)XAML browser applications (XBAPs).

Nella maggior parte delle finestre di dialogo vengono visualizzati e raggruppati dati più complessi del risultato di una finestra di messaggio, ad esempio testo, selezione (caselle di controllo), selezione a esclusione reciproca (pulsanti di opzione) e selezione in elenchi (caselle di riepilogo, caselle combinate, elenchi a discesa).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). Per tali file, Windows Presentation Foundation (WPF) fornisce diverse finestre di dialogo comuni e consente di creare finestre di dialogo, anche se l'utilizzo di uno è limitato alle applicazioni in esecuzione con attendibilità 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.

Finestre di dialogo comuniCommon Dialog Boxes

In WindowsWindows è implementata una varietà di finestre di dialogo riutilizzabili comuni a tutte le applicazioni, incluse le finestre di dialogo per l'apertura, il salvataggio e la stampa di file.WindowsWindows implements a variety of reusable dialog boxes that are common to all applications, including dialog boxes for opening files, saving files, and printing. Poiché queste finestre di dialogo sono implementate dal sistema operativo, possono essere condivise da tutte le applicazioni eseguite nel sistema operativo, con notevoli vantaggi in termini della coerenza di utilizzo: se un utente utilizza con frequenza una finestra di dialogo basata sul sistema operativo in un'applicazione, non dovrà imparare a utilizzare la stessa finestra in altre applicazioni.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. Poiché queste finestre di dialogo sono disponibili per tutte le applicazioni e poiché consentono un'esperienza utente coerente, sono note come finestre di dialogo comuni.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) incapsula i file aperti, salvare file, finestre di dialogo comuni di stampa e li espone come classi gestite da utilizzare in applicazioni autonome.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. Questo argomento fornisce alcuni cenni preliminari su ognuna.This topic provides a brief overview of each.

Finestra di dialogo ApriOpen File Dialog

La finestra di dialogo Apri illustrata di seguito viene utilizzata dalla funzionalità di apertura file per recuperare il nome di un file da aprire.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.

Finestra di dialogo ApriOpen dialog box

La finestra di dialogo Apri file comune viene implementato come il OpenFileDialog classe e si trova nel Microsoft.Win32 dello spazio dei nomi.The common open file dialog box is implemented as the OpenFileDialog class and is located in the Microsoft.Win32 namespace. Il codice seguente illustra come creare, configurare e visualizzare questa finestra di dialogo, nonché come elaborare il relativo risultato.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

Per ulteriori informazioni sulla finestra di dialogo Apri file, vedere Microsoft.Win32.OpenFileDialog.For more information on the open file dialog box, see Microsoft.Win32.OpenFileDialog.

Nota

OpenFileDialog Consente di recuperare in modo sicuro i nomi file da applicazioni in esecuzione con attendibilità parziale (vedere sicurezza).OpenFileDialog can be used to safely retrieve file names by applications running with partial trust (see Security).

Finestra di dialogo Salva con nomeSave File Dialog Box

La finestra di dialogo Salva con nome illustrata di seguito viene utilizzata dalla funzionalità di salvataggio file per recuperare il nome di un file da salvare.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.

Finestra di dialogo Salva con nomeSave As dialog box

La finestra Salva la finestra di dialogo file comune viene implementata come il SaveFileDialog classe e si trova nel Microsoft.Win32 dello spazio dei nomi.The common save file dialog box is implemented as the SaveFileDialog class, and is located in the Microsoft.Win32 namespace. Il codice seguente illustra come creare, configurare e visualizzare questa finestra di dialogo, nonché come elaborare il relativo risultato.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 = ".text"; // 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 = ".text" ' 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

Per ulteriori informazioni sul salvataggio di file la finestra di dialogo, vedere Microsoft.Win32.SaveFileDialog.For more information on the save file dialog box, see Microsoft.Win32.SaveFileDialog.

La finestra di dialogo Stampa illustrata di seguito viene utilizzata dalla funzionalità di stampa per la scelta e la configurazione della stampante su cui stampare dati.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.

Finestra di dialogo StampaPrint dialog box

La finestra di dialogo Stampa comune viene implementato come il PrintDialog classe e si trova nel System.Windows.Controls dello spazio dei nomi.The common print dialog box is implemented as the PrintDialog class, and is located in the System.Windows.Controls namespace. Il codice seguente illustra come creare, configurare e visualizzare una finestra di dialogo di questo tipo.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

Per ulteriori informazioni sulla finestra di dialogo Stampa, vedere System.Windows.Controls.PrintDialog.For more information on the print dialog box, see System.Windows.Controls.PrintDialog. Per informazioni dettagliate sulla stampa in WPFWPF, vedere Panoramica della stampa.For detailed discussion of printing in WPFWPF, see Printing Overview.

Finestre di dialogo personalizzateCustom Dialog Boxes

Sebbene le finestre di dialogo comuni siano utili e debbano essere utilizzate quando possibile, non supportano i requisiti delle finestre di dialogo specifiche di vari domini.While common dialog boxes are useful, and should be used when possible, they do not support the requirements of domain-specific dialog boxes. In questi casi, è necessario creare finestre di dialogo personalizzate.In these cases, you need to create your own dialog boxes. Come verrà illustrato in seguito, una finestra di dialogo è una finestra con particolari comportamenti.As we'll see, a dialog box is a window with special behaviors. Window implementa tali comportamenti e, pertanto, si utilizza Window per creare finestre di dialogo modali e non modali personalizzate.Window implements those behaviors and, consequently, you use Window to create custom modal and modeless dialog boxes.

Creazione di una finestra di dialogo modale personalizzataCreating a Modal Custom Dialog Box

In questo argomento viene illustrato come utilizzare Window per creare un'implementazione tipica di finestra di dialogo modale, utilizzando il Margins la finestra di dialogo ad esempio (vedere esempio finestra di dialogo).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). Il Margins la finestra di dialogo è illustrata nella figura riportata di seguito.The Margins dialog box is shown in the following figure.

Finestra di dialogo MarginiMargins dialog box

Configurazione di una finestra di dialogo modaleConfiguring a Modal Dialog Box

L'interfaccia utente di una finestra di dialogo tipica include gli elementi riportati di seguito:The user interface for a typical dialog box includes the following:

  • I diversi controlli necessari per raccogliere i dati desiderati.The various controls that are required to gather the desired data.

  • Che mostra un OK pulsante che gli utenti, fare clic per chiudere la finestra di dialogo, torna alla funzione e continuare l'elaborazione.Showing an OK button that users click to close the dialog box, return to the function, and continue processing.

  • Che mostra un Annulla pulsante che gli utenti fanno clic per chiudere la finestra di dialogo e interrompere l'elaborazione da parte della funzione.Showing a Cancel button that users click to close the dialog box and stop the function from further processing.

  • Che mostra un Chiudi pulsante nella barra del titolo.Showing a Close button in the title bar.

  • Un'icona.Showing an icon.

  • Visualizzazione Riduci a icona, Ingrandisci, e ripristinare pulsanti.Showing Minimize, Maximize, and Restore buttons.

  • Che mostra un sistema menu per ridurre al minimo, ingrandire, ripristinare e chiudere la finestra di dialogo.Showing a System menu to minimize, maximize, restore, and close the dialog box.

  • L'apertura sopra e al centro della finestra da cui è stata aperta la finestra di dialogo.Opening above and in the center of the window that opened the dialog box.

  • Poiché le finestre di dialogo devono essere, per quanto possibile, ridimensionabili, per impedire che diventino troppo piccole e per fornire utili dimensioni predefinite, è necessario impostare sia dimensioni minime sia dimensioni predefinite.Dialog boxes should be resizable where possible so, to prevent the dialog box from being too small, and to provide the user with a useful default size, you need to set both default and a minimum dimensions respectively.

  • Premendo il tasto ESC deve essere configurato come un tasto di scelta rapida che causa il Annulla pulsante premuto.Pressing the ESC key should be configured as a keyboard shortcut that causes the Cancel button to be pressed. Questo risultato si ottiene impostando il IsCancel proprietà del Annulla pulsante true.This is achieved by setting the IsCancel property of the Cancel button to true.

  • Premendo il tasto INVIO (o restituito) deve essere configurato come un tasto di scelta rapida che causa il OK pulsante premuto.Pressing the ENTER (or RETURN) key should be configured as a keyboard shortcut that causes the OK button to be pressed. Questo risultato si ottiene impostando il IsDefault proprietà del OK pulsante true.This is achieved by setting the IsDefault property of the OK button true.

Il codice seguente illustra questa configurazione.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'esperienza utente relativa all'utilizzo di una finestra di dialogo si estende anche alla barra dei menu della finestra da cui viene aperta la finestra di dialogo.The user experience for a dialog box also extends into the menu bar of the window that opens the dialog box. Quando una voce di menu attiva una funzione la cui elaborazione richiede interazione da parte dell'utente tramite una finestra di dialogo, nell'intestazione della voce di menu saranno visibili dei puntini di sospensione, come illustrato di seguito.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" />

Quando una voce di menu attiva una funzione che comporta la visualizzazione di una finestra di dialogo che non richiede interazione da parte dell'utente, ad esempio una finestra di dialogo Informazioni su, i puntini di sospensione non sono necessari.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.

Apertura di una finestra di dialogo modaleOpening a Modal Dialog Box

Una finestra di dialogo viene in genere visualizzata in seguito alla selezione, da parte dell'utente, di una voce di menu per l'esecuzione di una funzione specifica di un dominio, ad esempio l'impostazione dei margini di un documento in un elaboratore di testo.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. La visualizzazione di una finestra come una finestra di dialogo è simile alla visualizzazione di una normale finestra, sebbene richieda operazioni di configurazione specifiche.Showing a window as a dialog box is similar to showing a normal window, although it requires additional dialog box-specific configuration. L'intero processo di creazione di un'istanza, configurazione e apertura di una finestra di dialogo viene illustrato nel codice riportato di seguito.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
    {

Imports System
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

Namespace SDKSample

Public Class MainWindow
    Inherits 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();

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

In questo punto del codice, le informazioni predefinite (i margini correnti) vengono passate alla finestra di dialogo.Here, the code is passing default information (the current margins) to the dialog box. Viene inoltre impostata la Window.Owner proprietà con un riferimento alla finestra da cui viene visualizzata la finestra di dialogo.It is also setting the Window.Owner property with a reference to the window that is showing the dialog box. In generale, è necessario impostare sempre il proprietario di una finestra di dialogo per fornire i comportamenti correlati allo stato di finestra sono comuni a tutte le finestre di dialogo (vedere WPF Windows Overview per altre informazioni).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).

Nota

È necessario specificare un proprietario per supportare interfaccia utenteuser interface (UI) automazione per le finestre di dialogo (vedere Panoramica di automazione dell'interfaccia utente).You must provide an owner to support interfaccia utenteuser interface (UI) automation for dialog boxes (see UI Automation Overview).

Dopo aver configurata la finestra di dialogo, viene visualizzato come form modale chiamando il ShowDialog metodo.After the dialog box is configured, it is shown modally by calling the ShowDialog method.

Convalida di dati forniti dall'utenteValidating User-Provided Data

Quando viene aperta una finestra di dialogo e l'utente fornisce i dati necessari, la finestra di dialogo deve garantire che i dati forniti siano validi per i motivi riportati di seguito: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:

  • Da un punto di vista della sicurezza, tutti gli input devono essere convalidati.From a security perspective, all input should be validated.

  • Da un punto di vista specifico del dominio, la convalida dei dati impedisce l'elaborazione di dati errati da parte del codice, che potrebbe potenzialmente generare eccezioni.From a domain-specific perspective, data validation prevents erroneous data from being processed by the code, which could potentially throw exceptions.

  • Da un punto di vista dell'esperienza utente, una finestra di dialogo può aiutare l'utente mostrandogli quali dati immessi non sono validi.From a user-experience perspective, a dialog box can help users by showing them which data they have entered is invalid.

  • Da un punto di vista delle prestazioni, la convalida dei dati in un'applicazione a più livelli può ridurre il numero di round trip tra il client e i livelli dell'applicazione, in particolare se l'applicazione è composta da servizi Web o database basati su server.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.

Per convalidare un controllo associato in WPFWPF, è necessario definire una regola di convalida e associarlo con l'associazione.To validate a bound control in WPFWPF, you need to define a validation rule and associate it with the binding. Una regola di convalida è una classe personalizzata che deriva da ValidationRule.A validation rule is a custom class that derives from ValidationRule. Nell'esempio seguente viene illustrata una regola di convalida, MarginValidationRule, che verifica che un valore associato è un Double e si trova all'interno di un intervallo specificato.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

In questo codice, viene implementata la logica di convalida di una regola di convalida eseguendo l'override di Validate metodo, che convalida i dati e restituisce un oggetto appropriato ValidationResult.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.

Per abbinare la regola di convalida al controllo associato, utilizzare il markup riportato di seguito.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>
    
<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>

Una volta associata, la regola di convalida WPFWPF verranno automaticamente applicati quando vengono immessi dati nel controllo associato.Once the validation rule is associated, WPFWPF will automatically apply it when data is entered into the bound control. Quando un controllo contiene dati non validi, WPFWPF verrà visualizzato un bordo rosso intorno al controllo non valido, come illustrato nella figura seguente.When a control contains invalid data, WPFWPF will display a red border around the invalid control, as shown in the following figure.

Margine sinistro non validoInvalid left margin

In WPFWPF l'utente non rimane bloccato sul controllo non valido finché non vengono immessi dati validi.WPFWPF does not restrict a user to the invalid control until they have entered valid data. In questo modo, l'utente sarà libero di spostarsi tra i controlli della finestra di dialogo anche se i dati immessi non sono validi.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. Tuttavia, questo significa che un utente può immettere dati non validi e premere il OK pulsante.However, this means a user can enter invalid data and press the OK button. Per questo motivo, il codice deve anche convalidare tutti i controlli in una finestra di dialogo quando il OK pulsante gestendo il Click evento.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
    {
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window
void okButton_Click(object sender, RoutedEventArgs e)
{
    // Don't accept the dialog box if there is invalid data
    if (!IsValid(this)) return;
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
        }

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

Questo codice enumera tutti gli oggetti di dipendenza in una finestra e, se presenti non validi (restituito da GetHasError, il controllo non valido Ottiene lo stato attivo, il IsValid restituisce false, e la finestra è considerata non valida.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.

Dopo essere stata ritenuta valida, la finestra di dialogo può essere chiusa.Once a dialog box is valid, it can safely close and return. Questo processo deve inoltre prevedere la restituzione di un risultato alla funzione chiamante.As part of the return process, it needs to return a result to the calling function.

Impostazione del risultato di una finestra di dialogo modaleSetting the Modal Dialog Result

Aprire una finestra di dialogo utilizzando ShowDialog è sostanzialmente equivalente alla chiamata a un metodo: il codice che ha aperto la finestra di dialogo utilizzando ShowDialog attende fino a quando ShowDialog restituisce.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. Quando ShowDialog restituisce, il codice che ha chiamato deve decidere se continuare o arrestare l'elaborazione, a seconda che l'utente ha premuto il OK pulsante o Annulla pulsante.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. Per facilitare questa decisione, la finestra di dialogo deve restituire la scelta dell'utente come un Boolean valore restituito dal ShowDialog metodo.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.

Quando il OK pulsante ShowDialog deve restituire true.When the OK button is clicked, ShowDialog should return true. Questo risultato si ottiene impostando il DialogResult casella di proprietà della finestra di dialogo quando il OK si fa clic sul pulsante.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
    {
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window
void okButton_Click(object sender, RoutedEventArgs e)
{
Private Sub okButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    // Dialog box accepted
    this.DialogResult = true;
}
    ' Dialog box accepted
    MyBase.DialogResult = New Nullable(Of Boolean)(True)
End Sub
    }
}
End Class

End Namespace

Notare che l'impostazione di DialogResult proprietà comporta la chiusura della finestra automaticamente, che riduce la necessità di chiamare in modo esplicito Close.Note that setting the DialogResult property also causes the window to close automatically, which alleviates the need to explicitly call Close.

Quando il Annulla pulsante ShowDialog deve restituire false, che richiede l'impostazione di DialogResult proprietà.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
    {
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window
void cancelButton_Click(object sender, RoutedEventArgs e)
{
    // Dialog box canceled
    this.DialogResult = false;
}
Private Sub cancelButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Dialog box canceled
    Me.DialogResult = False
End Sub
    }
}
End Class

End Namespace

Quando un pulsante IsCancel è impostata su true e l'utente preme uno di Annulla pulsante o il tasto ESC, DialogResult viene impostato automaticamente su false.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. Il markup seguente ha lo stesso effetto del codice precedente, senza la necessità di gestire il Click evento.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>

Una finestra di dialogo restituisce automaticamente false quando un utente preme il Chiudi pulsante nella barra del titolo o sceglie il Chiudi voce di menu dal sistema menu.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.

Elaborazione di dati restituiti da una finestra di dialogo modaleProcessing Data Returned from a Modal Dialog Box

Quando DialogResult è impostata una finestra di dialogo, la funzione che ha aperto, ottenere la finestra risultante controllando il DialogResult proprietà quando ShowDialog restituisce.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
    {

Imports System
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

Namespace SDKSample

Public Class MainWindow
    Inherits Window
void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)
{
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 == true)
    {
        // Update fonts
        this.documentTextBox.Margin = dlg.DocumentMargin;
    }
}
    ' 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

Se il risultato della finestra di dialogo è true, la funzione usata come un segnale da recuperare ed elaborare i dati forniti dall'utente.If the dialog result is true, the function uses that as a cue to retrieve and process the data provided by the user.

Nota

Dopo aver ShowDialog ha restituito una finestra di dialogo non può essere riaperto.After ShowDialog has returned, a dialog box cannot be reopened. È invece necessario creare una nuova istanza.Instead, you need to create a new instance.

Se il risultato della finestra di dialogo è false, la funzione deve terminare l'elaborazione in modo appropriato.If the dialog result is false, the function should end processing appropriately.

Creazione di una finestra di dialogo non modale personalizzataCreating a Modeless Custom Dialog Box

Una finestra di dialogo non modale, ad esempio la finestra di dialogo Trova illustrata di seguito, presenta sostanzialmente lo stesso aspetto di una finestra di dialogo 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.

Finestra di dialogo TrovaFind dialog box

Il comportamento è invece leggermente diverso, come descritto nelle sezioni riportate di seguito.However, the behavior is slightly different, as described in the following sections.

Apertura di una finestra di dialogo non modaleOpening a Modeless Dialog Box

Viene aperta una finestra di dialogo non modale chiamando il Show metodo.A modeless dialog box is opened by calling the Show method.

<!--Main Window-->
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

namespace SDKSample
{
    public partial class MainWindow : Window
    {

Imports System
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

Namespace SDKSample

Public Class MainWindow
    Inherits 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();
}
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

A differenza di ShowDialog, Show restituisce immediatamente.Unlike ShowDialog, Show returns immediately. Di conseguenza, la finestra chiamante non può stabilire quando la finestra di dialogo non modale viene chiusa e pertanto non sa quando verificare il risultato della finestra di dialogo o quando ottenere dati dalla finestra di dialogo per continuare l'elaborazione.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. La finestra di dialogo deve quindi disporre di un modo alternativo per restituire dati alla finestra chiamante.Instead, the dialog box needs to create an alternative way to return data to the calling window for processing.

Elaborazione di dati restituiti da una finestra di dialogo non modaleProcessing Data Returned from a Modeless Dialog Box

In questo esempio, il FindDialogBox può restituire uno o più risultati di ricerca alla finestra principale, a seconda del testo cercato senza una frequenza specifica.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. Come con una finestra di dialogo modale, una finestra di dialogo non modale può restituire risultati utilizzando le proprietà.As with a modal dialog box, a modeless dialog box can return results using properties. Tuttavia, la finestra proprietaria della finestra di dialogo deve sapere quando controllare tali proprietà.However, the window that owns the dialog box needs to know when to check those properties. A tal fine, la finestra di dialogo dovrebbe implementare un evento generato ogni volta che viene trovato il testo.One way to enable this is for the dialog box to implement an event that is raised whenever text is found. FindDialogBox implementa il TextFoundEvent per questo scopo, che innanzitutto richiede un delegato.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

Utilizzo di TextFoundEventHandler delegare, FindDialogBox implementa il 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
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

Di conseguenza, Find può generare l'evento quando viene trovato un risultato di ricerca.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
    {
Imports System
Imports System.Windows
Imports System.Windows.Controls
Imports System.Text.RegularExpressions

Namespace SDKSample

Public Class FindDialogBox
    Inherits Window
void findNextButton_Click(object sender, RoutedEventArgs e)
{
Private Sub findNextButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
// Text found
this.index = match.Index;
this.length = match.Length;
OnTextFound();
Me.Index = match.Index
Me.Length = match.Length
RaiseEvent TextFound(Me, EventArgs.Empty)
}
End Sub
    }
}
End Class

End Namespace

La finestra proprietaria deve quindi eseguire la registrazione e gestire questo evento.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
    {

Imports System
Imports System.ComponentModel
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Win32

Namespace SDKSample

Public Class MainWindow
    Inherits 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();
        }
    }
}
    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

Chiusura di una finestra di dialogo non modaleClosing a Modeless Dialog Box

Poiché DialogResult non è necessario impostare, una finestra di dialogo non modale può essere chiusi utilizzando sistema forniscono meccanismi, inclusi i seguenti:Because DialogResult does not need to be set, a modeless dialog can be closed using system provide mechanisms, including the following:

  • Fare clic su di Chiudi pulsante nella barra del titolo.Clicking the Close button in the title bar.

  • ALT + F4.Pressing ALT+F4.

  • Scelta di Chiudi dal sistema menu.Choosing Close from the System menu.

In alternativa, è possibile chiamare Close quando il Chiudi si fa clic sul pulsante.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
    {
Imports System
Imports System.Windows
Imports System.Windows.Controls
Imports System.Text.RegularExpressions

Namespace SDKSample

Public Class FindDialogBox
    Inherits Window
        void closeButton_Click(object sender, RoutedEventArgs e)
        {
            // Close dialog box
            this.Close();
        }
    }
}
    Private Sub closeButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        MyBase.Close()
    End Sub
End Class

End Namespace

Vedere ancheSee Also

Panoramica sul controllo PopupPopup Overview
Esempio di finestra di dialogoDialog Box Sample
Esempio di controllo personalizzato ColorPickerColorPicker Custom Control Sample