Guía No. 6 Programación I

Programación I. Guía No.
6 1
Facultad: Informática y Ciencias Aplicadas

Escuela: Informática
Asignatura: Programación I
Tema: “Estructuras de Control, funciones, procedimientos y

uso de controles en proyectos Windows Forms en Visual C#.”
Objetivos
Identificar los controles comúnmente utilizados para aplicaciones Windows Forms.

Crear aplicaciones Windows Forms utilizando estructuras de control.
Utilizar funciones y procedimientos en aplicaciones Windows Forms.
Introducción
Métodos.
A continuación se mencionan algunos métodos utilizados frecuentemente en aplicaciones Windows Forms.
MessageBox.
El método MessageBox.Show permite mostrar un cuadro de mensaje que puede contener texto, botones y
símbolos que informan e instruyen al usuario.
La sintaxis es la siguiente:
Los botones que pueden agregarse a un MessageBox son:

▪ OK: El cuadro muestra un botón de “Aceptar (OK)”.
▪ OKCancel: El cuadro muestra un botón de “Aceptar (OK)” y otro de “Cancelar (Cancel)”.
▪ RetryCancel: Para mostrar un botón “Reintentar (Retry)” y otro botón de “Cancelar (Cancel)” en el
cuadro de mensaje.
▪ YesNo: El cuadro de mensaje muestra un Botón “Si (Yes)” y un botón “No”.
▪ YesNoCancel: El cuadro de mensaje muestra los botones “Si (Yes)”, “No” y “Cancelar (Cancel)”.
Los íconos que pueden utilizarse en este método son:

Error: El cuadro de mensaje muestra un símbolo de error.
Exclamation: El cuadro de mensaje muestra un símbolo de exclamación (admiración).
Information: El cuadro de mensaje muestra un símbolo de información.
2 Programación I. Guía No. 6
Question: El cuadro de mensaje muestra un símbolo de interrogación.

Warning: El cuadro de mensaje muestra un símbolo de advertencia.
En la siguiente figura, observamos un ejemplo de un MessageBox:
InputBox.
Aunque parezca mentira, no existe en Visual C# un diálogo para pedir un dato. Si no tienes ganas de crear tu
propio diálogo y no necesitas personalización, puedes hacer uso de la sentencia InputBox que se encuentra en
el ensamblado Microsoft.VisualBasic.
El método InputBox( ) permite mostrar un cuadro de mensaje en el que el usuario puede introducir un valor o
un mensaje en forma de texto. Muestra un indicador en un diálogo en el que el usuario puede introducir texto.
La entrada se asigna a una variable.
La instrucción InputBox es un método cómodo para introducir texto a través de un diálogo. La entrada se
devuelve como valor de retorno de la función.
La sintaxis es:
Esta sentencia muestra un diálogo modal con una etiqueta, una caja de texto, un botón para “aceptar” y otro
para “cancelar”.
La definición de la sentencia InputBox es la siguiente:
Donde:
❖ Prompt: Mensaje del diálogo.
❖ Title: Opcional. Título del diálogo.
❖ DefaultResponse: Opcional. Respuesta por defecto.
❖ xPos: Opcional. Coordenada X, por defecto centrado
❖ yPos: Opcional. Coordenada Y, por defecto centrado
Programación I. Guía No. 6 3
En la siguiente figura, observamos un ejemplo de un InputBox:
A continuación se detallan los pasos para añadir InputBox en Visual C#:

1. Agregar la referencia al ensamblado Microsoft.VisualBasic: Damos clic derecho en la carpeta
“References”, luego seleccionamos en el menú contextual que aparece, la opción “Agregar referencia”
2. En la ventana que aparece, buscamos y seleccionamos la referencia “Microsoft.VisualBasic”
3. Dar clic en el botón “Aceptar”.
Una vez hecha la referencia ya podemos utilizar ese método.

Ejemplo de uso:
Controles Especiales.
A continuación, detallaremos controles para el manejo de errores, validaciones y para mostrar ayuda al usuario.
ErrorProvider.
Proporciona una Interfaz de Usuario (UI) para indicar al usuario que el control de un formulario tiene un error
asociado.
El componente ErrorProvider de formularios Windows Forms se utiliza para indicar al usuario de forma no
intrusiva, que algo va mal. Habitualmente, se utiliza junto con la validación de entrada del usuario en un
formulario o con la presentación de errores dentro de un conjunto de datos.
ToolTip.
Muestra información cuando el usuario mueve el puntero sobre el control asociado.
Representa una pequeña ventana emergente rectangular que muestra una breve descripción de la finalidad de
un control cuando el usuario sitúa el puntero sobre el control.
El componente ToolTip de Windows Forms muestra texto cuando el usuario apunta a otros controles. Un
componente Tooltip se puede asociar con cualquier control.
Un ejemplo del uso de este control: para ahorrar espacio en un formulario, puede mostrar un pequeño icono en
un botón y utilizar un componente ToolTip para explicar la función del botón.
Procedimientos y Funciones.
Todas las instrucciones en un programa deben estar incluidas en un procedimiento o función, a las que
llamaremos mediante su identificador.
En Visual C# existen cuatro clasificaciones de este tipo de instrucciones:
➢ Los procedimientos que ejecutan un conjunto de instrucciones a petición sin devolver ningún
resultado.
➢ Las funciones que ejecutan una porción de código y devuelven el resultado al código que las invocó o
llamó.
➢ Los procedimientos de propiedades que permiten manejar las propiedades de los objetos creados
(dentro de las clases).
➢ Los procedimientos de operador utilizados para modificar el funcionamiento de un operador cuando
se aplica a una clase (class) o una estructura (struct).
Procedimientos.
La visibilidad de un procedimiento viene determinada por la declaración private, public o internal. Por defecto,
si no se indica nada, se entiende que es de tipo public.
Un procedimiento puede recibir o no parámetros, ejecuta instrucciones, pero nunca retorna ningún valor.
Funciones.
Una función puede recibir o no parámetros, ejecuta ciertas instrucciones y la ejecución del comando return
devuelve un valor de salida de la función.
La sintaxis se muestra a continuación:
Procedimientos de propiedades.
Estos procedimientos se llaman “encapsuladores” ya que el valor de la propiedad se encapsula. Se utilizarán
cuando queramos modificar y/o recuperar un valor (Set/Get).
Procedimientos de operador.
Permiten la redefinición de un operador estándar del lenguaje para utilizarlo en tipos de datos personalizados
(clase o estructura) definidos por el usuario.
Procedimiento
Crear una carpeta con el nombre Practica 6 para guardar los ejemplos y ejercicios, en el escritorio de su
computadora.
Guía 6 Ejemplo 1: Uso de Estructuras Condicionales.

Se debe crear una aplicación Windows Forms que permita ingresar los dos lados de un cuadrilátero, y debe
mostrar la figura de un cuadrado si ambos lados son iguales o mostrar un rectángulo si los valores de los dos
lados son distintos. También debe calcularse el área y el perímetro de la figura resultante.
La aplicación debe lucir parecida a la siguiente figura:
Figura 1.
Creamos nuestro proyecto, y le colocamos como nombre “Guia6”.

Luego le cambiamos nombre al Form1. Podemos colocarle por ejemplo el nombre “FrmUsoIf”.
A continuación, agregamos los distintos objetos que necesitaremos: 2 GroupBox, 4 Label, 2 PictureBox, 4
TextBox y 3 Button.
Les cambiamos la propiedad “Text” a los GroupBox así:
GroupBox1 → Ingresar datos del cuadrilátero
GroupBox2 → Datos resultantes
Les cambiamos a todos los objetos la propiedad “Text”, de acuerdo con la figura 1.
A los TextBox del GroupBox2, les cambiaremos la propiedad “Enabled” a “False”, con el propósito de que en
ellos no pueda escribirse.
Cambiamos la propiedad “BackColor” a los PictureBox de acuerdo con nuestra preferencia.
También cambiamos la propiedad “Size” de tal manera que uno represente un cuadrado y el otro represente un
rectángulo.
Le cambiamos la propiedad “Name” a los objetos de esta manera:
Control Valor
TextBox1 txtLado1
TextBox2 txtLado2
TextBox3 txtArea
TextBox4 txtPerimetro
PictureBox1 pbxCuadrado
PictureBox2 pbxRectangulo
Button1 btnCalcular
Button2 btnNuevo
Button3 btnSalir
A continuación, procedemos a programar nuestra aplicación.
Damos doble clic en el botón “Calcular” y escribimos el siguiente código en el evento “Click”:
private void btnCalcular_Click(object sender, EventArgs e)
{
//Declaración de variables
double lado1, lado2;
double area, perimetro;
//Entrada de datos
lado1 = Convert.ToDouble(txtLado1.Text);
lado2 = Convert.ToDouble(txtLado2.Text);
//Evaluamos si es un cuadrado o un rectángulo

if (lado1 == lado2)
{
pbxCuadrado.Visible = true;
pbxRectangulo.Visible = false;
}
else
{
pbxCuadrado.Visible = false;
pbxRectangulo.Visible = true;
}
//Calcular el área y el perímetro

area = lado1 * lado2;
perimetro = 2 * (lado1 + lado2);
//Salida de la Información
txtArea.Text = Convert.ToString(area) + " cms cuadrados";
txtPerimetro.Text = Convert.ToString(perimetro) + " cms.";

}
Damos doble clic en el botón “Nuevo” y escribimos el siguiente código en el evento “Click”:
private void btnNuevo_Click(object sender, EventArgs e)
{
//Para limpiar la propiedad “Text” de los objetos
txtLado1.Clear();
txtLado2.Clear();
txtArea.Clear();
txtPerimetro.Clear();
//Para que los PictureBox no se visualicen

}
Damos doble clic en el botón “Salir” y escribimos el siguiente código en el evento “Click”:
private void btnSalir_Click(object sender, EventArgs e)
{
Close();
}
Luego, tenemos que ocultar los PictureBox de tal manera que cuando la aplicación cargue no se visualicen,
sino hasta que se dé clic al botón “Calcular”.
Para ello, ubicamos el método constructor de nuestra clase y agregaremos las siguientes líneas de código:
public FrmUsoIf()
{
InitializeComponent();
// Para que, al cargar el formulario, los PictureBox no se vean

}
Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación.
Para validar esta aplicación utilizaremos el control “ErrorProvider”.

Para ello, lo primero que tenemos que hacer es agregar el control a nuestro formulario. Este control no
aparecerá visualmente en nuestro formulario, pero podemos asegurarnos que se ha agregado, revisando si en
la parte inferior del IDE se encuentra el mismo (ver figura 2).
Figura 2.
Luego le cambiamos la propiedad “Name” y le colocamos “errorControl”.

A continuación, creamos una función que nos permita manejar las validaciones, así:
private bool is_validate()
{
// Variable para controlar si ha habido un error
bool sin_error = true;
if (txtLado1.Text == string.Empty)
{
// El método SetError() se utiliza para enviar el error
errorControl.SetError(txtLado1, "Ingrese el valor del Lado 1");
sin_error = false; // Cambiamos a “false”, pues ocurrió un error
}
else // Para validar los otros controles
{
try
{
// Declaramos una variable para capturar lo que digite el usuario
double Lado1 = Convert.ToDouble(txtLado1.Text);
}
catch
{
errorControl.Clear(); // Limpiar todos los mensajes de error
errorControl.SetError(txtLado1, "Ingrese un valor válido");
return false;
}
if (txtLado2.Text == string.Empty)
{
errorControl.SetError(txtLado2, "Ingrese el valor del Lado 2");
sin_error = false; // Cambiamos a “false”, pues ocurrió un error
}
else
{
try
{
double Lado2 = Convert.ToDouble(txtLado2.Text);
}
catch
{
errorControl.SetError(txtLado2, "Ingrese un valor Válido");
return false;
}
}
return sin_error; //Retornamos la variable que controla si ha ocurrido un error
}
return sin_error; //Retornamos la variable que controla si ha ocurrido un error
}
El siguiente paso es hacer la validación en el botón “Calcular”. Agregamos las siguientes líneas de código al
inicio del evento “Click”:
if (is_validate())
{
errorControl.Clear();
/* Acá colocamos todas las instrucciones que queremos que se ejecuten al dar clic al
Botón */
}

De esta forma hemos validado nuestra aplicación, para que el usuario no deje en blanco los datos o introduzca
texto como valor de los lados.
En Visual C# podemos utilizar el control “ToolTip” para mostrar mensajes al usuario. En nuestro ejemplo lo
utilizaremos para indicar al usuario que es lo que tiene que hacer en la aplicación.
Lo primero que tenemos que hacer es agregar el control a nuestro formulario. Este control no aparecerá
visualmente en nuestro formulario, pero podemos asegurarnos que se ha agregado, revisando si en la parte
inferior del IDE se encuentra el mismo (ver figura 3).
Figura 3.
Luego le cambiamos la propiedad “Name” y le colocamos “ttMensajes”.

Lo que haremos es que cuando el usuario pase el cursor del mouse sobre la caja de texto donde debe ingresar
el valor del lado 1 le aparezca un mensaje indicándole tal acción, y lo mismo para el lado 2.
Para ello, ubicamos el constructor del formulario y colocamos dentro de él las siguientes líneas de código:
// El método SetToolTip() asocia el texto de información sobre el control especificado.
this.ttMensajes.SetToolTip(this.txtLado1, "Ingrese el valor del lado 1");
this.ttMensajes.SetToolTip(this.txtLado2, "Ingrese el valor del lado 2");

De esta forma hemos completado nuestra aplicación, para mostrar ayuda visual al usuario que le facilite el uso
de la misma.
Guía 6 Ejemplo 2: Uso de Estructuras Repetitivas.

Elaborar una aplicación Windows Forms que permita almacenar los datos personales de un estudiante y las
notas obtenidas en una asignatura. Además debe mostrarse el promedio obtenido en la asignatura y la
evaluación con la nota más baja y la evaluación con la nota más alta.
Para desarrollar este ejemplo, no crearemos un nuevo proyecto, sino que lo haremos en el mismo proyecto en
que trabajamos el ejemplo 1. Para ello, agregaremos un nuevo formulario a dicho proyecto.
Para hacer esto, debemos seguir los siguientes pasos:
Dar clic derecho sobre el nombre del proyecto.
En el menú contextual, dar clic a la opción “Agregar”.
En el nuevo menú contextual que aparece dar clic en la opción “Windows Forms”.
Nos aparecerá una ventana similar a la que se observa en la imagen siguiente:
Acá tenemos que darle un nombre al formulario, en nuestro caso le daremos el nombre “FrmRepetitivas”.
De esta forma, nos agrega un nuevo formulario a nuestro proyecto. Podemos verificarlo en la ventana
“Explorador de Soluciones”. Además, nos cargará el nuevo formulario en el área de edición del proyecto (área
central del IDE) (ver figura 4).
Figura 4.
Le cambiamos la propiedad “Text” al formulario, le colocamos “Ejemplo Estructura Repetitiva”.
Para diseñar esta aplicación utilizaremos un control que nos permite visualmente, tener más de un entorno en
el mismo formulario, este es el control “TabControl”.
Agregamos entonces el objeto “TabControl”. Observemos que este control genera dos páginas “tabPage1” y
“tabPage2” y en cada una de ellas podemos diseñar dos entornos diferentes (ver figura 5).
Figura 5.
Lo primero que haremos con este control es cambiar el nombre a los tabPages, para ello tenemos que modificar
la propiedad “TabPages”. Damos clic en los tres puntos que aparecen en esta propiedad en la ventana
“Propiedades” (ver figura 6).
Figura 6.
Al hacer esto, nos carga una ventana como se observa en la figura 7.

Figura 7.
Acá seleccionamos en el área “Miembros” cada uno de los tabPages y les cambiaremos la propiedad “Text”,
así:
tabPage1 → Datos Personales
tabPage2 → Datos Académicos
Una vez hecho esto damos clic al botón “Aceptar”. Regresamos al formulario y observamos que los nombres
de los tabPages han sido personalizados (ver figura 8).
Figura 8.
Vamos a trabajar con el tabPage “Datos Personales”. Para ello, damos clic en su nombre.
Vamos a agregar los siguientes controles: 2 GroupBox, 6 Label, 1 PictureBox, 3 TextBox, 2 RadioButton, 1
ComboBox, 1 DateTimePicker y 1 CheckBox.
La ficha debe lucir parecida a la imagen mostrada en la figura 9.
Le cambiamos la propiedad “Text” a los GroupBox así:

GroupBox1 → Datos del Estudiante
GroupBox2 → Datos del Perfil
Figura 9.
Vamos a modificar la propiedad “Items” del ComboBox. Damos clic en los tres puntos que aparecen en esta
propiedad en la ventana “Propiedades”.
Al hacer esto, nos carga una ventana como la que muestra la figura siguiente:
En esta ventana escribiremos los nombres de las asignaturas. Damos clic en el botón “Aceptar”.
Luego en la propiedad “Text” colocaremos “Seleccione…”.
Cambiaremos la propiedad “BackgroundImage” del PictureBox para agregarle una imagen como fondo.
Damos clic en los tres puntos que aparecen en esta propiedad en la ventana “Propiedades”.
Al hacer esto, nos carga una ventana como la que observamos en la siguiente imagen:
Seleccionamos la opción “Archivo de recurso del proyecto”, luego damos clic en el botón “Importar”. Nos
carga una ventana, en la cual tenemos que buscar una imagen previamente descargada, la seleccionamos y
damos clic en el botón “Abrir”.
Regresará el foco a la ventana previa y lucirá así:

Damos clic en el botón “Aceptar”. De esta forma agregamos la imagen como un recurso a nuestro proyecto,
tal como observamos en la ventana “Explorador de Soluciones”.
Cambiamos la propiedad “BackgroundimageLayout” a su valor “Strech”, para que la imagen luzca centrada
en el control PictureBox.
Al control DataTimePicker le cambiamos la propiedad “Format” a su valor “Short”, para que nos aparezca la
fecha en un formato corto.
Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación. Al hacer esto, observamos
que nos carga el formulario del ejemplo1. Para cambiar esto, damos clic en “Program.cs” en la ventana
“Explorador de soluciones”. Observemos que en el comando “Applicatiom.Run()” está ejecutando el
formulario del ejemplo 1. Tenemos que cambiar esta instrucción para que ejecute el formulario correspondiente
al ejemplo 2.
Es decir, que debemos escribir la instrucción: Application.Run(new FrmRepetitivas());

Al presionar “F5” nos cargará una ventana similar a la que se observa en la figura 10.

Control Valor
TextBox1 txtNombres
TextBox2 txtApellidos
TextBox3 txtCarnet
PictureBox1 pbxFoto
radioButton1 rbtnHombre
radioButton2 rbtnMujer
comboBox1 cmbMateria
dateTimePicker1 dtpIngreso
checkBox1 chbxMostrar
Figura 10.
Ahora vamos a trabajar con el tabPage “Datos Académicos”. Para ello, damos clic en su nombre.
Vamos a agregar los siguientes controles: 2 GroupBox, 4 Label, 4 TextBox y 3 Button.
La ficha debe lucir parecida a la siguiente figura:
Figura 11.

GroupBox3 → Ingresar Datos de las Notas
GroupBox4 → Cálculos
Control Valor
TextBox1 txtCantidad
TextBox2 txtPromedio
TextBox3 txtNotaMin
TextBox4 txtNotaMax
Button1 btnIngresar
Button2 btnNuevo
Button3 btnSalir
De esta forma hemos terminado el diseño de nuestra aplicación. A continuación, procedemos a realizar la
codificación de los botones.
Para ingresar los datos de las evaluaciones y las notas utilizaremos un control “InputBox”. Para ello tenemos
que agregar una referencia. Vamos a la ventana “Explorador de soluciones”, ubicamos el elemento
“References (Referencias)”, damos clic derecho, en el menú contextual que aparece, damos clic en la opción
“Agregar referencia…”
Nos aparece la ventana que se observa en la siguiente figura:
Figura 12.
En esta ventana seleccionamos la referencia “Microsoft.VisualBasic” y damos clic al botón “Aceptar”. De

esta forma, ya tenemos agregada la referencia (lo podemos verificar en la ventana “Explorador de soluciones”)
Ahora si ya podemos utilizar el control “InputBox”. Primero, declaramos las variables que utilizaremos, las
declaramos de tipo global, es decir, fuera de todo evento, así:
// Declaramos variables a utilizar
private string[,] Evaluaciones; /* Matriz para almacenar el nombre de la evaluación y la nota
obtenida */
double promedio = 0;
double minimo = 11, maximo = 0; // Para comparar con las notas obtenidas
string EvalMin, EvalMax; // Para almacenar el nombre de las evaluaciones
Damos doble clic al botón “Ingresar”. Agregamos el siguiente código al método “Click”:
private void btnIngresar_Click(object sender, EventArgs e)
{
//Declaración de variables
int cantNotas;
double suma = 0;
//Entrada de datos
cantNotas = Convert.ToInt32(txtCantidad.Text);
/* Inicializamos la matriz, como segundo parámetro colocamos 2, pues solo se manejarán

dos columnas */
Evaluaciones = new string[cantNotas, 2];
//Ingresamos datos a la matriz con un inputBox

//Para ingresar datos a la matriz
for (int i = 0; i < cantNotas; i++)
{
Evaluaciones[i, 0] = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Nombre de
la evaluación " + (i + 1), "Universidad");
Evaluaciones[i, 1] = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Nota
obtenida en la evaluación " + (i + 1), "Universidad");
}
// Para calcular nota promedio, nota mínima y nota máxima

for (int j = 0; j < cantNotas; j++)
{
suma = suma + Convert.ToDouble(Evaluaciones[j, 1]);
// Para encontrar la evaluación que tiene la nota mínima

if (minimo > Convert.ToDouble(Evaluaciones[j, 1]))
{
minimo = Convert.ToDouble(Evaluaciones[j, 1]);
EvalMin = Evaluaciones[j, 0];
}
// Para encontrar la evaluación que tiene la nota máxima

if (maximo < Convert.ToDouble(Evaluaciones[j, 1]))
{
maximo = Convert.ToDouble(Evaluaciones[j, 1]);
EvalMax = Evaluaciones[j, 0];
}
}
promedio = Math.Round(suma/cantNotas, 2); // Para que el promedio se muestre con 2 decimales
//Salida de información
txtPromedio.Text = Convert.ToString(promedio);
txtNotaMin.Text = EvalMin.ToUpper() + " : " + Convert.ToString(minimo);
txtNotaMax.Text = EvalMax.ToUpper() + " : " + Convert.ToString(maximo);
}
Damos doble clic al botón “Nuevo”. Agregamos el siguiente código al método “Click”:
{
// Limpiamos todos los cuadros de texto
txtCantidad.Clear();
txtPromedio.Clear();
txtNotaMin.Clear();
txtNotaMax.Clear();
// Reseteamos las variables

minimo = 11;
maximo = 0;
}
Damos doble clic al botón “Salir”. Agregamos el siguiente código al método “Click”:
{
Close();
}
Guía 6 Ejemplo 3: Uso de Funciones y Procedimientos.

Elaborar una aplicación Windows Forms que permita gestionar los retiros y depósitos de la cuenta bancaria de
un cliente. Se debe primero ingresar los datos del cliente y el monto de apertura de la cuenta de ahorros.
Considerar las siguientes condiciones:
▪ El cliente puede realizar “N” depósitos, almacenándolos en su cuenta de ahorros.
▪ El cliente puede realizar “N” retiros, pero siempre que se realiza el retiro se debe tener en cuenta
inicialmente que el monto de retiro no exceda el saldo de su cuenta de ahorros.
▪ Se debe mostrar el historial de depósitos y retiros realizados por el cliente.
▪ Resolver utilizando funciones y procedimientos.
Para solucionar este problema, agregaremos un nuevo formulario en el proyecto que hemos creado al inicio de
este guía; para ello utilizaremos el método mostrado en el ejemplo 2. Nombraremos el formulario como
“FrmCuenta”.
El formulario debe lucir parecido al que se muestra en la figura 13.
Vamos a agregar los siguientes controles al formulario: 3 GroupBox, 5 Label, 3 TextBox, 5 Button y 2 ListBox.
GroupBox1 → Ingresar Datos de la Cuenta
GroupBox2 → Transacciones
GroupBox3 → Historial de Transacciones
Figura 13.
Para que el formulario no tenga los botones de control (Maximizar, Minimizar, Cerrar) tenemos que colocar el
valor “False” en las siguientes propiedades: “ControlBox”, “MinimizeBox”, “MaximizeBox”.

Control Valor
TextBox1 txtCliente
TextBox2 txtMonto
TextBox3 txtSaldo
Button1 btnAbrirCuenta
Button2 btnDeposito
Button3 btnRetiro
Button4 btnNuevo
Button5 btnSalirAplicacion
ListBox1 lstDepositos
ListBox2 lstRetiros
De esta forma hemos terminado el diseño de nuestra aplicación. A continuación, procedemos a realizar la
codificación de la aplicación.
Primero declaramos las variables globales que necesitaremos:
private Double monto; // Para almacenar el monto de la cuenta
Lo siguiente será dar doble clic al botón “SALIR”, y en su evento “Click” digitaremos lo siguiente:
Close();
Esto nos servirá para cerrar nuestra aplicación, pues el formulario no tiene el botón por defecto “X”.
Vamos a definir dos procedimientos: uno para desactivar un grupo de controles y otro para activar ese mismo
grupo de controles.
La lógica que utilizaremos es que los botones “Deposito” y “Retiro” inicialmente estarán deshabilitados, y se
habilitarán hasta que se abra la cuenta de ahorros.
Entonces agregamos el siguiente código en el cuerpo de la clase que define nuestro formulario:
//Procedimiento que permite activar los controles
private void ActivarControles()
{
// Se habilitan los botones de las transacciones
btnDeposito.Enabled = true;
btnRetiro.Enabled = true;
// Desactivamos los controles del GroupBox "Ingresar datos de la cuenta”

txtCliente.Enabled = false;
txtMonto.Enabled = false;
btnAbrirCuenta.Enabled = false;
}
De manera similar, definiremos el procedimiento “DesactivarControles”, que hará lo opuesto al

procedimiento “ActivarControles”:
//Procedimiento que permite desactivar los controles
private void DesactivarControles()
{
// Se deshabilitan los botones de las transacciones
btnDeposito.Enabled = false;
btnRetiro.Enabled = false;
// Activamos los controles del GroupBox "Ingresar datos de la cuenta”

txtCliente.Enabled = true;
txtMonto.Enabled = true;
btnAbrirCuenta.Enabled = true;
}
Ubicamos el constructor de nuestro formulario y en él colocamos las siguientes líneas de código:

// Al cargar la aplicación, los botones "Deposito" y "Retiro" estarán deshabilitados
DesactivarControles();
Presionamos “F5” para que la aplicación se ejecute, y observaremos que los botones “Depósito” y “Retiro”
se encuentran deshabilitados.
A continuación, vamos a definir una función que nos va a servir para capturar el monto de dinero que se va a
operar en cualquiera de las dos transacciones:
/* Función para capturar el monto digitado por el usuario para cualquiera de las dos transacciones.
Recibirá como parámetro una cadena de caracteres */
private Double Leer(string mensaje)
{
//Leemos la cantidad a retirar o depositar con un “InputBox”
Double cantidad;
cantidad = Convert.ToDouble(Microsoft.VisualBasic.Interaction.InputBox("Ingrese monto a " +
mensaje, "Gestión de Ahorros", "0"));
return cantidad; // Valor devuelto por la función al código que la invoca
Recordemos que para utilizar un control InputBox debemos agregar la referencia “Microsoft.VisualBasic”.
También definiremos un procedimiento que muestre el saldo de la cuenta en cualquier momento:
// Procedimiento que permite mostrar el monto actual
private void Mostrar()
{
// Mostrará el saldo existente en la cuenta en el TextBox correspondiente
// Para mostrar el valor siempre con dos decimales, aunque se introduzca sin decimales
txtSaldo.Text = "$ " + monto.ToString("####0.00");
}
Damos doble clic en el botón “Abrir Cuenta”, colocamos el siguiente código en el evento “Click”:
private void btnAbirCuenta_Click(object sender, EventArgs e)
{
string NombreCliente;
NombreCliente = txtCliente.Text;
monto = Convert.ToDouble(txtMonto.Text); //Leemos el monto a depositar
if (monto > 0) // El monto de apertura debe ser un valor positivo

{
ActivarControles(); // Activamos los controles si el monto de depósito es correcto
Mostrar(); // Llamamos al procedimiento
}
else
{
//Mostramos un mensaje de error si el monto inicial es cero o negativo
MessageBox.Show("El monto de apertura debe ser mayor a cero.", "Gestión de Ahorros",
MessageBoxButtons.OK, MessageBoxIcon.Error);
txtMonto.Focus(); // Retorna el cursor al TextBox donde debe ingresarse el monto
}
}
Podemos probar nuestra aplicación y observaremos que, si el monto es mayor que cero, los controles de
apertura de cuenta se desactivan y se activan los botones de transacciones (ver figura 14).
Figura 14.
Damos doble clic en el botón “Depósito” y en el evento “Click” colocamos el siguiente código:
private void btnDeposito_Click(object sender, EventArgs e)
{
double deposito; // monto de dinero a depositar
//Llamamos a la función leer y le enviamos como parámetro la palabra "Depositar"

deposito = Leer("Depositar");
monto = monto + deposito; // actualizamos monto de la cuenta
// lo mostraremos en el ListBox "Depósitos"
lstDepositos.Items.Add("$ " + Convert.ToString(deposito));
Mostrar(); // Llamada al procedimiento "Mostrar"
}
Tenemos que dar doble clic al botón “Retiro” y en el evento “Click” colocamos el siguiente código:
private void btnRetiro_Click(object sender, EventArgs e)
{
double retiro; // monto de dinero a retirar
//Llamamos a la función leer y le enviamos como parámetro la palabra "Retirar"

retiro = Leer("Retirar");
// Verificamos que la cantidad a retirar sea menor al saldo en la cuenta

if (retiro <= monto)
{
monto = monto - retiro;
// lo mostraremos en el ListBox "Retiros"
lstRetiros.Items.Add("$ " + Convert.ToString(retiro));
Mostrar(); // Llamada al procedimiento "Mostrar"
}
else
{
//Si la cantidad a retirar es mayor al monto actual mostramos un error
MessageBox.Show("La cantidad a retirar excede el saldo disponible en la cuenta",
"Gestión de Ahorros", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Ahora codificamos el botón “Nuevo Cliente”, damos doble clic y colocamos el siguiente código en el evento
“Click”:
{
// Limpiamos todos los controles para poder ingresar un nuevo cliente
txtCliente.Clear();
txtMonto.Clear();
txtSaldo.Clear();
lstDepositos.Items.Clear();
lstRetiros.Items.Clear();
// Llamamos al procedimiento que desactiva los botones de transacciones

DesactivarControles();
}
Podemos probar como funciona nuestra aplicación.
Sin embargo, no hemos validado los datos que introduce el usuario. Vamos a validar en una forma distinta lo
que el usuario debe digitar en los TextBox del área de ingreso de datos.
Utilizaremos el evento “KeyPress” de los TextBox.

Para ello, ubicamos la ventana “Propiedades” y ubicamos el botón “Eventos”:
Damos clic en el botón y ubicamos el método “KeyPress” y damos doble clic en el área en blanco a la par del
nombre:
Dar doble
clic acá
Nos cargará el método en el área de edición de código. Ahí digitamos lo siguiente:

private void txtCliente_KeyPress(object sender, KeyPressEventArgs e)
{
// Esto validará que cuando el usuario intente ingresar números, le muestre un mensaje de error
if (!(char.IsLetter(e.KeyChar)) && (e.KeyChar != (char)Keys.Back) &&
(e.KeyChar != (char)Keys.Space) && (e.KeyChar != (char)Keys.Enter))
{
MessageBox.Show("Sólo se permiten letras.", "Advertencia", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
e.Handled = true;
return;
}
}
Podemos probar nuestra aplicación, intentando digitar números como nombre del cliente, veremos la siguiente
imagen (ver figura 15).
Algo similar haremos con el TextBox donde debe digitarse el monto con el que se apertura la cuenta. Solo que
aquí debemos validar que no se introduzcan letras, así:
private void txtMonto_KeyPress(object sender, KeyPressEventArgs e)

{
// Esto validará que cuando el usuario intente ingresar letras, le muestre un mensaje de error
if (!(char.IsNumber(e.KeyChar)) && (e.KeyChar != (char)Keys.Back) &&
!(e.KeyChar.ToString().Equals(".")))
{
MessageBox.Show("Sólo se permiten números.", "Advertencia", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
e.Handled = true;
return;
}
}
Figura 15.
Podemos probar nuestra aplicación, intentando digitar letras como monto, veremos algo parecido a la figura
siguiente:
Figura 16.
De esta manera hemos finalizado nuestra aplicación.
Guía 6 Ejemplo 4: Uso de Formulario como un Menú.

Se necesita modificar la aplicación resultante de los ejemplos 1 y 2, de tal manera que a partir de un formulario
principal (Menú) se pueda cargar las dos distintas aplicaciones desarrolladas en dichos ejemplos.
Para resolver este problema, abrimos una vez más el proyecto desarrollado en el ejemplo 1 (que combina las
aplicaciones desarrolladas en los ejemplos 1 y 2). Es el proyecto que tiene los formularios que se observan en
la siguiente figura:
Debemos agregar un tercer formulario, le colocaremos como nombre “FrmMenu”:
En este formulario agregaremos: 1 Label y 3 Button.

El formulario debe lucir parecido al que se muestra en la imagen siguiente:

Control Valor
Button1 btnEjemplo1
Button2 btnEjemplo2
Button3 btnSalir
Procedemos a codificar los eventos “Click” de cada uno de los botones.

Para el botón “Salir”:
{
Close();
}
Para el botón “Ejemplo1”:

private void btnEjemplo1_Click(object sender, EventArgs e)
{
// Definimos un objeto del tipo de formulario que queremos mostrar
FrmUsoIf IrEjemplo1 = new FrmUsoIf();
/* Esta variante del evento Show, muestra el formulario con un propietario especificado, en
este caso, el “FrmMenu”, y se utiliza el puntero this para referirse a él */
IrEjemplo1.Show(this); // Para mostrar el formulario deseado
this.Hide(); // Ocultamos Formulario padre, es decir “FrmMenu”
}
Para el botón “Ejemplo2”:

private void btnEjemplo2_Click(object sender, EventArgs e)
{
// Definimos un objeto del tipo de formulario que queremos mostrar
FrmRepetitivas IrEjemplo2 = new FrmEjemplo2();
/* Esta variante del evento Show, muestra el formulario con un propietario especificado, en
este caso, el “FrmMenu”, y se utiliza el puntero this para referirse a él */
IrEjemplo2.Show(this); // Para mostrar el formulario deseado
this.Hide(); // Ocultamos Formulario padre, es decir “FrmMenu”
}
Debemos agregar una línea de código a cada método “Click” de los botones “Salir” de los ejemplos 1 y 2, así:
{
// Esta línea debe agregarse hasta que se implemente el ejemplo 4
this.Owner.Show(); // Para llamar al formulario propietario (padre), es decir "FrmMenu"
Close();
}
Antes de probar la aplicación tenemos que cambiar en “Program.cs”, que corra el formulario que acabamos
de crear, es decir;
Application.Run(new FrmMenu());
Hoy si, podemos probar nuestro primer menú creado con formularios.
Ejercicios de práctica
1. Modificar la aplicación resultante del ejemplo 2 de la siguiente forma:

▪ Hacer las validaciones necesarias para que los datos introducidos por el usuario no causen que la
aplicación falle.
▪ Colocar ayuda visual que facilite al usuario utilizar la aplicación.
2. Modificar la aplicación resultante del ejemplo 3 de la siguiente forma:

▪ Colocar ayuda visual que facilite al usuario utilizar la aplicación.
Tarea Complementaria
1. Modificar la aplicación resultante del Ejemplo 4 de la siguiente forma:

a. Agregar una opción para que a partir del Menú pueda accederse al formulario “FrmCuenta”
desarrollado en el ejemplo 3.
2. Modificar la aplicación resultante del Ejemplo 2 de la siguiente forma:

a. Todos los datos introducidos en la ficha “Datos Personales”, a excepción de la fotografía,
deben aparecer en un GroupBox en la ficha “Datos Académicos”, si el usuario selecciona el
CheckBox “Desea mostrar estos datos”.
Considerar todas las validaciones necesarias para un correcto funcionamiento de la aplicación.

Incluir ayudas visuales para el usuario.
3. Elaborar una aplicación en Windows Forms que a partir de un Menú Principal permita llamar a las
siguientes aplicaciones:
a. Solicitar al usuario que digite un año, y debe determinarse si es un año bisiesto o no.
b. Ingresar la nota final de “N” estudiantes y mostrar los datos ordenados en forma ascendente.
c. Solicitar al usuario que introduzca un número del 1 al 12 y de acuerdo con el dato introducido
se muestre el número de días que posee ese mes del año con su respectivo nombre. (NOTA:
Febrero tiene 28 días)
Por ejemplo:
Digitamos: 3
Nos presenta: El mes de Marzo posee 31 días
Debe resolverse utilizando la estructura repetitiva “switch”.
Considerar todas las validaciones necesarias para un correcto funcionamiento de la aplicación.

Incluir ayudas visuales para el usuario.
Bibliografía
❖ Deitel, Harvey M. y Paul J. Deitel, Cómo Programar en C#, Segunda Edición, México, 2007.

Guía No. 6 Programación I

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía No. 6 Programación I

Cargado por

Copyright:

Formatos disponibles

Programación I. Guía No.

Facultad: Informática y Ciencias Aplicadas

Tema: “Estructuras de Control, funciones, procedimientos y

Identificar los controles comúnmente utilizados para aplicaciones Windows Forms.

Los botones que pueden agregarse a un MessageBox son:

Los íconos que pueden utilizarse en este método son:

Question: El cuadro de mensaje muestra un símbolo de interrogación.

En la siguiente figura, observamos un ejemplo de un MessageBox:

A continuación se detallan los pasos para añadir InputBox en Visual C#:

2. En la ventana que aparece, buscamos y seleccionamos la referencia “Microsoft.VisualBasic”

3. Dar clic en el botón “Aceptar”.

Una vez hecha la referencia ya podemos utilizar ese método.

Guía 6 Ejemplo 1: Uso de Estructuras Condicionales.

Creamos nuestro proyecto, y le colocamos como nombre “Guia6”.

//Evaluamos si es un cuadrado o un rectángulo

//Calcular el área y el perímetro

txtPerimetro.Text = Convert.ToString(perimetro) + " cms.";

//Para que los PictureBox no se visualicen

// Para que, al cargar el formulario, los PictureBox no se vean

Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación.

Para validar esta aplicación utilizaremos el control “ErrorProvider”.

Luego le cambiamos la propiedad “Name” y le colocamos “errorControl”.

errorControl.Clear(); // Limpiar todos los mensajes de error

Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación.

Luego le cambiamos la propiedad “Name” y le colocamos “ttMensajes”.

Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación.

Guía 6 Ejemplo 2: Uso de Estructuras Repetitivas.

Nos aparecerá una ventana similar a la que se observa en la imagen siguiente:

Le cambiamos la propiedad “Text” al formulario, le colocamos “Ejemplo Estructura Repetitiva”.

Al hacer esto, nos carga una ventana como se observa en la figura 7.

Le cambiamos la propiedad “Text” a los GroupBox así:

Luego en la propiedad “Text” colocaremos “Seleccione…”.

Regresará el foco a la ventana previa y lucirá así:

Es decir, que debemos escribir la instrucción: Application.Run(new FrmRepetitivas());

Le cambiamos la propiedad “Name” a los objetos de esta manera:

Le cambiamos la propiedad “Text” a los GroupBox así:

Nos aparece la ventana que se observa en la siguiente figura:

En esta ventana seleccionamos la referencia “Microsoft.VisualBasic” y damos clic al botón “Aceptar”. De

/* Inicializamos la matriz, como segundo parámetro colocamos 2, pues solo se manejarán

//Ingresamos datos a la matriz con un inputBox

// Para calcular nota promedio, nota mínima y nota máxima

// Para encontrar la evaluación que tiene la nota mínima

// Para encontrar la evaluación que tiene la nota máxima

promedio = Math.Round(suma/cantNotas, 2); // Para que el promedio se muestre con 2 decimales

// Reseteamos las variables

Presionamos la tecla “F5” para visualizar el funcionamiento de nuestra aplicación.

Guía 6 Ejemplo 3: Uso de Funciones y Procedimientos.

Le cambiamos la propiedad “Name” a los objetos de esta manera:

// Desactivamos los controles del GroupBox "Ingresar datos de la cuenta”

De manera similar, definiremos el procedimiento “DesactivarControles”, que hará lo opuesto al

// Activamos los controles del GroupBox "Ingresar datos de la cuenta”

Ubicamos el constructor de nuestro formulario y en él colocamos las siguientes líneas de código:

monto = Convert.ToDouble(txtMonto.Text); //Leemos el monto a depositar

if (monto > 0) // El monto de apertura debe ser un valor positivo

//Llamamos a la función leer y le enviamos como parámetro la palabra "Depositar"

//Llamamos a la función leer y le enviamos como parámetro la palabra "Retirar"

// Verificamos que la cantidad a retirar sea menor al saldo en la cuenta

// Llamamos al procedimiento que desactiva los botones de transacciones

Podemos probar como funciona nuestra aplicación.

Utilizaremos el evento “KeyPress” de los TextBox.

Nos cargará el método en el área de edición de código. Ahí digitamos lo siguiente:

private void txtMonto_KeyPress(object sender, KeyPressEventArgs e)

De esta manera hemos finalizado nuestra aplicación.

Guía 6 Ejemplo 4: Uso de Formulario como un Menú.