Un temporizador es un aparato con el que podemos regular la conexión ó desconexión de

un circuito eléctrico después de que se ha programado un tiempo. El elemento fundamental

del temporizador es un contador binario, encargado de medir los pulsos suministrados por
algún circuito oscilador, con una base de tiempo estable y conocida. El tiempo es
determinado por una actividad o proceso que se necesite controlar.
Se diferencía del relé, en que los contactos del temporizador no cambian de posición
instantáneamente. Podemos clasificar los temporizadores en:
De conexión: el temporizador recibe tensión y mide un tiempo hasta que libera los
contactos

De desconexión: cuando el temporizador deja de recibir tensión al cabo de un tiempo,

libera los contactos

Hay diversos tipos de temporizadores desde los que son usados en el hogar para cocinar,
hasta los que son usados en la automatización de procesos de industriales, tienen diferentes
clases de componentes que tienen como fin la misma función, pero cada uno sirve para
algún proceso en específico:
Temporizador térmico que actúa por calentamiento de una lámina bimetálica, el tiempo se
determina por la curva que adquiere la lámina.
Temporizador neumático, está basado en la acción de un fuelle que se comprime al ser
accionado por un electroimán. El fuelle ocupa su posición que lentamente, ya que el aire
entra por un pequeño orificio, al variar el tamaño del orificio cambia el tiempo de
recuperación y por consecuencia la temporización.
Temporizador electrónico, el principio oes la descarga de un condensador mediante una
resistencia. Por lo general se emplean ccondensadores electrolíticos.
Temporizador magnético, se obtiene ensartando en el núcleo magnético, un tubo de cobre.
En Bricos contamos con un amplia variedad de temporizadores , contadores y relés,
llamenos al 8150 1850 o visítenos en Av. Madero 718 Pte entre Amado Nervo y Rayón, en
el centro de Monterrey, para observar el funcionamiento de los temporizadores y relés que
tenemos instalados en nuestro Showroom. Contáctenos para encontrar las mejores
soluciones de control y automatización, puede enviar sus dudas y comentarios a
info@bricos.com
 Barras de progreso
Esta herramienta como otras de visual basic también cuenta con propiedades para manipular su
estructura o sus valores, algunas de las propiedades más importantes de esta herramienta son:

Propiedades de las Barras de progreso – Figura 2

Name: Esta propiedad muestra el nombre de nuestra barras de Progreso cómo es tener mucho cuidado
con este nombre ya que se modificado deberemos también modificar nuestro código base.
Maximum: Este es el valor máximo al que puede llegar nuestra barra el valor preestablecido es de 100
siendo referencia a 100%.
Minimum: Esta propiedad es el valor mínimo de la barra para que la barra comience desde cero el valor
debe ser cero.
Value: Si queremos que la barra inicio por ejemplo desde un 50% deberemos de ingresar en esta
propiedad el valor de 50, digamos que es el punto de inicio de nuestra barra.
Enabled: Esta propiedad especifica si la barra de progreso esta activada o no, si no lo llegara a estar
significa que solo se activara al realizar una acción en el programa.
Visible: esta propiedad nos permite activar o desactivar la visibilidad del progreso de la barra.

Ejemplo 1: Barras de progreso para abrir nuevas ventanas

Objetivo: Abrir una ventana secundaria utilizando la herramienta Timer y la herramienta barra de
progreso (Progressbar) qué muerte tiempo promedio en que se abrirá la ventana.
Archivos completos del ejemplo: barras de progreso
Nota 1: Si no sabes cómo realizar el siguiente diseño algunas de las herramientas utilizadas te resulta
desconocida te recomendamos echarle un vistazo alguno de los otros artículos que hemos desarrollado
para la materia programación visual.
Anuncio

PASO 1: Bien, como primer paso debemos abrir nuestro programa, crear un nuevo proyecto y realizar el
diseño que te mostraremos a continuación (este diseño fue realizar con las
herramientas: PictureBox, Labely Progressbar), también deberemos crear otro formulario
llamado Form2, este sera el formulario que se abrirá cuando nuestra barra llegue a 100%. Si no sabes
como crearlo te recomiendo visitar este articulo: Ventanas Graficas

Barras de progreso – Figura 1

PASO 2: Bien una vez que tengamos nuestro diseño listo procedemos a cambiar los valores máximos y
mínimos de nuestra Progressbar, los valores deben ser 0 y 100, tal y como se muestra a continuación:
Barras de progreso – Figura 3

PASO 3: Ahora deberemos ir nuevamente a las herramientas de Visual Basic y seleccionar la

herramienta Timer, después damos clic en cualquier parte de nuestro formulario y esta se agregara, no
hace falta acomodarla ya que solo es representativa y no se mostrara en el programa final.

Barras de progreso – Figura 4

PASO 4: Ahora debemos seleccionar una vez nuestro Timer e ir a sus propiedades y cambiar las
propiedades Enabled en True e Interval en 40.
Barras de progreso – Figura 4.1

PASO 5: Ahora solamente deberemos colocar el siguiente código en nuestro formulario 1 (Form1), este
código abarca la ProgressBar y el Timer.
Public Class Form1

Public CONTADOR As Integer

Private Sub ProgressBar1_Click(sender As Object, e As EventArgs) Handles

ProgressBar1.Click

ProgressBar1.Value = 0.0

ProgressBar1.Maximum = 100

Timer1.Interval = 40

Timer1.Enabled = True

End Sub
 Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles
Timer1.Tick

If CONTADOR < 100 Then

ProgressBar1.Value = CONTADOR

CONTADOR = CONTADOR + 1

Else

Timer1.Enabled = False

Me.Hide()

Form2.Show()

End If

End Sub

End Class

La programación debe quedar como se ve en la siguiente imagen:

Barras de progreso – Figura 6

En el programa se declaro una variable publica llamada CONTADOR, para que se pudiera cumplir los
siclos del código base.
PASO 6: Ahora debemos ir ala ventana derecha de Visual Studio y seleccionar nuestro
proyecto que debe llamarse WindowsApplication1 (o si le cambiaron el nombre debe aparecer
con el nombre que le asignaron), damos clic derecho sobre el y nos vamos a la opción
propiedades, una vez hechos nos saldrá una ventana como esta:

Barras de progreso – Figura 7

De esta forma al cerrar el formulario hijo (Form2) se cerrara todo el proceso, si no se hace este paso y
cerramos el formulario hijo, el formulario padre (Form1) seguirá abierto pero oculto, con esto evitamos
ese problema.

Si has realizado la practica y llegaste a este punto significa que tu proyecto ya esta listo, solo falta
probarlo, a continuación te dejamos un vídeo que muestra el funcionamiento
CUADRO DE DIALOGOS PREDEFINIDOS
Aplicaciones independientes tienen normalmente una ventana principal que tanto
muestra los datos principales en el que la aplicación funciona y expone la
funcionalidad necesaria para procesar los datos a través de interfaz de usuario
(UI) mecanismos como barras de menús, barras de herramientas y barras de
estado. Una aplicación no trivial también puede mostrar ventanas adicionales para
realizar lo siguiente:

 Mostrar información específica a los usuarios.

 Recopilar información de los usuarios.
 Mostrar y recopilar información.

Estos tipos de ventanas se conocen como cuadros de diálogo, y hay dos tipos:
modales y no modales.

A modal cuadro de diálogo se muestra una función cuando la función necesita

datos adicionales de un usuario para continuar. Como la función depende del
cuadro de diálogo modal para recopilar datos, el cuadro de diálogo modal también
impide que un usuario active otras ventanas de la aplicación mientras permanece
abierto. En la mayoría de los casos, un cuadro de diálogo modal permite a los
usuarios señalar cuando haya terminado con el cuadro de diálogo modal
presionando un Aceptar o cancelar botón. Al presionar la Aceptar botón indica
que un usuario ha entrado en datos y desea que la función que se va a continuar
con el procesamiento con esos datos. Al presionar la cancelar botón indica que un
usuario desea detener la ejecución de la función. Los ejemplos más comunes de
cuadros de diálogo modales se muestran para abrir, guardar e imprimir datos.

A no modales cuadro de diálogo, por otro lado, no impide que un usuario active
otras ventanas mientras está abierto. Por ejemplo, si un usuario quiere buscar las
repeticiones de una palabra determinada en un documento, a menudo una
ventana principal abrirá un cuadro de diálogo para solicitar al usuario la palabra
que está buscando. En cambio, como buscar una palabra no impide que un usuario
edite el documento, el cuadro de diálogo no necesita ser modal. Un cuadro de
diálogo no modal proporciona al menos un cerrar botón para cerrar el cuadro de
diálogo y puede proporcionar botones adicionales para ejecutar funciones
específicas, como un Buscar siguientebotón para buscar la siguiente de word que
coincide con los criterios de búsqueda de una búsqueda de palabras.
Windows Presentation Foundation (WPF) le permite crear varios tipos de cuadros
de diálogo, incluidos cuadros de mensaje, cuadros de diálogo comunes y cuadros
de diálogo personalizados.Este tema describe cada uno y el Dialog Box
Sample proporciona ejemplos de búsqueda de coincidencias.
Cuadros de mensaje

A cuadro de mensaje es un cuadro de diálogo que puede utilizarse para mostrar

información textual y para permitir a los usuarios tomar decisiones con botones. En
la siguiente figura se muestra un cuadro de mensaje que muestra información de
texto, realiza una pregunta y proporciona tres botones al usuario para responderla.

Para crear un cuadro de mensaje, utilice la MessageBox clase. MessageBoxle

permite configurar el texto de cuadro de mensaje, título, icono y botones,
mediante código similar al siguiente.
C#Copiar

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

Para mostrar un cuadro de mensaje, se llama a la static Show método, como se

muestra en el código siguiente.
C#Copiar

// Display message box

MessageBox.Show(messageBoxText, caption, button, icon);
Cuando el código que muestra un cuadro de mensaje necesita detectar y procesar
la decisión del usuario (qué botón se ha presionado), el código puede inspeccionar
el resultado del cuadro de mensaje, como se muestra en el código siguiente.
C#Copiar

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

Para obtener más información sobre el uso de cuadros de mensaje,

consulte MessageBox, MessageBox Sample, y Dialog Box Sample.

Aunque MessageBox puede ofrecer una experiencia de usuario del cuadro de

diálogo simple, la ventaja de usar MessageBox que es el único tipo de ventana que
se puede mostrar las aplicaciones que se ejecutan en un recinto de seguridad de
confianza parcial (vea seguridad), como Aplicaciones del explorador XAML (XBAPs).

La mayoría de los cuadros de diálogo muestran y recopilan datos más complejos

que el resultado de un cuadro de mensaje, incluidos texto, selección (casillas),
selección mutuamente exclusiva (botón de selección) y selección de listas (cuadros
de lista, cuadros combinados, cuadros de lista desplegable). En estos
casos, Windows Presentation Foundation (WPF) proporciona varios cuadros de
diálogo comunes y le permite crear sus propios cuadros de diálogo, aunque el uso
de uno de ellos se limita a aplicaciones que se ejecutan con plena confianza.
Cuadros de diálogo comunes

Windows implementa una variedad de cuadros de diálogo reutilizables que son

comunes a todas las aplicaciones, incluidos los cuadros de diálogo para abrir y
guardar archivos, e imprimir. Como estos cuadros de diálogo se implementan
mediante el sistema operativo, pueden compartirse entre todas las aplicaciones
que se ejecutan en el sistema operativo, que ayuda a la coherencia de la
experiencia de usuario; cuando los usuarios están familiarizados con el uso de un
cuadro de diálogo proporcionado por el sistema operativo en una aplicación, no
necesitan obtener información sobre cómo usar ese cuadro de diálogo en otras
aplicaciones. Dado que estos cuadros de diálogo están disponibles para todas las
aplicaciones y dado que ayudan a proporcionar una experiencia de usuario
coherente, se conocen como cuadros de diálogo comunes.

Windows Presentation Foundation (WPF) encapsula los cuadros de diálogo

comunes de Abrir archivo, Guardar archivo e Imprimir y los expone como clases
administradas para su uso en aplicaciones independientes. En este tema se
proporciona una breve introducción de cada uno.
Cuadro de diálogo Abrir archivo

El cuadro de diálogo Abrir archivo, que se muestra en la siguiente figura, se usa por
la función de apertura de archivos para recuperar el nombre de un archivo que se
va a abrir.
El cuadro de diálogo Abrir archivo común se implementa como
el OpenFileDialog clase y se encuentra en la Microsoft.Win32 espacio de
nombres. En el siguiente código se muestra cómo crear, configurar y mostrar uno,
y cómo procesar el resultado.
C#Copiar

// 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;
}
Para obtener más información sobre el cuadro de diálogo Abrir archivo,
consulte Microsoft.Win32.OpenFileDialog.
Nota
OpenFileDialogpuede usarse para recuperar de manera segura los nombres de
archivo por aplicaciones que se ejecutan con confianza parcial (vea seguridad).
Cuadro de diálogo Guardar archivo

El cuadro de diálogo Guardar archivo, que se muestra en la siguiente figura, se usa

por la función de guardado de archivos para recuperar el nombre de un archivo
que se va a guardar.

Common Guardar cuadro de diálogo de archivo se implementa como

el SaveFileDialog clase y se encuentra en la Microsoft.Win32 espacio de
nombres. En el siguiente código se muestra cómo crear, configurar y mostrar uno,
y cómo procesar el resultado.
C#Copiar

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

Para obtener más información sobre la operación de guardar archivo de cuadro de

diálogo, consulte Microsoft.Win32.SaveFileDialog.
Cuadro de diálogo Imprimir

El cuadro de diálogo Imprimir, que se muestra en la siguiente figura, se usa por la

función de impresión para elegir y configurar la impresora con la que el usuario
quiere imprimir los datos.
El cuadro de diálogo de impresión común se implementa como el PrintDialog clase
y se encuentra en la System.Windows.Controls espacio de nombres. En el siguiente
código se muestra cómo crear, configurar y mostrar uno.
C#Copiar

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

Para obtener más información sobre el cuadro de diálogo de impresión,

consulteSystem.Windows.Controls.PrintDialog. Para una explicación detallada de la
impresión en WPF, consulte resumen de impresión.
Cuadros de diálogo personalizados

Aunque los cuadros de diálogo comunes son útiles, y deben usarse cuando sea
posible, no admiten los requisitos de los cuadros de diálogo específicos de
dominio. En estos casos, necesita crear sus propios cuadros de diálogo. Como
veremos, un cuadro de diálogo es una ventana con comportamientos
especiales. Windowimplementa esos comportamientos y, por lo tanto,
utilice Window para crear cuadros de diálogo modales y no modales
personalizados.
Crear un cuadro de diálogo modal personalizado

Este tema muestra cómo usar Window para crear una implementación de cuadro
de diálogo modal típico, utilizando el Margins cuadro de diálogo como ejemplo
(vea Dialog Box Sample). El Margins cuadro de diálogo se muestra en la ilustración
siguiente.
Configurar un cuadro de diálogo modal

La interfaz de usuario de un cuadro de diálogo típico incluye lo siguiente:

 Los distintos controles que se necesitan para recopilar los datos deseados.
 Mostrar un Aceptar botón que los usuarios, haga clic en para cerrar el cuadro
de diálogo, vuelva a la función y continuar con el procesamiento.
 Mostrar un cancelar botón que los usuarios hacen clic para cerrar el cuadro
de diálogo y detener la función de procesamiento posterior.
 Mostrar un cerrar botón en la barra de título.
 Mostrar un icono.
 Mostrar minimizar, maximizar, y restaurar botones.
 Mostrar un System menú para minimizar, maximizar, restaurar y cerrar el
cuadro de diálogo.
 Apertura encima y en el centro de la ventana que ha abierto el cuadro de
diálogo.
 Los cuadros de diálogo deben ser redimensionables donde sea posible, para
evitar que el cuadro de diálogo sea demasiado pequeño y para proporcionar
al usuario un tamaño predeterminado útil, necesita establecer las
dimensiones mínimas y predeterminadas respectivamente.
 Al presionar la tecla ESC debe configurarse como un método abreviado de
teclado que provoca la cancelar botón presionado. Esto se logra
estableciendo la IsCancel propiedad de la cancelar botón a true .
 Al presionar la tecla ENTRAR (o retorno) debe configurarse como un método
abreviado de teclado que provoca la Aceptar botón presionado. Esto se logra
estableciendo la IsDefaultpropiedad de la Aceptar botón true .

El siguiente código muestra esta configuración.

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

XAMLCopiar

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

C#Copiar

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

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

C#Copiar

}
}

La experiencia de usuario de un cuadro de diálogo también se extiende a la barra

de menús de la ventana que abre el cuadro de diálogo. Cuando un elemento de
menú ejecuta una función que requiere interacción del usuario mediante un cuadro
de diálogo antes de que la función pueda continuar, el elemento de menú de la
función tendrá puntos suspensivos en su encabezado, como se muestra aquí.
XAMLCopiar

<!--Main Window-->

XAMLCopiar

<MenuItem Name="formatMarginsMenuItem" Header="_Margins..."

Click="formatMarginsMenuItem_Click" />

Cuando un elemento de menú ejecuta una función que muestra un cuadro de

diálogo que no necesita interacción del usuario, como un cuadro de diálogo Acerca
de, no se necesitan los puntos suspensivos.
Abrir un cuadro de diálogo modal

Un cuadro de diálogo se muestra normalmente como el resultado de un usuario

que selecciona un elemento de menú para realizar una función específica de
dominio, como establecer los márgenes de un documento en un procesador de
textos. Mostrar una ventana como un cuadro de diálogo es similar a mostrar una
ventana normal, aunque necesita una configuración específica de cuadro de
diálogo adicional. El proceso completo de crear instancias, configurar y abrir un
cuadro de diálogo se muestra en el código siguiente.
C#Copiar

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

namespace SDKSample
{
public partial class MainWindow : Window
{

C#Copiar

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

C#Copiar

C#Copiar

}
}

Aquí, el código está pasando información predeterminada (los márgenes actuales)

al cuadro de diálogo. También está estableciendo la Window.Owner propiedad con
una referencia a la ventana que se muestra el cuadro de diálogo. En general,
siempre debe establecerse el propietario de un cuadro de diálogo para
proporcionar comportamientos relacionados con el estado de ventana que son
comunes a todos los cuadros de diálogo (vea Introducción a WPF Windows para
obtener más información).
Nota
Debe proporcionar un propietario para admitir interfaz de usuario
(UI) automatización para los cuadros de diálogo (vea información general sobre la
automatización de interfaz de usuario).

Después de configura el cuadro de diálogo, se mostrará modalmente llamando a

la ShowDialogmétodo.
Validar los datos proporcionados por el usuario

Cuando un cuadro de diálogo se abre y el usuario proporciona los datos

necesarios, un cuadro de diálogo es responsable de garantizar que los datos
proporcionados sean válidos por los motivos siguientes:

 Desde una perspectiva de seguridad, se deben validar todas las entradas.

 Desde una perspectiva específica de dominio, la validación de datos impide
que los datos incorrectos se procesen por el código, que puede provocar
excepciones potencialmente.
 Desde una perspectiva de experiencia de usuario, un cuadro de diálogo
puede ayudar a los usuarios a mostrarles qué datos de los que han
especificado no son válidos.
 Desde una perspectiva de rendimiento, la validación de datos en una
aplicación de varios niveles puede reducir el número de recorridos de ida y
vuelta entre los niveles de aplicación y cliente, especialmente cuando la
aplicación está formada por servicios Web o bases de datos basadas en
servidor.

Para validar un control enlazado en WPF, debe definir una regla de validación y
asociarlo con el enlace. Una regla de validación es una clase personalizada que
deriva de ValidationRule. En el ejemplo siguiente se muestra una regla de
validación, MarginValidationRule , que comprueba que un valor enlazado es
un Double y está dentro del intervalo especificado.
C#Copiar

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

En este código, se implementa la lógica de validación de una regla de validación

invalidando el Validate método, que valida los datos y devuelve un
apropiado ValidationResult.
Para asociar la regla de validación con el control enlazado, use el siguiente
marcado.
XAMLCopiar

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

XAMLCopiar

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

XAMLCopiar

</Window>

Una vez que está asociada, la regla de validación WPF lo aplicará automáticamente
cuando se escriben datos en el control enlazado. Cuando un control contiene datos
no válidos, WPF mostrará un borde rojo alrededor del control no válido, tal como
se muestra en la ilustración siguiente.

WPF no restringe un usuario al control no válido hasta que haya especificado los
datos válidos.Este es un buen comportamiento para un cuadro de diálogo; un
usuario debe poder navegar libremente por los controles de un cuadro de diálogo
sean los datos válidos o no. Sin embargo, esto significa que un usuario puede
escribir datos no válidos y presione la Aceptar botón. Por este motivo, el código
también debe validar todos los controles en un cuadro de diálogo cuadro cuando
el Aceptar se presiona el botón controlando el Click eventos.
C#Copiar

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

namespace SDKSample
{
public partial class MarginsDialogBox : Window
{

C#Copiar

void okButton_Click(object sender, RoutedEventArgs e)

{
// Don't accept the dialog box if there is invalid data
if (!IsValid(this)) return;

C#Copiar
 }

// 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;
}
}
}
Este código enumera todos los objetos de dependencia en una ventana y, si alguna
no son válido (tal como lo devuelve GetHasError, el control no válido obtiene el
foco, el IsValid método false , y la ventana se considera no válida.

Una vez que un cuadro de diálogo es válido, puede cerrarse y devolverse de

manera segura. Como parte del proceso de retorno, necesita devolver un resultado
a la función de llamada.
Establecer el resultado del cuadro de diálogo modal

Abrir un cuadro de diálogo mediante ShowDialog es fundamentalmente como

llamar a un método: el código que abre el cuadro de diálogo
mediante ShowDialog espera hasta
queShowDialog devuelve. Cuando ShowDialog devuelve, el código que lo llamó
necesita decidir si continuar procesando o detener el procesamiento, dependiendo
de si el usuario presionó la Aceptar botón o cancelar botón. Para facilitar esta
decisión, el cuadro de diálogo debe devolver la elección del usuario como
un Boolean valor que se devuelve desde el ShowDialog método.

Cuando el Aceptar se hace clic en el botón, ShowDialog debe devolver true . Esto
se logra estableciendo la DialogResult propiedad del cuadro de diálogo cuadro
cuando el Aceptar se hace clic en el botón.
C#Copiar

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

namespace SDKSample
{
public partial class MarginsDialogBox : Window
{

C#Copiar

void okButton_Click(object sender, RoutedEventArgs e)

{

C#Copiar

// Dialog box accepted

this.DialogResult = true;
}

C#Copiar

}
}

Tenga en cuenta esa configuración el DialogResult propiedad también hace que la

ventana para cerrar automáticamente, lo que elimina la necesidad de llamar
explícitamente a Close.

Cuando el cancelar se hace clic en el botón, ShowDialog debe devolver false ,

que requiere la configuración de la DialogResult propiedad.
C#Copiar

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

namespace SDKSample
{
public partial class MarginsDialogBox : Window
{

C#Copiar

void cancelButton_Click(object sender, RoutedEventArgs e)

{
// Dialog box canceled
this.DialogResult = false;
}

C#Copiar

}
}

Cuando un botón IsCancel propiedad está establecida en true y el usuario

presiona cualquiera el cancelar botón o la tecla ESC, DialogResult se establece
automáticamente en false . El siguiente marcado tiene el mismo efecto que el
código anterior, sin necesidad de controlar la Click eventos.
XAMLCopiar

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

Devuelve automáticamente un cuadro de diálogo false cuando un usuario

presiona la cerrarsituado en la barra de título o elige el cerrar elemento de menú
de la System menú.
Procesar los datos devueltos de un cuadro de diálogo modal

Cuando DialogResult está establecido en un cuadro de diálogo, la función que lo

abrió puede obtener el resultado del cuadro de diálogo inspeccionando
el DialogResult propiedad cuando ShowDialog devuelve.
C#Copiar

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

namespace SDKSample
{
public partial class MainWindow : Window
{

C#Copiar

void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)

{

C#Copiar

// Process data entered by user if dialog box is accepted

if (dlg.DialogResult == true)
{
// Update fonts
this.documentTextBox.Margin = dlg.DocumentMargin;
}
}

C#Copiar

}
}

Si el resultado del diálogo es true , la función que utiliza como una indicación para
recuperar y procesar los datos proporcionados por el usuario.
Nota
Después de ShowDialog ha devuelto, no se puede volver a abrir un cuadro de
diálogo. En su lugar, necesita crear una instancia nueva.

Si el resultado del diálogo es false , la función debe finalizar el procesamiento

correctamente.
Crear un cuadro de diálogo no modal personalizado

Un cuadro de diálogo no modal, como el cuadro de diálogo Buscar que se muestra

en la figura siguiente, tiene el mismo aspecto fundamental que el cuadro de
diálogo modal.

En cambio, el comportamiento es un poco diferente, como se describe en las

secciones siguientes.
Abrir un cuadro de diálogo no modal

Se abre un cuadro de diálogo no modal mediante una llamada a la Show método.

XAMLCopiar

<!--Main Window-->

C#Copiar
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;

namespace SDKSample
{
public partial class MainWindow : Window
{

C#Copiar

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

C#Copiar

}
}

A diferencia de ShowDialog, Show devuelve inmediatamente. Por consiguiente, la

ventana de llamada no puede indicar cuándo se cierra el cuadro de diálogo no
modal y, por lo tanto, no sabe cuándo comprobar el resultado de un cuadro de
diálogo u obtener los datos de este para un procesamiento posterior. En su lugar,
el cuadro de diálogo necesita crear una manera alternativa de devolver los datos a
la ventana de llamada para su procesamiento.
Procesar los datos devueltos de un cuadro de diálogo no modal

En este ejemplo, el FindDialogBox puede devolver uno o más resultados de

búsqueda a la ventana principal, según el texto que se va a buscar sin ninguna
frecuencia concreta. Al igual que un cuadro de diálogo modal, un cuadro de
diálogo no modal puede devolver resultados mediante propiedades. En cambio, la
ventana que tiene el cuadro de diálogo necesita saber cuándo comprobar esas
propiedades. Una manera de habilitar esto es que el cuadro de diálogo
implemente un evento que se genera cuando se detecta
texto. FindDialogBox implementa el TextFoundEvent para este propósito, que
primero requiere un delegado.
C#Copiar

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

Mediante el TextFoundEventHandler delegar, FindDialogBox implementa

el TextFoundEvent .
C#Copiar

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

C#Copiar

}
}
Por lo tanto, Find puede generar el evento cuando se encuentra un resultado de
búsqueda.
C#Copiar

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

namespace SDKSample
{
public partial class FindDialogBox : Window
{

C#Copiar

void findNextButton_Click(object sender, RoutedEventArgs e)

{

C#Copiar

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

C#Copiar

C#Copiar

}
}

Después, la ventana propietaria necesita registrar y controlar este evento.

C#Copiar

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

namespace SDKSample
{
public partial class MainWindow : Window
{

C#Copiar

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

Cerrar un cuadro de diálogo no modal

Dado que DialogResult no es necesario se establece, se puede cerrar un cuadro de

diálogo no modal mediante sistema proporcionan mecanismos, incluidos los
siguientes:

 Al hacer clic en el cerrar botón en la barra de título.

 Presionar ALT+F4.
 Elegir cerrar desde el System menú.

Como alternativa, puede llamar su código Close cuando el cerrar se hace clic en el
botón.
C#Copiar

using System;
using System.Windows;
using System.Windows.Controls;
using System.Text.RegularExpressions;
namespace SDKSample
{
public partial class FindDialogBox : Window
{

C#Copiar

void closeButton_Click(object sender, RoutedEventArgs e)

{
// Close dialog box
this.Close();
}
}
}

Vea también

Información general sobre el control Popup

Ejemplo de cuadro de diálogo
ColorPicker Custom Control Sample (Ejemplo de control personalizado de selector
de colores)