Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Cuadros de diálogo
En general, las cuadros de diálogo se utilizan para pedir datos o configurar variables
desde una aplicación. La plataforma .NET proporciona cuadros de diálogo predefinidos
pero también permite que el programador configure cuadros de diálogo según sus
necesidades. A continuación se estudian estos últimos y posteriormente se verán los que
proporciona la plataforma.

Cuadros de diálogo definidos por el usuario

En C# no existe una clase Dialog o DialogBox. Las cajas de diálogo son formularios
con unas propiedades predeterminadas:
a) Tiene tamaño fijo. La propiedad FormBorderStyle debe ser FixedDialog.
b) No suelen tener los tres botones de la parte superior derecha de las ventanas
comunes de Windows –Minimizar, Maximizar y Control- . Por eso, sus
propiedades MinimizedBox, MaximizedBox y ControlBox deben ser false.

Un cuadro de diálogo puede ser modal -cuando la propia aplicación o formulario que
lo ha llamado no puede recibir ningún evento hasta que se ha cerrado el cuadro de
diálogo- o no modal –el caso contrario-.

Para ejecutar un cuadro de dialogo modal se siguen los siguientes pasos:

• Se crea y diseña el formulario correspondiente al cuadro de diálogo. Dicho

formulario tendrá en cuenta lo dicho anteriormente en los apartados a y b. En
general, el cuadro tendrá, al menos, un botón Aceptar y un botón Cancelar,
con la función de cerrar el cuadro y de informar a la aplicación que se
aceptan los datos que se han introducido o que se desea anular la
introducción de dichos datos. También se diseñan cuadros de diálogo con
solo el botón de Aceptar.
• En el método de la aplicación que llama al cuadro de diálogo modal se crea
un objeto de la clase del cuadro de diálogo y dicho objeto invoca al método
ShowDialog(). En ese momento la aplicación detiene su ejecución hasta que
se haya cerrado el cuadro de diálogo que le informa de cuál ha sido el botón
pulsado. El código podría ser algo así:
Dialogo dlg = new Dialogo();
dlg.ShowDialog();
MetodoQueHaceAlgo();

En este ejemplo, el método MetodoQueHaceAlgo() no se ejecuta hasta que

se ha cerrado el cuadro de diálogo.

Si se llama a un cuadro de diálogo no modal habría que llamar al método Show() en

lugar de ShowDialog(). Se abre entonces el cuadro de diálogo y se ejecutaría el método
MetodoQueHaceAlgo() sin esperar a que se cierre el cuadro. El control de este tipo de
cuadros es mucho más complejo.

1/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Ejemplo: trabajando con cuadros de diálogo definidos por el usuario

Esta aplicación tiene un formulario llamado FormularioPrincipal, y un cuadro de

diálogo modal. El FormularioPrincipal puede abrir el cuadro de diálogo para
solicitar un dato -en este caso una frase- que se introduce en una caja de texto y se
devuelve como una cadena al propio formulario (figura 18.1).

El formulario FormularioPrincipal tiene una etiqueta para recoger la cadena desde el

cuadro de dialogo y dos botones btnDefinirFrase y btnSalir. El cuadro de diálogo
Dialogo tiene una caja de texto texto y dos botones btnOk y btnCancelar.
FormularioPrincipal llama al cuadro de diálogo desde btnDefinirFrase.

Figura 18.1. Se llama desde formulario principal a un cuadro de diálogo.

Una vez que se despliega el cuadro de diálogo, el usuario debe rellenar la caja de texto.
Posteriormente, si pulsa el btnOk, la cadena de la caja de texto debe pasar a la etiqueta
del FormularioPrincipal. Si se pulsase btnCancelar, se debe cancelar la operación.

El botón btnOk del diálogo en realidad significa: “Estoy de acuerdo con la elección. Por
favor, utiliza este valor en el programa y cierra el cuadro de diálogo”. Y el
btnCancelar : ”Anula la elección, vuelve al estado anterior y cierra el cuadro de
diálogo”.

Para asignar esta funcionalidad a los botones del formulario, deben utilizarse las
propiedades DialogResult de los botones btnOk y btnCancelar. Se le asigna el valor
DialogResult.Ok al primero y DialogResult.Cancel al segundo.

Pero, ¿qué significa exactamente asignar un valor a la propiedad DialogResult de un

botón?.

2/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Para contestar a esta pregunta es necesario saber que cuando se pulsa un botón del
diálogo suceden las siguientes cosas:

a) Se ejecuta el código asociado al botón.

b) Inmediatamente después, se cierra el cuadro de diálogo.
c) Se asigna a la propiedad DialogResult del cuadro de diálogo el valor de la
propiedad DialogResult del botón que se ha pulsado.

El código del botón btnDefinirFrase del formulario principal es:

//Se crea un objeto de la clase del Cuadro de Dialogo

Dialogo dlg = new Dialogo();

//Cuando se cierre dlg se asigna a la propiedad DialogResult del

//formulario, la propiedad DialogResult del botón
//correspondiente al botón pulsado
dlg.ShowDialog(this);

//Si se pulsa btnOk

if(dlg.DialogResult == DialogResult.Ok)
// CodigoQueSeEjecutaDespuesDePulsarOk()

//si se pulsa btnCancelar

else if(dlg.DialogResult == DialogResult.Cancel)
// CodigoQueSeEjecutaDespuesDePulsarCancel()

MetodoQueHaceMasCosas();

DialogResult es una enumeración pública. Su definición es:

public enum DialogResult;

Los valores que puede tomar DialogResult son:

DialogResult.Abort
DialogResult.Cancel
DialogResult.Ignore
DialogResult.No
DialogResult. OK
DialogResult.Retry
DialogResult.Yes
None

El método ShowDialog() devuelve un objeto de tipo DialogResult que se asigna a la

propiedad DialogResult del cuadro de diálogo. Su estructura es:

public DialogResult ShowDialog();

Para construir esta aplicación siga los siguientes pasos:

• Comience creando una nueva aplicación y llámele CuadroDeDialogo

• Propiedades del formulario:
Text = Formulario Principal

3/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Name = FormularioPrincipal
• A continuación añada dos botones al formulario principal. Asigne las propiedades
siguientes:
Name = btnIrCuadroDialogo
Text = Ir al cuadro de dialogo
Name = btnSalir
Text = Salir

• Se añade una etiqueta con las propiedades siguientes:

Name = etiqueta
Text = (sin texto)

El resultado del diseño debe ser parecido al de la figura 18.2:

Figura 18.2. Diseño de la aplicación

• Este es un buen momento para guardar el proyecto.

• A continuación, cree el cuadro de diálogo:
a) Añada un formulario al proyecto (Proyecto/Agregar formulario de
Windows) o bien, en la ventana Explorador de Soluciones pulse –
como indica la figura 18.3- con el botón derecho del ratón sobre el
nombre del proyecto, elegir Agregar/Agregar formulario de
Windows... , y asigne al fichero el nombre MiDialogo.cs (figuras
18.3 y 18.4)

4/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.3. Añadiendo un nuevo formulario a la aplicación.

Figura 18.4. Cuadro de diálogo para configurar el nuevo formulario.

5/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Al pulsar Abrir se añadirá un nuevo formulario a la aplicación.

b) En la ventana de propiedades del formulario MiDialogo:

BorderStyle = FixedDialog. (No puede cambiarse el tamaño)
ControlBox = false (No aparece el botón control )
MinimizeBox = false (No aparece el botón minimizar )
MaximizeBox = false. (No aparece el botón maximizar )

c) Añada una caja de texto al cuadro de diálogo:

Name = texto
Text = (sin texto)

d) Añada una etiqueta al cuadro de diálogo, para “etiquetarlo”:

Text = Escriba el fichero con su path completo
Autosize = True (optimiza su tamaño automáticamente)

e) Añada dos botones al cuadro de diálogo, btnOK y btnCancelar.

Cuando se pulse btnOK, se debe cerrar el cuadro de diálogo y el texto
de la caja de texto, debe ser “recogido” por el cuadro de diálogo y
enviado al formulario principal. Sin embargo, si se pulsa el botón
btnCancelar, simplemente se sale del cuadro de diálogo y se cancela
la operación.

Propiedades de los botones:

Name = btnOK
Text = Aceptar
DialogResult = Ok

Name = btnCancelar
Text = Cancelar
DialogResult = cancel

El aspecto final del cuadro de diálogo es el de la figura 18.5:

Figura 18.5: Diseño final del cuadro de diálogo

f) La misión de los dos botones es cerrar el cuadro de diálogo y asignar

a la propiedad DialogResult del cuadro de diálogo el valor
correspondiente de la propiedad ModalResult del botón pulsado–en

6/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

este caso ModalResult.OK o ModalResult.Cancel- . Además, esos

botones pueden ejecutar un código, si se desea, antes de que se cierre
el cuadro. En este caso, el botón btnCancelar no ejecutará nada y el
btnOk asignará la cadena de la caja de texto a una variable privada de
la clase MiDialogo.

Para hacer esto de manera correcta, defina un campo privado

nombreFichero de tipo string, para almacenar o recoger el texto de la caja
de texto texto en la clase MiDialogo. Añada la línea siguiente en la zona de
la clase MiDialogo reservada para los campos de la clase:

private string nombreFichero;

Para poder acceder a este campo de modo sencillo defina una propiedad
pública, de nombre NombreFichero para leer y almacenar un string en el
campo nombreFichero.

Para ello, en la ventana Vista de clases pulse con botón derecho sobre el
nombre de la clase –MiDialogo- y seleccione la opción Agregar/Agregar
Propiedad, como se indica en la figura 18.6)

Figura 18.6. Forma de agregar visualmente una propiedad a una clase

Aparece el cuadro de diálogo de la figura 18.7:

7/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.7. Cuadro de diálogo de definición de una propiedad.

Rellene los datos correspondientes: tipo devuelto –será un string- y el nombre

de la propiedad, que además será de lectura/escritura (figura 18.7). Visual Studio
escribe el código siguiente:

public string NombreFichero

{
get
{
return nombreFichero;
}
set
{
nombreFichero = value;
}
}

El botón btnOk debe cerrar el cuadro, pero también asignar la cadena

introducida a la variable nombreFichero. Por eso, en su evento Click se le asocia el
código siguiente:
NombreFichero=texto.Text;

Sólo resta llamar al diálogo como modal desde el FormularioPrincipal y

asignar código a los eventos Click de ambos botones:
MiDialogo dlg = new MiDialogo();
dlg.ShowDialog(this);

8/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

//Si se pulsa btnOk

if(dlg.DialogResult == DialogResult.OK)
etiqueta.Text = dlg.NombreFichero;
//si se pulsa btnCancelar
else if(dlg.DialogResult == DialogResult.Cancel)
// No hacer nada
;

Guarde la aplicación y ejecútela.

Figura 18.8. Aspecto final de la aplicación.

El código completo de los dos formularios es el siguiente:

//*************FormularioPrincipal.cs********************
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace CuadroDialogo
{
public class FormularioPrincipal : System.Windows.Forms.Form
{
private System.Windows.Forms.Button btnIrCuadroDialogo;
private System.Windows.Forms.Button btnSalir;
private System.Windows.Forms.Label etiqueta;
private System.ComponentModel.Container components = null;

public FormularioPrincipal()
{

9/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

InitializeComponent();
}

protected override void Dispose( bool disposing )

{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}

#region Windows Form Designer generated code

private void InitializeComponent()
{
this.btnSalir = new System.Windows.Forms.Button();
this.etiqueta = new System.Windows.Forms.Label();
this.btnIrCuadroDialogo = new Button();
this.SuspendLayout();
//
// btnSalir
//
this.btnSalir.Location = new Point(176, 152);
this.btnSalir.Name = "btnSalir";
this.btnSalir.TabIndex = 1;
this.btnSalir.Text = "Salir";
//

this.AutoScaleBaseSize = new Size(5, 13);

this.ClientSize = new System.Drawing.Size(292, 273);
this.Controls.AddRange(new Control[] {
this.etiqueta,
this.btnSalir,
this.btnIrCuadroDialogo});
this.Name = "FormularioPrincipal";
this.Text = "Formulario Principal"; // etiqueta
//
this.etiqueta.Location = new Point(48, 72);
this.etiqueta.Name = "etiqueta";
this.etiqueta.Size=new System.Drawing.Size(184, 23);
this.etiqueta.TabIndex = 2;
//
// btnIrCuadroDialogo
//
this.btnIrCuadroDialogo.Location=new Point(32, 152);
this.btnIrCuadroDialogo.Name = "btnIrCuadroDialogo";
this.btnIrCuadroDialogo.Size = new Size(128, 23);
this.btnIrCuadroDialogo.TabIndex = 0;
this.btnIrCuadroDialogo.Text =
"Ir al cuadro de diálogo";
this.btnIrCuadroDialogo.Click +=
new
System.EventHandler(this.btnIrCuadroDialogo_Click);
//
// FormularioPrincipal
//
this.ResumeLayout(false);

10/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

}
#endregion

[STAThread]
static void Main()
{
Application.Run(new FormularioPrincipal());
}

private void btnIrCuadroDialogo_Click(object sender,

System.EventArgs e)
{
MiDialogo dlg = new MiDialogo();
dlg.ShowDialog(this);

//Si se pulsa btnOk

if(dlg.DialogResult == DialogResult.OK)
etiqueta.Text = dlg.NombreFichero;
//si se pulsa btnCancelar
else if(dlg.DialogResult == DialogResult.Cancel)
// No hacer nada
;

}
}
}

//***************MiDialogo.cs**************************
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;

namespace CuadroDialogo
{
public class MiDialogo : System.Windows.Forms.Form
{
private System.Windows.Forms.TextBox texto;
private System.Windows.Forms.Button btnOk;
private System.Windows.Forms.Button btnCancelar;
private System.Windows.Forms.Label label1;

private System.ComponentModel.Container components = null;

//Mis variables
private string nombreFichero;
public string NombreFichero
{
get
{
return nombreFichero;
}
set
{
nombreFichero=value;
}
}
public MiDialogo()
{

11/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

InitializeComponent();
}
protected override void Dispose( bool disposing )
{
if( disposing )
{
if(components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows Form Designer generated code
private void InitializeComponent()
{
this.texto = new System.Windows.Forms.TextBox();
this.btnOk = new System.Windows.Forms.Button();
this.btnCancelar = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// texto
//
this.texto.Location=new System.Drawing.Point(56,56);
this.texto.Name = "texto";
this.texto.Size = new System.Drawing.Size(184, 20);
this.texto.TabIndex = 0;
this.texto.Text = "";
//
// btnOk
//
this.btnOk.DialogResult = DialogResult.OK;
this.btnOk.Location = new Point(56, 104);
this.btnOk.Name = "btnOk";
this.btnOk.TabIndex = 1;
this.btnOk.Text = "Ok";
this.btnOk.Click +=
new System.EventHandler(this.btnOk_Click);
//
// btnCancelar
//
this.btnCancelar.DialogResult = DialogResult.Cancel;
this.btnCancelar.Location = new Point(160, 104);
this.btnCancelar.Name = "btnCancelar";
this.btnCancelar.TabIndex = 2;
this.btnCancelar.Text = "Cancelar";
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new Point(40, 24);
this.label1.Name = "label1";
this.label1.Size = new Size(201, 13);
this.label1.TabIndex = 3;
this.label1.Text =
“Escriba el fichero con su path completo";
//
// MiDialogo
//
this.AutoScaleBaseSize = new Size(5, 13);

12/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

this.ClientSize = new Size(292, 157);

this.Controls.AddRange(new Control[] {
this.label1,
this.btnCancelar,
this.btnOk,
this.texto});
this.Name = "MiDialogo";
this.Text = "MiDialogo";
this.ResumeLayout(false);

}
#endregion

private void btnOk_Click(object sender, System.EventArgs e)

{
//Asignamos el valor introducido
//en la caja de texto al campo nombreFichero
//Podría escribirse también
// nombreFichero=texto.Text;
NombreFichero=texto.Text;
}
}
}

Por último y aunque no se ha indicado, el código correspondiente al botón btnSalir es:

private void btnSalir_Click(object sender, System.EventArgs e)

{
Application.Exit();
}

Cuadros de dialogo proporcionados por .NET

Todos los cuadros de diálogo que se estudian a continuación son proporcionados por la
librería .NET. El programador no los diseña. Sólo define algunas de sus propiedades

La clase MessageBox

Presenta un cuadro de diálogo muy simple por pantalla. Un cuadro de diálogo

MessageBox es un cuadro de diálogo modal que, en general, se utiliza para informar o
avisar al usuario de algo que ha ocurrido pero no para introducir datos.

No tiene constructor público, por lo que no es posible crear un objeto o instancia de esta
clase. Para visualizar un MessageBox se invoca al método estático Show().

El aspecto de un MessageBox es el de la figura 18.9.

13/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.9

Se puede definir el título, el mensaje, los botones e iconos del MessageBox

determinando los parámetros que se pasan en el método Show().

Si, por ejemplo, en un formulario se ha situado un botón y una caja de texto y se desea
que si se pulsa el botón estando la caja de texto vacía, se avise al usuario con un
MessageBox que le indique que la caja de texto debe rellenarse con algún dato, el
código del botón sería algo parecido al siguiente:

protected void button1_Click(object sender, System.EventArgs e)

{
if(textBox1.Text == "")
{
MessageBox.Show("Introduce tu nombre",
"Error al introducir el nombre”,
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
else
{
// Código en caso de que se haya introducido algo.
}
}

Esta clase hereda directamente de la clase Object y sólo tiene un método que no sea
heredado que es precisamente Show(). Devuelve el valor de la propiedad
DialogResult del botón pulsado.

Show() está sobrecargado y tiene muchas maneras de ser invocado:

Desde el simple:

public static DialogResult Show(string mensaje);

hasta

public static DialogResult Show(IWin32Window ventana,

string mensaje,
string titulo,
MessageBoxButtons botones,
MessageBoxIcon icono,
MessageBoxDefaultButton btn,
MessageBoxOptions op);

La enumeración MessageBoxButtons es:

AbortRetryIgnore La ventana contiene los botones Anular, Reintentar y Omitir.

OK La ventana contiene el boton Aceptar.
OKCancel La ventana contiene los botones Aceptar y Cancelar.
RetryCancel La ventana contiene los botones Reintentar y Cancelar.
YesNo La ventana contiene los botones Sí, No

14/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

YesNoCancel La ventana contiene los botones Sí, No y Cancelar.

La enumeración MessageBoxIcon es:

Asterisk El icono es una interrogación (una letra “i” en un signo de

interrogación).
Error El icono es una X blanca sobre un cículo de fondo rojo
Exclamation El icono es una exclamación en un triángulo de fondo amarillo
Hand El icono es una X blanca sobre un cículo de fondo rojo.
Information El icono es una interrogación (una letra “i” en un signo de
interrogación).
None No hay icono.
Question El icono es una interrogación en un círculo.
Stop El icono es una X blanca sobre un cículo de fondo rojo.
Warning El icono es una exclamación en un triángulo de fondo amarillo.

Enumeración correspondiente a MessageBoxDefaultButton

Button1 El botón por defecto es el primero.

Button2 Idem el segundo.
Button3 Idem el tercero.

Enumeración correspondiente a MessageBoxOptions

DefaultDesktopOnly, Se visualiza el mensaje en la ventana activa.
ServiceNotification

RightAlign, RtlReading Formas de alinear el texto

A continuación se destacan varios ejemplos y se representa la salida de esas

líneas de código.

a) MessageBox.Show(this,"Hola");
b) MessageBox.Show("Hola");

Figura 18.10

15/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

b) MessageBox.Show(this,"Hola","Este es el título del mensaje");

Figura 18.11

c) MessageBox.Show(this,"Hola","Título mensaje",MessageBoxButtons.OK);

Figura 18.12

c) MessageBox.Show(this,
"Hola",
"Título mensaje",
MessageBoxButtons.YesNoCancel);

Figura 18.13

d) MessageBox.Show(this,
"Hola",
"Título mensaje",
MessageBoxButtons.AbortRetryIgnore);

Figura 18.14

e) MessageBox.Show(this,

16/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

"Hola",
"Título mensaje",
MessageBoxButtons.AbortRetryIgnore,
MessageBoxIcon.Asterisk);

Figura 18.15

f) MessageBox.Show(this,
"Hola",
"Título mensaje",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Stop,
MessageBoxDefaultButton.Button2);

Figura 18.16

Cuadros de diálogo estándar proporcionados por .NET

El Framework .NET proporciona otras clases para algunos cuadros de diálogo

predefinidos para abrir y guardar ficheros, imprimir, para la elegir de la fuente, etc.
Cada uno de estos cuadros de diálogo se corresponde con una clase del Framework. La
jerarquía de dichas clases es la que se representa en la figura 18.17.

Object

Component

17/27
CommonDialog
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.17. Jerarquía de las clases correspondientes a los cuadros de diálogo estándar.

Todas estas clases derivan de la clase CommonDialog, excepto la clase

PrintPreviewDialog que deriva directamente de la clase Form.

La clase CommonDialog

Esta clase base define los siguientes métodos y eventos, que son comunes a todas las
clases que derivan de ella (Figura 18.17). Los más importantes son:

DialogResult Este método despliega el cuadro de diálogo

ShowDialog()
void Reset() Pone los valores predeterminados.
EventHandler Este evento se lanza cuando el usuario pulsa el botón de
HelpRequest ayuda en el cuadro de diálogo

El método más importante de CommonDialog es ShowDialog() que devuelve un objeto

de tipo DialogResult que en estos cuadros de diálogo puede tomar dos valores:

DialogResult.OK si el usuario pulsa el botón Ok en el cuadro de diálogo.

DialogResult.CANCEL, en cualquier otro caso.

Cómo utilizar los cuadros de diálogo estándar

En general, todas las clases que corresponden a cuadros de diálogo estándar son muy
parecidas. Para presentar en pantalla el cuadro de diálogo se invoca el método
ShowDialog() y éste, a su vez, invoca al método RunDialog(). Una vez que se ha
cerrado el cuadro, ShowDialog() devuelve un objeto de tipo DialogResult que
encapsula la información acerca de cómo el usuario ha interactuiado con la caja de
diálogo.

18/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

En general, los pasos a seguir para utilizar un cuadro de diálogo estándar son:

• Crear una instancia del cuadro de diálogo.

• Definir las propiedades y estado del cuadro de diálogo. Este paso puede
también hacerse en tiempo de diseño.
• Llamar al método ShowDialog() y esperar la actuación del usuario.

Suponga, por ejemplo que se desea llamar al cuadro de diálogo correspondiente a abrir
un fichero. Después de haber realizado los tres pasos anteriores, el usuario selecciona un
fichero y pulsa el botón OK. Se asocia a la propiedad FileName el nombre del fichero
que se ha selecionado, se cierra el cuadro y se chequea si el valor devuelto por el
método ShowDialog() es DialogResult.Ok. Después se leen las propiedades que se
necesiten del cuadro de diálogo. El código podría ser:
string nombreFichero;
OpenFileDialog dlg=new OpenFileDialog();
dlg.Title= "Cuadro de dialogo Abrir";
if(dlg.ShowDialog()==DialogResult.OK)
nombreFichero = dlg.FileName;
else
//OtroMetodo();

Realmente, para abrir el cuadro de diálogo, sólo son necesarias estas dos líneas de
código:
OpenFileDialog dlg=new OpenFileDialog();
dlg.ShowDialog();

Observe que el cuadro de diálogo sólo selecciona el fichero y no lo abre. Para ello. el
programador debe escribir un determinado código.

El resto de los cuadros de dialogo estándar funcionan de una manera muy parecida pero
cada uno de ellos tiene una funcionalidad específica y pueden seleccionar de manera
visual un fichero, una fuente, un color, etc... y lo asignan a la propiedad
correspondiente.

Si se ejecuta el código anterior, por ejemplo, desde un botón, se despliega en la pantalla

el formulario de la figura 18.18:

19/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.18. Cuadro de diálogo estándar para abrir ficheros.

A continuación, se estudian con cierto detalle algunas de las clases correspondientes a

los distintos cuadros de diálogo.

La clase FileDialog

FileDialog es una clase abstracta y no puede ser instanciada directamente. De esta

clase heredan las clases OpenFileDialog y SaveFileDialog.

FileDialog es un cuadro de diálogo modal.

Propiedades

bool AddExtension Indica si se añade una extensión de un tipo de fichero si el

bool CheckFileExists
bool CheckPathExists
string DefaultExt
string FileName
string[] FileNames
string Filter
usuario omite la extensión.
Indica si se presenta un cuadro de diálogo de aviso si el
usuario especifica un nombre de fichero que no existe.
Indica si se presenta un cuadro de diálogo de aviso si el
usuario especifica un path que no existe.
La extensión por defecto. Por defecto, si no se ha
especificado ninguna, se añade esta extensión a los
ficheros cuando el usuario guarda el fichero.
Es un string con el nombre del fichero seleccionado en el
cuadro de diálogo.
Obtiene todos los ficheros seleccionados en el cuadro de
diálogo.
Determina el “filtro” que determina los tipos de ficheros
que aparecen en las cajas de texto “Guardar como tipo

20/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

…” o “Tipo de archivo….”
int FilterIndex El índice del filtro actualmente seleccionado. El primer
índice es el 1.
string InitialDirectory Directorio inicial al abrirse el cuadro de diálogo.
bool RestoreDirectory Especifica si se restaura los valores del cuadro de diálogo
antes de cerrarlo.
bool ShowHelp Indica si se despliega el botón Help en el cuadro de
diálogo.
string Title Título del cuadro de diálogo.

Eventos

CancelEventhandler FileOk Ocurre cuando el usuario pulsa el botón Abrir o

Guardar del cuadro de diálogo.

Las clases OpenFileDialog y SaveFileDialog

El objetivo final de estos controles es proporcionar el nombre de un fichero de forma

segura y visual. El nombre del archivo viene especificado en la propiedad FileName del
diálogo.

Representan dos cuadros de diálogo que presentan en pantalla controles que permiten
seleccionar un fichero, abrirlo o salvarlo chequeando si el fichero existe o no. La
propiedad ShowReadOnly determina si aparece un CheckBox en el cuadro para indicar
la opción de sólo lectura. La propiedad ReadOnlyChecked indica el estado del
CheckBox de sólo lectura.

Ambas clases tienen miembros muy parecidos, por lo que se estudiarán juntas. La
mayor parte de la funcionalidad de estas clases la proporciona la clase FileDialog. A
continuación se estudian los miembros de FileDialog.

Propiedades

bool Multiselect Indica si puede hacerse una selección múltiple o no.

bool ReadOnlyChecked Indica si el CheckBox está seleccionado o no.
bool ShowReadOnly Indica si el cuadro de diálogo contiene una opción –un
CheckBox- de sólo lectura.

Métodos

Stream OpenFile() Abre el fichero especificado en la propiedad FileName

seleccionado por el usuario con permiso de sólo lectura.

Por ejemplo, éste podía ser un código para este control:

Stream miStream;
OpenFileDialog openDialog = new OpenFileDialog();

openDialog.InitialDirectory = "c:\\" ;

21/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

openDialog.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*"

;
openDialog.FilterIndex = 2 ;
openDialog.RestoreDirectory = true ;

if(openDialog.ShowDialog() == DialogResult.OK)
{
if((miStream = openDialog.OpenFile())!= null)
{
// Código para leer el Stream.
miStream.Close();
}
}

Las dos siguientes propiedades son específicas de la clase SaveFileDialog.

bool CreatePrompt Indica si el usuario puede crear un fichero que no existe.

bool OverwritePrompt Indica si el cuadro de diálogo Guardar como despliega un
aviso especificando el fichero que ya existe.

La clase ColorDialog

Esta clase se utiliza para seleccionar un color mediante un cuadro de diálogo. Su

aspecto es el de la figura 18.19.

Figura 18.19. Cuadro de dialogo Color

Propiedades.

bool AllowFullOpen Indica si el usuario puede utilizar el cuadro de diálogo para

definir colores personalizados.

22/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

bool AnyColor Indica si el cuadro de diálogo presenta todos los colores

disponibles del juego básico de colores.
Color Color Color actual o color seleccionado por el usuario.
bool CustomColors Indica si se pueden definir colores personalizados.
bool FullOpen Indica si se enseña el cuadro de diálogo completo, es decir,
con la parte de los colores personalizados.
bool ShowHelp Indica si hay botón de ayuda en el cuadro de diálogo.

La clase FontDialog

Esta clase se utiliza para la selección de una fuente. Su aspecto es el de la figura 20.

Figura 18.20. Cuadro de diálogo Fuente

Propiedades

Color Color Indica el color de la fuente seleccionada.

Font Font Indica la fuente actual o la fuente seleccionada por el usuario.
int MaxSize Indica el valor de tamaño máximo de la fuente.
int MinSize Idem, mínimo.
bool ShowApply Indica si el cuadro de diálogo tiene botón Aplicar.
bool ShowColor Indica si el cuadro de diálogo proporciona la opción de color de la
letra.
bool ShowEffects Indica si el cuadro de diálogo contiene controles que permitan
especificar las características de tachado, subrayado y color del
texto.
bool ShowHelp Indica si se presenta en el cuadro de diálogo un botón de ayuda.

23/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Ejemplo: trabajando con cuadros de diálogo estándar y el control

RichTextBox: Un sencillo editor de textos.

A continuación se implementa un sencillo editor de textos con una serie de menús que
permite cambiar la fuente y el color, así como abrir y salvar ficheros de texto. Se utiliza
un control que no ha sido estudiado, RichTextBox, que es una caja de texto
enriquecido. Dicho control tiene dos métodos para leer y guardar un fichero en formato
RTF o de texto La estructura de estos dos métodos es la siguiente:

public void LoadFile(string nombreDelFichero);

public void SaveFile(string nombreDelFichero);

El aspecto final de la aplicación es el de la figura 21.

Los pasos necesarios para implementar la aplicación son los siguientes:

a) Cree un nuevo proyecto y llámelo ProyectoDialogosEstandar.

b) Cambie el nombre del fichero Form1.cs a ProcesadorDeTextos.cs.
c) Cambie las siguientes propiedades del formulario:
Name: ProcesadorDeTextos
Text: Procesador de Textos

Cambie la línea del método Main()

Application.Run(new Form1());

por la línea:

Application.Run(new ProcesadorDeTextos());

OJO con esto que puede ser sólo para la versión beta

d) Sitúe un control RichTextBox en el formulario con las siguientes propiedades:

Name: texto
Text: (Vacío)
Dock: Fill
Con esta última propiedad se asegura que siempre que se redimensione la
ventana del formulario también se redimensiona la superficie del control para ocupar
toda la superficie del formulario.

e) Añada un control MainMenu al formulario con las propiedades siguientes:

Name: menu
Opciones de Menu:
Diseñe el menú con dos opciones principales, Archivo y Formato y en cada una
de ellas las siguienetes opciones de menú:

Menu Propiedades Propiedad Text

24/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Archivo mArchivo Archivo

Nuevo mNuevo Nuevo
Abrir mAbrir Abrir
Guardar mGuardar Guardar
- (Signo -) mSeparador -
Salir mSalir Salir
Formato mFormato Formato
Fuente mFuente Fuente
Color de fondo mColorFondo Color de fondo

f) Añada los cuatro controles siguientes con las propiedades que se indican:

• OpenFileDialog

Name: dlgAbrir
Filter: Documentos de text (*.txt)|*.txt|Todos (*.*)|*.*
Default Ext: txt
ShowHelp: True
ShowReadOnly: False
Title: Diálogo Abrir fichero

• SaveFileDialog

Name: dlgGuardar
AddExtension: true
Filter: Documentos de text (*.txt)|*.txt|Todos (*.*)|*.*
FileName: doc1
Default Ext: txt
RestoreDirectory: False
ShowHelp: True
Title: Diálogo Guardar fichero

• ColorDialog

Name: dlgColor
AllowFullOpen: True
FullOpen: False
ShowHelp: True
SolidColorOnly: False

• FontDialog

Name: dlgFuente
ShowApply: True
ShowColor: True
ShowEffects: True
ShowHelp: True

25/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Figura 18.21. Editor de textos

g) Cree un miembro privado, denominado nombreFichero de tipo string, e

inícielo en el constructor del formulario de la siguiente manera:
//miembro
private string nombreFichero;
//constructor
public ProcesadorDeTextos()
{
InitializeComponent();
nombreFichero="Sintitulo";
this.Text=nombreFichero;
}

h) Escriba, para cada una de las opciones de menú, el siguiente código:

Menú Nuevo:
private void mNuevo_Click(object sender, System.EventArgs e)
{
nombreFichero="Sintitulo";
texto.Clear();
this.Text=nombreFichero;
}

Menú Abrir:
private void mAbrir_Click(object sender, System.EventArgs e)
{
if(dlgAbrir.ShowDialog() == DialogResult.OK){
nombreFichero=dlgAbrir.FileName;
texto.LoadFile(nombreFichero);
this.Text=nombreFichero;
}
}

Menú Guardar
private void mGuardar_Click(object sender, System.EventArgs e)
{
if(dlgGuardar.ShowDialog() == DialogResult.OK)

26/27
Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

{
nombreFichero=dlgAbrir.FileName;
texto.SaveFile(nombreFichero);
this.Text=nombreFichero;
}
}

Menú Salir
private void mSalir_Click(object sender, System.EventArgs e)
{
Application.Exit();
}

Menú Fuente
private void mFuente_Click(object sender, System.EventArgs e)
{
if(dlgFuente.ShowDialog() == DialogResult.OK)
{
texto.Font=dlgFuente.Font;
texto.ForeColor=dlgFuente.Color;
}
}

Menú Color de Fondo:

private void mColorFondo_Click(object sender, System.EventArgs e)
{
if(dlgColor.ShowDialog() == DialogResult.OK)
texto.BackColor=dlgColor.Color;

Guarde, compile y ejecute la aplicación. Compruebe las distintas posibilidades del

programa. Observe que en el título de la aplicación se escribe el nombre completo
del fichero (Figura 18.21).

27/27