You are on page 1of 85

Desarrollo de aplicaciones

Windows. Aspectos básicos


Tclgo. César O. Vanegas M.
Sinopsis:

Texto dirigido a aquellas personas que quieran iniciarse en la creación de


aplicaciones para entorno Windows, empleando Visual Studio 2005. Como
lenguajes de programación se utiliza Visual C#.

Se trata de una obra organizada alrededor de cuatro bloques principales de


contenidos.

El primer bloque abarca los capítulos versados en la creación de proyectos


sencillos, utilizando Visual Studio 2005 como herramienta de desarrollo. El segundo
bloque se adentra en los dos lenguajes de programación, explicando aquellas
características más importantes de cada uno, el tercer bloque desarrollamos
aplicaciones con base de datos Microsoft Acces y Finalmente, el cuarto bloque se
encuentra enfocado en el diseño e implementación de aplicaciones Windows,
haciendo uso del conjunto de tipos ofrecidos por la plataforma .NET Framework al
programador, así como del numeroso grupo de diseñadores y asistentes del
entorno de desarrollo.

A lo largo de todo el texto, el lector encontrará un gran número de ejemplos


prácticos que le permitirán aplicar de forma inmediata todos aquellos conceptos
aprendidos en los diferentes capítulos de que se compone esta obra.
CESVAN

Desarrollo de aplicaciones Windows. Aspectos básicos


© César Octavio Vanegas Mendoza
© De esta edición 02 de Octubre del 2010

Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra


solo puede ser realizada con la autorización de su titular, salvo excepción prevista por la ley. Diríjase
al Autor si necesita fotocopiar, escanear o hacer copias digitales de algún fragmento de esta obra.
INDICE
Capítulo I: Entorno de Visual C#
Introducción .................................................................................................................. 2
Objetivos del Libro ……………....................................................................................... 2
Primeros Pasos ………………….................................................................................... 4
1.1 Entorno de Desarrollo Visual C#............................................................................... 5
1.2 Herramientas IDE...................................................................................................... 6
1.3 Crear Proyectos en Visual C# ………………………………………………………… 7
1.4 Explorado de Soluciones ……………………………………………………………….. 8
1.5 Estructura General de un programa en C# …………………………………………… 9
1.6 Main y argumentos de la línea Comando ……………………………………………… 10

Capítulo II: Elementos de Programación


Elementos ……………………………............................................................................... 12
2.1 Agregar comentarios a nuestros programas............................................................... 12
2.2 Variables y Constantes en Visual C# ………………………………………………….. 12
2.3 Tipos de Datos en Visual C# ……………………………………………………………. 13
2.4 Operadores en Visual C# ………………………………………………………………. 14

Capítulo III: Programación Windows


Aplicaciones…………………………............................................................................... 20
3.1 Uso Componentes Label ……………......................................................................... 20
3.2 Uso Componentes Label y texboxt …………………………………………………….. 21
3.3 Uso de Componentes Label, textBox y Button ……………………………………….. 24
Aplicaciones Propuestas …………………………………………………………………….. 25

Capítulo IV: Elementos de Programación


Programacion………………………............................................................................... 29
4.1 Utilización de Constantes y variables......................................................................... 29
4.2 Utilización de eventos y de la función Keychar() …………………………………….. 31
4.3 Utilización de Funciones o Clases ……………………………………………………… 34
4.4 Formatos de Datos ………………………………………………………………………. 46
4.5 Metodos de la Clase String ……………………………………………………………… 52
4.6 Arrays ……………………………………………………………………………………… 64
Aplicaciones Propuestas …………………………………………………………………….. 65

Capítulo V: Mejorando el Aspecto de los Formularios


Programacion………………………............................................................................... 81
5.1 Utilización de los controles PictureBox y Timer ........................................................ 81
5.2 Utilización del control ProgressBar, TrackBar, NotifyIcon y NumericUpDown …… 84
5.3 Utilización del control ImageList ……………………………………………………….. 87
5.4 Utilización del control StatusStrip(Barra de Estado) ………………………………… 88
5.5 Utilización del control MonthCalendar y el DateTimePicker ………………………. 92
Aplicaciones Propuestas ……………………………………………………………………. 92

Capítulo VI: Personalización de Datos


Personalizacion……………………….............................................................................. 96
6.1 Utilización del control ComboBox …………………………………………………….... 96
6.2 Utilización del control ListBox y CheckedListBox …………………………….. …….. 100
6.3 Utilización del control RadioButton ……………………………………………………. 107
6.4 Utilización del control CheckBox ………………………………………………………. 111
6.4 Utilización del control TabControl ……………………………………………………… 116
6.5 Como Agregar controles Adicionales a la caja de Herramientas …………………… 121
6.6 Utilización de los controles MaskedTexbox y LinkLabel …………………………….. 122

Capítulo VII: Manipulación de Varios Formularios


7.1 Utilización de Varios Formularios........................................................................... 124
7.2 Como pasar datos de un formulario a otro …………………………………………..... 130
7.3 Utilización del control ListView y TreeView ……………………………………………. 135
Aplicaciones Propuestas ……………………………………………………………………. 135

Capítulo VIII: Formularios MIDI y Controles Avanzados

8.1 Diseño de Menú ........................................................................................................ 140


8.2 Que es un formularios MIDI ……………………………………………………………… 142
8.3 Utilización de Cuadros de Diálogos ……………………………………………………. 151
8.4 El Control DataGridView ………………………………………………………………… 159
Aplicaciones Propuestas …………………………………………………………………….. 160

Capítulo IX: Conexiones a Base de datos con Oledb y Odbc

Referencias y Excepciones ........................................................................................... 169


9.1 Referencias………………………………………………………………………………… 169
9.2 Excepción de Errores …………………………………………………………………….. 170
9.3 Tipos de Accesos a Base de Datos …………………………………………………….. 173
9.3.1 Acceso a datos desde ADO.NET mediante C# y OLEDB ………………… 173
9.3.1.1 Acceso a Datos mediante DataSet ……………………………….. 174
9.3.1.2 Acceso a Datos mediante DataReader …………………………… 176
9.3.1.3 Acceso a Datos mediante ExecuteNonQuery ……………………. 178
9.3.2 Acceso a datos desde ADO.NET mediante C# y ODBC …………………… 179
Aplicaciones Propuestas …………………………………………………………………….. 180

Capítulo X: Creación de Consultas y Reportes con Base de


datos Acces
Mantenimiento de Datos ........................................................................................... 203
10.1 Mantenimiento de datos desde un ListBox………………………………………… 203
10.2 Aplicación con Base de datos Relacionada………………………………………….. 210
10.3 Diseño de reporte con CrystalReport……..………………………………………….. 232
10.4 Pasos para la creación de reportes con CrystalReport………….. ………………… 247
10.5 El Control CrystalReportView……………………….. ……………………………….. 255

Capítulo XI: Creación de Consultas y Reportes con Base de


datos SQL
Creación de Base de Datos ........................................................................................... 252
11.1 Diseño de Base de datos con SQL EXPRESS………………………………………… 252
11.2 Creación de una fuente de datos SQL……………………………………………….. 264
11.3 Controles no enlazados a datos……..……………………………………………….. 269
11.4 Diseño del reporte CrystalReport con SQL………….………….. ………………… 275
11.5 Creando el Visualizador de Informe……………….. ……………………………….. 279
“La Práctica hace al Maestro” Página 1
La habitual expresión "los tiempos avanzan que es una barbaridad" que solemos oír
con bastante frecuencia, resulta ciertamente aplicable al sector informático y, más aún
si cabe, al mundo de los lenguajes y herramientas de programación. En apenas una
generación humana hemos pasado de los lenguajes cercanos a la máquina a los
actuales y modernos lenguajes orientados a componentes, dejando por el camino
lenguajes sin estructuras propiamente dichas, como los antiguos BASIC y FORTRAN;
lenguajes procedimentales, como Pascal y C, y lenguajes orientados a objetos, como
C++, por mencionar los más conocidos.

En la actualidad la mayoría de las aplicaciones que se crean son desarrolladas a


partir de componentes software, pequeñas porciones de código reutilizable que, en
ocasiones, forman parte de los servicios que ofrece el lenguaje o el sistema operativo,
mientras que en otras se adquieren por separado de terceras partes. En cualquier
caso, los programadores de hoy necesitan lenguajes de programación que sean
capaces de utilizar esos componentes como una construcción más, al tiempo
que simplifican su desarrollo para uso propio o de terceros. Además, no se exige única
mente un compilador o un entorno básico de edición/compilación/depuración, sino un
completo entorno que facilite el diseño de las interfaces de usuario, la gestión de los
proyectos, que cuente con herramientas para el acceso a datos, etc.

Lo que Microsoft nos ofrece con Visual C# es un entorno de desarrollo de última


generación, con gran parte de los elementos de Visual Studio 2005, conjuntamente
con el compilador de uno de los lenguajes de programación más avanzados que existen
en la actualidad: C#. A esto se une una extensa documentación de referencia en
línea, material de apoyo como este libro y una amplia comunidad de
programadores a nivel mundial.

Objetivos de este libro

La finalidad de este libro es guiarle mientras da sus primeros pasos en el aprendizaje


de Visual C#, mostrándole las estructuras del lenguaje de programación, las tareas
comunes en el entorno de desarrollo y enseñándole a crear aplicaciones, con o sin
interfaz gráfica de usuario, que usan algunos de los componentes y servicios de que
dispone esta plataforma.

Asumimos que el lector tiene conocimientos generales sobre programación, aunque


no esté familiarizado con versiones previas del lenguaje C#, Visual Studio o la
plataforma .NET. El reducido espacio de este libro no nos permite, por ejemplo,
adentrarnos en la teoría relativa a la programación orientada a objetos o los aspectos
teóricos sobre tratamiento de bases de datos. Sí se tratarán, por el contrario, los temas
relativos a orientación a objetos con C# y el acceso a bases de datos con los
componentes de Visual C#.

El objetivo es que cuando finalice la lectura de este libro tenga los


conocimientos generales necesarios para crear aplicaciones básicas y que, al

“La Práctica hace al Maestro” Página 2


tiempo, se sienta capacitado para adentrarse en temas más avanzados

En la redacción de este libro se ha utilizado una versión preliminar de Visual


Studio C# 2005 en español, por lo que las imágenes incluidas del entorno, ventanas y
opciones aparecen en dicho ENTORNO

“La Práctica hace al Maestro” Página 3


En este primer capítulo nos proponemos dar nuestros primeros pasos con Visual C#,
iniciando un nuevo proyecto, familiarizándonos con los distintos elementos que
aparecen en el entorno de desarrollo, editando nuestra primera línea de código,
aprendiendo a compilar, depurar y ejecutar la aplicación desde el propio entorno y a
distribuir ese programa para que puedan utilizarlo los usuarios finales.

Todo este proceso nos servirá en los capítulos siguientes, y en cualquier otro proyecto
que aborde con posterioridad, ya que en él conoceremos muchos conceptos, y algunos
de los elementos y opciones que nos ofrece esta herramienta.

Al iniciar Visual C# por primera vez nos encontramos con un entorno como el que
aparece en la figura 1.1 (página siguiente), con elementos habituales como un menú de
opciones, una barra de botones debajo y una serie de ventanas adosadas. La Página
de inicio aparece en primer plano, ofreciendo una lista de los proyectos en los que
hemos trabajado recientemente (vacía por ahora) y enlaces para abrir y crear otros
proyectos; debajo una lista de accesos directos a temas de la ayuda y a la derecha una
serie de hipervínculos a noticias relacionadas con el pro- ducto obtenidas a través de
Internet. Esta página estará vacía si no disponemos de una conexión a la red.

La parte derecha del entorno está ocupada por el Explorador de soluciones, una
ventana que nos servirá para gestionar los elementos que forman parte de cada
proyecto. Observe la parte superior de ese panel: en el extremo derecho, tras el título,
aparece una serie de iconos:

Este botón da paso a un menú desplegable que nos permite establecer la


configuración de la ventana, eligiendo entre acoplarla a otras (estado en el que
se encuentra por defecto), dejarla flotante, ocultarla automáticamente, etc.

Este icono aparece en las ventanas que se encuentran acopladas. Al


hacer clic sobre él la ventana pasa a ocultarse automáticamente cuando no está
en uso, quedando visible únicamente una pestaña. En el margen superior
izquierdo de la figura 1.1 puede ver una pestaña con el título Toolbox,
correspondiente al Cuadro de herramientas que se encuentra oculto. Situando
el puntero del ratón sobre esa pestaña se abrirá la ventana, que volverá a
ocultarse automáticamente cuando no se use a menos que hagamos clic sobre
este icono.

Como es fácil imaginar, este icono sirve para cerrar la ventana. Podemos
cerrar todas aquellas ventanas que no utilicemos con frecuencia, para liberar

“La Práctica hace al Maestro” Página 4


Figura 1.1. Aspecto inicial del entorno de desarrollo

El área central del entorno, donde ahora mismo se encuentra la Página de inicio, sirve
para ir mostrando las ventanas de los distintos editores y diseñadores con que cuenta
el producto. Por cada página abierta aparecerá una pestaña en la parte superior, de tal
forma que un simple clic nos llevará de una a otra.

1.1. Entorno de desarrollo de Visual C #.

El entorno de desarrollo integrado (IDE) de Visual C# es un conjunto de herramientas


de desarrollo expuestas a través de una interfaz de usuario común. Algunas de las
herramientas se comparten con otros lenguajes de Visual Studio, y otras, como el
compilador de C#, son únicas de Visual C#.

A continuación se detallan las herramientas y ventanas más importantes de Visual


C#. Las ventanas de la mayoría de estas herramientas se pueden abrir desde el menú
Ver.

El Editor de código, para escribir código fuente.

El compilador de C#, para convertir el código fuente de C# en un programa


ejecutable.

El depurador de Visual Studio, para probar el programa.

El Cuadro de herramientas y el Diseñador, para desarrollar rápidamente


interfaces de usuario con el mouse.

El Explorador de soluciones, para ver y administrar archivos de proyecto y


configuraciones.

“La Práctica hace al Maestro” Página 5


El Diseñador de proyectos, para configurar opciones del compilador, rutas de
implementación, recursos, etc.

La Vista de clases, para desplazarse por el código fuente según los tipos, no los
archivos.

La Ventana Propiedades, para configurar propiedades y eventos en los controles


de la interfaz de usuario.

El Examinador de objetos, para ver los métodos y clases disponibles en las


bibliotecas de vínculos dinámicos, incluidos los ensamblados de .NET Framework
y los objetos COM.

Document Explorer, para explorar y buscar la documentación del producto en su


equipo local y en Internet.

1.2. Herramientas IDE.

Puede interactuar con las herramientas a través de ventanas, menús, páginas de


propiedades y asistentes en el IDE. El IDE básico tiene un aspecto similar al siguiente:

El Editor de código y el Diseñador de Windows Forms utilizan la ventana principal


grande. Para alternar entre la vista de código y la vista Diseño, puede presionar F7 o
hacer clic en Código o Diseñador en el menú Ver. En la vista Diseño, puede arrastrar
controles a la ventana desde el Cuadro de herramientas, que se puede hacer visible
haciendo clic en la ficha Cuadro de herramientas del margen izquierdo.

La ventana Propiedades de la parte inferior derecha sólo contiene información en


vista Diseño. Permite establecer las propiedades y enlazar los eventos para los
controles de la interfaz de usuario, como botones, cuadros de texto, etc. Cuando esta
ventana se establece como Ocultar automáticamente, se contrae en el margen derecho
cada vez que se cambia a Vista Código.

La ventana de la parte superior derecha es el Explorador de soluciones, que


muestra todos los archivos del proyecto en una vista de árbol jerárquica. Cuando se
utiliza el menú Proyecto para agregar nuevos archivos al proyecto, se verán reflejados
en el Explorador de soluciones. Además de los archivos, el Explorador de soluciones
también muestra la configuración del proyecto y las referencias a las bibliotecas

“La Práctica hace al Maestro” Página 6


externas que necesita la aplicación.

Lista de errores aparece debajo de la ventana del editor/diseñador con una lista de
errores. Haga doble clic en un error para ir a la línea de código fuente que presenta el
problema. Presione F1 para consultar la documentación de Ayuda correspondiente al
error resaltado.

El depurador tiene distintas ventanas que muestran valores de variables e


información de tipos a medida que se ejecuta la aplicación. Puede utilizar la ventana
Editor de código mientras depura el programa para especificar una línea en la que
desee hacer una pausa durante la ejecución en el depurador y para recorrer el código
línea a línea.

1.3. Crear un proyecto en Visual C # 2005

A medida que vayamos trabajando con él, cada vez nos sentiremos más cómodos
en el entorno de Visual C# 2005 y aprenderemos a adaptarlo a nuestras necesidades.
Por el momento ya sabemos cómo disponer las ventanas en la posición que más nos
guste y establecer la configuración para que permanezcan acopladas, flotantes o se
oculten automáticamente. Ahora vamos a proceder a crear nuestro primer proyecto.

Si tenemos abierta la Página de inicio, podemos hacer clic en el enlace Crear


proyecto que aparece en la parte inferior de la sección Proyectos recientes. También
podemos sencillamente pulsar el botón Nuevo proyecto, que por defecto es el primero
de izquierda a derecha en la barra de botones; elegir la opción Archivo>Nuevo
proyecto del menú principal o pulsar la combinación de teclas Control- Mayús-N. En
cualquier caso siempre nos encontraremos con el cuadro de diálogo que aparece en la
figura 1.2, en el que se enumeran las plantillas de proyectos que tenemos instaladas.

Figura 1.2. Cuadro de diálogo desde el que iniciaremos un nuevo proyecto

En nombre del proyecto escogemos el nombre que deseamos escribir por lo general

“La Práctica hace al Maestro” Página 7


para nuestras aplicaciones Windows escogeremos WinAppUno, que significa
(Windows Aplicaciones Uno), para aplicaciones web escribiremos WebAppUno (Web
Aplicación Uno).

Los formularios son un componente más de Visual C# 2005, con la


particularidad de que actúan como contenedores, pueden alojar a otros
componentes en su interior, y el entorno cuenta con diseñadores específicos para
trabajar sobre ellos.

1.4 El explorador de soluciones.

Nuestro proyecto contendrá lo siguiente en el explorador de soluciones:

Propiedades
El nodo Propiedades representa opciones de configuración que se aplican a la
totalidad del proyecto y se almacenan en el archivo .csproj de su carpeta de
soluciones. Esta configuración incluye opciones de compilación, seguridad e
implementación, entre muchas otras. Para modificar el proyecto, se utiliza el Diseñador
de proyectos, que es un conjunto de Páginas de propiedades a las que se tiene acceso
haciendo clic con el botón secundario del mouse en Propiedades, y seleccionando
Abrir.

Referencias
En el contexto de un proyecto, una referencia identifica simplemente un archivo
binario que la aplicación necesita para poder ejecutarse. Normalmente, una referencia
identifica un archivo DLL, como uno de los archivos de la biblioteca de clases de .NET
Framework. También puede hacer referencia a un ensamblado .NET (denominado
shim) que permite que la aplicación llame a los métodos de un objeto COM o de un

“La Práctica hace al Maestro” Página 8


archivo DLL nativo de Win32. Si su programa crea una instancia de una clase definida
en otro ensamblado, debe agregar una referencia al archivo correspondiente en el
proyecto antes de compilarlo. Para agregar una referencia, haga clic en Agregar
referencia en el menú Proyecto. Todos los proyectos de C# incluyen de forma
predeterminada una referencia a mscorlib.dll, que contiene las clases básicas de .NET
Framework. Puede agregar las referencias a archivos DLL de .NET Framework
adicionales y a otros archivos haciendo clic en el Menú Proyecto y seleccionando
Agregar referencia.

Recursos
Los recursos son datos que se incluyen con la aplicación pero que se pueden
almacenar de forma que pueden modificarse con independencia del resto del código
fuente. Por ejemplo, puede almacenar todas las cadenas como recursos en lugar de
codificarlas directamente en el código fuente. De esta forma, podrá traducir las
cadenas a distintos idiomas más adelante y agregarlas a la carpeta de la aplicación
que distribuye a los clientes sin necesidad de volver a compilar el ensamblado. Los
cinco tipos de recursos definidos por Visual C# son: cadenas, imágenes, iconos, audio
y archivos. Para agregar, quitar o modificar recursos, utilice el Diseñador de recursos,
al que se tiene acceso en la ficha Recursos del Diseñador de proyectos.

Formularios
Cuando se crea un proyecto de formularios Windows Forms, Visual C# agrega de
forma predeterminada un formulario al proyecto y lo llama Form1. Los dos archivos que
representan el formulario se llaman Form1.cs y Form1.designer.cs. El código se
escribe en Form1.cs. El Diseñador de Windows Forms escribe en el archivo
designer.cs el código que implementa todas las acciones que se realizaron al arrastrar
y colocar objetos desde el Cuadro de herramientas.

Puede agregar un nuevo formulario haciendo clic en el elemento de menú Proyecto


y seleccionando Agregar Windows Forms. Cada formulario tiene dos archivos
asociados. Form1.cs, o como haya decido llamarlo, contiene el código fuente que se
escribe para configurar el formulario y sus controles, como cuadros de lista y cuadros
de texto, y responde a eventos tales como los clics en botones y las pulsaciones de
teclas. En los proyectos de formularios Windows Forms simples, la mayoría o incluso la
totalidad de la codificación se hace en este archivo.

15. Estructura general de un programa en C #

Los programas en C# pueden constar de uno o varios archivos. Cada archivo puede
contener cero o varios espacios de nombres. Un espacio de nombres puede contener
tipos como clases, estructuras, interfaces, enumeraciones y delegados, además de
otros espacios de nombres. A continuación, se muestra el esqueleto de un programa
en C# que contiene todos estos elementos.

// A esqueleto de un programa en C#
using System;
namespace YourNamespace
{
class YourClass
{

}
struct YourStruct
{

“La Práctica hace al Maestro” Página 9


}
interface IYourInterface
{

}
delegate int YourDelegate();
enum YourEnum
{

}
namespace YourNestedNamespace
{
struct YourStruct
{
}
}

class YourMainClass
{
static void Main(string[] args)
{
//Your program starts here...
}
}
}

1.6. Main y argumentos de línea de comandos

El método Main es el punto de entrada del programa, donde crea objetos e invoca
otros métodos. En un programa de C#, sólo puede haber un punto de entrada

El método Main es el punto de entrada del programa, donde se inicia y


finaliza el control.
Se declara dentro de una clase o una estructura. Debe ser estático y no
debería ser público. (En el ejemplo anterior, recibe el acceso predeterminado
de privado.)
Puede tener un tipo de valor devuelto void o int.
El método Main se puede declarar con o sin parámetros.
Los parámetros se pueden leer como argumentos de la línea de comandos
indizados basados en cero.
A diferencia de C y C++, el nombre del programa no se trata como el primer
argumento de la línea de comandos.

“La Práctica hace al Maestro” Página 10


“La Práctica hace al Maestro” Página 11
2.1. Agregar Comentarios a nuestros Programas en C #.

Para agregar comentarios en nuestro código de dos formas:

// Indica que es un comentario de una sola línea.

/* ... comentario ... */ es un comentario de una o varias líneas. Observa el ejemplo:

// Esto es un comentario de una única línea


/* Esto es un comentario que consta de
varias líneas */

2.2. Variables y Constantes en visual C #.

Una variable puede verse simplemente como un hueco en el que se puede


almacenar un objeto de un determinado tipo al que se le da un cierto nombre. Para
poderla utilizar sólo hay que definirla indicando cuál será su nombre y cuál será el tipo
de datos que podrá almacenar, lo que se hace siguiendo la siguiente sintaxis:

<tipoVariable> <nombreVariable>;

Una variable puede ser definida dentro de una definición de clase, en cuyo caso se
correspondería con el tipo de miembro que hasta ahora hemos denominado campo.
También puede definirse como un variable local a un método, que es una variable
definida dentro del código del método a la que sólo puede accederse desde dentro de
dicho código. Otra posibilidad es definirla como parámetro de un método, que son
variables que almacenan los valores de llamada al método y que, al igual que las
variables locales, sólo puede ser accedida desde código ubicado dentro del método.

El siguiente ejemplo muestra cómo definir variables de todos estos casos:

class A
{
int x, z;
int y;
void F(string a, string b)
{
Persona p;
}

En este ejemplo las variables x, z e y son campos de tipo int, mientras que p es una
variable local de tipo Persona y a y b son parámetros de tipo string. Como se muestra
en el ejemplo, si un método toma varios parámetros las definiciones de éstos se
separan mediante comas (carácter,), y si queremos definir varios campos o variables
locales (no válido para parámetros) de un mismo tipo podemos incluirlos en una misma

“La Práctica hace al Maestro” Página 12


definición incluyendo en <nombreVariable> sus nombres separados por comas.
Una constante es una variable cuyo valor puede determinar el compilador durante
la compilación y puede aplicar optimizaciones derivadas de ello. Para que esto sea
posible se ha de cumplir que el valor de una constante no pueda cambiar durante la
ejecución, por lo que el compilador informará con un error de todo intento de modificar
el valor inicial de una constante. Las constantes se definen como variables normales
pero precediendo el nombre de su tipo del modificador const y dándoles siempre un
valor inicial al declararlas. O sea, con esta sintaxis:

const <tipoConstante> <nombreConstante> = <valor>;

Así, ejemplos de definición de constantes es el siguiente:

const int a = 123;


const int b = a + 125;

2.3. Tipos de datos en visual C #.

El sistema de tipos suele ser la


parte más importante de
cualquier lenguaje de
programación. El uso correcto
de los distintos tipos de datos es
algo fundamental para que una
aplicación sea eficiente con el
menor consumo posible de
recursos, y esto es algo que se
tiende a olvidar con demasiada
frecuencia. Todo tiene su
explicación: antiguamente los
recursos de los equipos eran
muy limitados, por lo que había
que tener mucho cuidado a la
hora de desarrollar una
aplicación para que esta no
sobrepasara los recursos disponibles. Actualmente se produce el efecto contrario: los
equipos son muy rápidos y potentes, lo cual hace que los programadores se relajen, a
veces demasiado, y no se preocupen por economizar medios. Esta tendencia puede
provocar un efecto demoledor: aplicaciones terriblemente lentas, inestables y muy
poco eficientes.

Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en
la escritura de aplicaciones que en C# se ha incluido una sintaxis especial para
tratarlos. Por ejemplo, para representar números enteros de 32 bits con signo se utiliza
el tipo de dato System.Int32 definido en la BCL, aunque a la hora de crear un objeto a
de este tipo que represente el valor 2 se usa la siguiente sintaxis:

System.Int32 a = 2;

Como se ve, no se utiliza el operador new para crear objeto System.Int32, sino que
directamente se indica el literal que representa el valor a crear, con lo que la sintaxis
necesaria para crear entero de este tipo se reduce considerablemente. Es más, dado
lo frecuente que es el uso de este tipo también se ha predefinido en C# el alias int para

“La Práctica hace al Maestro” Página 13


el mismo, por lo que la definición de variable anterior queda así de compacta:

int a = 2;

System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de


nombres System se han incluido todos estos:

Tipos de datos básicos

Pese a su sintaxis especial, en C# los tipos básicos son tipos del mismo nivel que
cualquier otro tipo del lenguaje. Es decir, heredan de System.Object y pueden ser
tratados como objetos de dicha clase por cualquier método que espere un
System.Object, lo que es muy útil para el diseño de rutinas genéricas que admitan
parámetros de cualquier tipo y es una ventaja importante de C# frente a lenguajes
similares como Java donde los tipos básicos no son considerados objetos.

El valor que por defecto se da a los campos de tipos básicos consiste en poner a cero
todo el área de memoria que ocupen. Esto se traduce en que los campos de tipos
básicos numéricos se inicializan por defecto con el valor 0, los de tipo bool lo hacen
con false, los de tipo char con „\u0000‟, y los de tipo string y object con null.

2.4. Operadores en visual C #.

Los operadores sirven, como su propio nombre indica, para efectuar operaciones con
uno o más parámetros (sumar, restar, comparar...) y retornar un resultado. Se pueden
agrupar de varios modos, pero yo te los voy a agrupar por primarios, unitarios y
binarios. Aquí tienes una tabla con los operadores de C#, y luego te los explico
detalladamente:

“La Práctica hace al Maestro” Página 14


Otros operadores:

Están puestos en orden de precedencia, es decir, en el caso de haber una expresión con
varios de ellos, se ejecutan por ese orden. Ya te explicaré esto con más detalles.

Los operadores primarios son operadores de expresión. Vamos siguiendo la tabla y te


cuento de qué van:

En el caso de “(expresión)”, los operadores son realmente los paréntesis. Sirven para
modificar la precedencia.

En “objeto.miembro”, el operador es el punto. Sirve para especificar un miembro de una


clase (sea una variable, una propiedad o un método).

En “método(argumento, argumento, ...)”, los operadores vuelven a ser los paréntesis. En


este caso, sirven para especificar la lista de argumentos de un método.

En array[índice], los operadores son los corchetes. Sirven para indicar el elemento de un
array o un indizador.

Los operadores de incremento (++) y decremento (--) sirven para incrementar o disminuir
el valor de una variable en una unidad. Por ejemplo:

“La Práctica hace al Maestro” Página 15


num++;

hará que num incremente su valor en una unidad, es decir, si valía 10 ahora vale 11. Los
operadores de incremento y decremento se pueden poner delante (preincremento ó
predecremento) o bien detrás (postincremento ó postdecremento), teniendo
comportamientos distintos. Me explico: si hay un postincremento o postdecremento,
primero se toma el valor de la variable y después se incrementa o decrementa. En caso
contrario, si lo que hay es un preincremento o un predecremento, primero se incrementa
o decrementa la variable y después se toma el valor de la misma. En una línea como la
anterior esto no se ve claro, porque, además, el resultado sería el mismo que poniendo
++num. Sin embargo, veamos este otro ejemplo (num vale 10):

a = ++num;
b = a- -;

Después de ejecutar la primera línea, tanto a como num valdrían 11, ya que el
preincremento hace que primero se incremente num y después se tome su valor,
asignándolo así a la variable a. Ahora bien, después de ejecutar la segunda línea, b
valdrá 11, y a valdrá 10. ¿Por qué? Porque el postdecremento de a hace que primero se
asigne su valor actual a b y después se decremente el suyo propio.

El operador “new” sirve para instanciar objetos

El operador “typeof” es un operador de reflexión, y la reflexión es la posibilidad de


recuperar información de un tipo determinado en tiempo de ejecución. typeof devuelve el
tipo de un objeto.

“sizeof” devuelve el tamaño en bytes que ocupa un tipo determinado. Ahora bien,
solamente se puede utilizar sizeof con tipos valor y en contextos de código inseguro.
Aunque no vamos a explicar ahora este tipo de contexto, sí puedes ver cómo funciona en
ejemplo "OperadoresPrimarios", que se incluye con esta entrega.

“checked” y “unchecked” sirven para controlar si una expresión provoca o no


desbordamiento. Me explico con un ejemplo: sabemos que las variables de tipo byte
pueden almacenar valores entre 0 y 255. Si escribimos el siguiente código:

byte i=253;
checked {i+=10;}
Console.WriteLine(i);

El programa se compila, pero al ejecutar se produce un error de desbordamiento, ya que


la variable i es de tipo byte y no puede almacenar valores mayores que 255. Sin
embargo, si cambiamos checked por unchecked:

byte i=253;
unchecked {i+=10;}
Console.WriteLine(i);

El programa no produciría error de desbordamiento, ya que unchecked hace que se


omitan estos errores. En su lugar, i toma el valor truncado, de modo que después de esa
línea valdría 7. Un asunto importante en el que quiero que te fijes: checked y unchecked
son bloques de código, como se deduce al ver que está escrito con llaves, de modo que
puedes incluir varias líneas en un mismo bloque checked o unchecked.
Sí, sí, ya sé que no entiendes eso del valor truncado. Veamos: las variables numéricas
tienen un rango de datos limitado, es decir, una variable de tipo byte, por ejemplo, no

“La Práctica hace al Maestro” Página 16


puede almacenar valores menores que 0 ni mayores que 255. Cuando se trunca el valor,
lo que se hace es, para que me entiendas, colocar seguidos en una lista todos los valores
que la variable acepta, empezando de nuevo por el primero cuando el rango acaba, y
después se va recorriendo esta lista hasta terminar la operación de suma. Como dicho
así resulta bastante ininteligible, fíjate en la siguiente tabla y lo verás enseguida:

En la primera fila están la lista de valores que acepta la variable, y en negrilla el valor que
contiene. Como ves, a continuación del último que acepta vuelve a estar el primero. Al
sumarle 10 (segunda fila) es como si se fueran contando valores posibles hacia adelante,
de modo que i ahora vale 7. Otro ejemplo usando el tipo sbyte (que acepta valores entre
128 y 127):

sbyte i=126;
unchecked {i+=10;}
Console.WriteLine(i);

De modo que i valdría -120 después de la suma.

Los operadores unitarios + y - sirven sencillamente para mantener o cambiar el signo de


un operando. Si se desea mantener el signo de un operando sin cambios, el + se puede
omitir. Por ejemplo:

int i=10;
int b=-i;
Console.WriteLine("Valor de i: {0} Valor de b: {1}", i, b);

La variable i valdría 10, y la variable b valdría -10. Por lo tanto, la salida en la consola
sería:

Valor de i: 10 Valor de b: -10

El operador unitario ! es un not lógico, es decir, invierte el valor de un dato de tipo


boolean. En el siguiente ejemplo, i valdría true y b valdría false:
bool i=true;
bool b=!i;

El operador unitario ~ es de complemento a nivel de bits, o sea, que devuelve el valor


complementario al operando al que afecta. Para entender esto usaremos una variable de
tipo int y escribiremos tanto su valor como el de su complementario en hexadecimal:

uint i=10;
Console.WriteLine("Valor de i: {0:X8} Valor de ~i: {1:X8}", i, ~i);
La salida en la consola sería la siguiente:
Valor de i: 0000000A Valor de ~i: FFFFFFF5

Como sabes, el número hexadecimal A equivale al 10 en base decimal, por eso escribe A
como valor de i. El número FFFFFFF5 es el complementario en hexadecimal de 10, y en
base decimal equivale a 4294967285. Veamos estos números en código binario (que es
como se almacenan en la memoria):

A: 0000 0000 0000 0000 0000 0000 0000 1010


FFFFFFF5: 1111 1111 1111 1111 1111 1111 1111 0101

Así lo ves perfectamente: el operador ~ ha cambiado todos los bits, pondiendo un 1


donde había un 0 y un 0 donde había un uno. ¿Y por qué ha rellenado tantos números? .

“La Práctica hace al Maestro” Página 17


Muy simple: ¿Cuánto espacio se reserva en memoria para una variable de tipo int? 4
bytes, ¿no?. Pues bien, independientemente del valor de la variable, esta siempre ocupa
4 bytes ( 32 bits), de modo que si, por ejemplo, le asignamos 10 (que en binario es 1010)
tendrá que colocar 28 ceros delante para ocupar los 28 bits que le faltan. El operador ~
solamente es aplicable a variables de tipo int, uint, long y ulong.

En el operador (conversion), lo que ha de ir entre paréntesis es el tipo al que se quiere


convertir (int), (uint), (long)... Ya lo explicamos con anterioridad cuando hablamos del
sistema de tipos.

Los operadores * y / son, respectivamente, para multiplicar y dividir. Es muy sencillo. Si,
por ejemplo, tenemos la siguiente expresión: 4*6/2, el resultado sería el que se supone:
12.

El operador % devuelve el resto de una división. Por ejemplo, 8 % 3 devolvería 2.

Los operadores + y – (binarios) son para sumar o restar. 4+7-3 devolvería 8.

“La Práctica hace al Maestro” Página 18


“La Práctica hace al Maestro” Página 19
3.1. Uso componentes Label

Aplicación N° 01

Esta aplicación es fácil de hacer, pero la cosa es divertirse y aprender okis, el formulario
que vas a crear deberá tener el siguiente diseño. El Proyecto se Llamara Aplicacion01 y
el Formulario se llamará frmaplicacion01.

Como tú mismo ves va a tener los siguientes controles:

Si te habrás dado cuenta a la hora de utilizar la propiedad de TextAlign del control Label,
este te muestra una imagen en donde hay nuevo opciones de alinear el texto a
comparación de la versión anterior que solo te mostraba tres opciones.

“La Práctica hace al Maestro” Página 20


Luego de la pequeña explicación sigamos con la aplicación, para poder ejecutar la
aplicación puedes presionar la tecla F5 o ir a la barra de menú y después a Depurar ->
Iniciar Depuración, y por fin veraz tu primera aplicación hecha en Visual C#.

3.2. Uso componentes Label,Textbox

Aplicación N° 02
Bueno seguiremos con las aplicaciones, todavía no vamos a tocar lo que es código,
primero tendremos que aprender lo que nos trae de nuevo esta nueva versión del visual
C# para el diseño de nuestros formularios. Siguiendo con los diseños, esta aplicación
diseñaremos un nuevo formulario, como les digo solo diseñaremos okis.

Para esta aplicación crearemos un nuevo proyecto llamado Aplicacion02 y el formulario


llamado frmaplicacion02, que tendrá el siguiente diseño.

“La Práctica hace al Maestro” Página 21


Aplicación Propuesta 1
Esta aplicación lo harán sin mi ayuda (Que fácil no?), no se preocupen es solo puro
diseño aquí les dejo la interfaz okis.

“La Práctica hace al Maestro” Página 22


Aplicación N° 03
Esta aplicación todavía es solo diseño, así que crearemos un nuevo proyecto llamado
Aplicacion03 y un formulario llamado frmaplicacion03, que tendrá la siguiente interfaz.

Características:

1.- En el ciclo debe ingresar hasta 03 caracteres.


2.- En el sexo sólo un carácter.
3.- En la clave hasta 05 caracteres y no se debe visualizar a medida que ingresa.
4.- No se debe permitir el ingreso de la dirección electrónica.

“La Práctica hace al Maestro” Página 23


3.3. Uso componentes Label,Textbox, Button

Aplicación N° 04
Bueno dirán ustedes, Cuando vamos a comenzar a codificar?, bueno la respuesta es que
en esta aplicación por fin podremos codificar, aunque sea un poco, pero algo es algo
dicen, para esto crearemos un nuevo proyecto llamado Aplicacion04 y un formulario
llamado frmaplicacion04, que tendrá el siguiente diseño, si se han dado cuenta el diseño
se parece al de la aplicación 02, así que pueden hacerlo en la misma ventana de la
aplicación 02, si les da flojera diseñar esta interfaz okis.

Bueno ya no les voy a decir las propiedades de cada control, solo les voy a indicar con
que nombre voy a trabajar por cada control y que a la propiedad CancelButton del
formulario le asignen el botón finalizar, para que a la hora de presionar la tecla Esc,
este ejecute el código de este botón okis.

“La Práctica hace al Maestro” Página 24


Ahora codificaremos el botón nuevo, para entrar a la ventana de diseño de código le
daremos doble clic en el botón nuevo y aparecerá el siguiente código

private void btnnuevo_Click(object sender, EventArgs e)


{

Y a continuación codificaremos lo siguiente:

txtnombre.Text = "";
txtdireccion.Text = "";
txttelefono.Text = "";
txtce.Text = "";
txtobservaciones.Text = "";
txtnombre.Focus();

y quedara algo asi:

“La Práctica hace al Maestro” Página 25


Y en el botón finalizar, codificaremos lo siguiente:

This.Close();

Y visualizaras

Bueno ahora viene lo más interesante, que es la explicación, comencemos, por el código
de Focus(), que es la de devolver el foco al control indicado.

Ahora el código de This.Close(), este código permite cerrar la aplicación y de liberar la


memoria, para que el espacio que ocupe esta aplicación en la memoria, pueda ser
utilizada por otra aplicación.

Aplicación Propuesta 2
Bueno ahora que seguro que ya tienen ganas de programar, al saber que casi no ha
cambiado el código a comparación de la versión anterior les dejare un aplicación para
que ustedes de luzcan poniendo todo su conocimiento en ello, solo les dejo la interfaz y
lo que pide esta aplicación.

Características

1. Al dar clic en el botón nombre, me deberá Mostar en el control TextBox el nombre


del autor, o sea sus nombres y apellidos de usted.
2. Al dar clic en el botón Centro de Estudios, me deberá Mostar el nombre de centro
de estudios de usted.
3. Al dar clic en el botón Fecha de Nacimiento, me deberá Mostar la fecha de
nacimiento de usted.
4. Al dar clic en el botón Salir, este terminara la aplicación.
5. Al dar clic en cada botón, este dará el foco al siguiente botón.
6. Y por último al presionar la tecla ( Esc ), este cerrara la aplicación.

Eso es todo, no les pido nada más, así que suerte!

“La Práctica hace al Maestro” Página 26


Aplicación N° 05
Esta aplicación se parece bastante a la aplicación anterior, así que para
desarrollar esta aplicación crearemos un nuevo proyecto llamado Aplicacion05
y un formulario llamado frmaplicacion05, que tendrá la siguiente interfaz.

Las características de los controles del formulario son las siguientes:

El código que va a tener el btnnuevo es el siguiente:

txtnombre.Text = ""
txtfecnac.Text = ""
txtdni.Text = ""
txtdomact.Text = ""
txtnombre.Focus()

Y el del btnsalir es el siguiente:

Me.Close()

Con esta aplicación concluimos este Tercer capítulo, así que ahora tocaremos un poco
más de programación codificada en el siguiente capítulo.

“La Práctica hace al Maestro” Página 27


“La Práctica hace al Maestro” Página 28
4.1 Utilización de Constantes, Variables enteras y doubles

Aplicación N° 06

Esta aplicación muestra la diferencia entre una variable declarada con int y double
dentro de un procedimiento.

 Paso N° 01: Dibujar los controles.


 Paso N° 02: Asignar los nombres a los controles. Como ustedes se habrán dado
cuenta, yo acostumbro a ponerle un nombre especifico a cada control que voy a
utilizar, y en esta aplicación no puede ser la excepción, los siguientes nombres
que van a tener los controles son:

Control Name
Label3 lbla
Label4 lblb
Button1 btnincrementa

 · Paso N° 03: Escribir las instrucciones

public partial class frmaplicacion06 : Form


{
/*este espacio esta reservado para la declaracion
* de variables a utilizar en el proceso
* estas variables solo se pueden utilizar
* en este formulario de este proyecto
*/
private int a=0;
private double b=0;

public frmaplicacion06()
{
InitializeComponent();
}

private void btnincrementa_Click(object sender, EventArgs e)

“La Práctica hace al Maestro” Página 29


{
a = a + 1;
b = b + 0.25;
//asignacion de valores a el objeto Label
lbla.Text = Convert.ToString(a); //se puede hacer de esta forma
lblb.Text = b.ToString();//o tambien asi
}
}

Como usted observara que al dar clic en el botón “Incrementa a la Variable A y B”, la
variable “a” se incrementa en la unidad, a comparación de la variable “b”, que se
incrementa en 0.25, también hemos vistos las diferentes formas de asignar el valor de la
variable al control Lbla, y Lblb

Aplicación N° 07

Les diré ahora lo que nos pide esta aplicación, nos pide que al ingresar un nombre de un
trabajador, las horas normales que ha trabajado, las horas extras, el pago por cada hora
normal y extra. Al dar clic en el botón de calcular nos deberá mostrar lo siguiente: total del
pago por las horas normales y extras, el subtotal, su descuento del 10 % y el total a
pagarle (el subtotal menos el descuento).

 Paso N° 01: Diseñar el formulario, preferiría que lo hicieran lo mejor posible.


 Paso N° 02: Asignarles los nombres específicos para cada control.

“La Práctica hace al Maestro” Página 30


 Paso N° 03: Uno de los pasos más difíciles, escribir las instrucciones.

private void btnnuevo_Click(object sender, EventArgs e)


{
txtnom.Text = "";
txthtn.Text = "";
txthe.Text = "";
txtpxhn.Text = "";
txtpxhe.Text = "";
txttxhn.Text = "";
txttxhe.Text = "";
txtsubtotal.Text = "";
txtdescuento.Text = "";
txttp.Clear(); //tambien se puede limpiar un textbox asi
txtnom.Focus();
}

private void btncalcular_Click(object sender, EventArgs e)


{
//declaracion de variables locales
//se podran utilizar solo dentro de este procedimiento
int hnt, het;
double phn, phe, txhn, txhe, st, des, tp;
const double descuento = 10;

hnt = int.Parse(txthtn.Text); //Horas Normales Trabajadas


het = int.Parse(txthe.Text); //Horas Extras Trabajadas
phn = Double.Parse(txtpxhn.Text);// 'Pago por Horas Normales
phe = Double.Parse(txtpxhe.Text); //Pago por Horas Extras
txhn = hnt * phn; // 'Total de Pago por las Horas Normales
txhe = het * phe; //'Total de Pago por las Horas Extras
st = txhn + txhe; //'Sub Total
des = st * descuento / 100; // 'Descuento
tp = st - des ; //'Total a Pagar
txttxhn.Text = txhn.ToString();
txttxhe.Text = txhe.ToString();
txtsubtotal.Text = st.ToString();
txtdescuento.Text = des.ToString();
txttp.Text = tp.ToString();
}

private void btnsalir_Click(object sender, EventArgs e)


{
this.Close();
}

4.2 Utilización de eventos y de la función Keychar()

Para acceder a un evento de un objeto, haga lo siguiente:

1. Seleccione el objeto
2. En la ventana de propiedades de clic en el botón

“La Práctica hace al Maestro” Página 31


3. De doble clic sobre el evento deseado

Aplicación N° 08

Ahora con esta aplicación que se parece mucho a la aplicación N° 02 (en la interfaz) no
les voy a pedir mucho, solo que al presionar ENTER en cada caja de texto (TextBox),
este le pase el foco al siguiente TextBox, y al presionar la tecla ESC o dar clic en el botón
Finalizar, nos salga un mensaje de advertencia, así que comencemos.

Paso N° 01: Diseñar el formulario.



· Paso N° 02: Asignar los nombres a los controles.

Paso N° 03: Escribir las instrucciones, bueno mejor dicho copien, y de ahí les explico
okis.

btnnuevo (Evento click)

private void btnnuevo_Click(object sender, EventArgs e)


{
txtnombre.Text = "";
txtdireccion.Text = "";
txttelefono.Text = "";
txtcentro.Text = "";
txtobservaciones.Text = "";
txtnombre.Focus();

“La Práctica hace al Maestro” Página 32


}

btnsalir (Evento Click) en una sola Línea la comparación okis.

private void btnsalir_Click(object sender, EventArgs e)


{
DialogResult r; // variable para el resultado del messagebox
r=MessageBox.Show("Esta Seguro de salir", "Alerta",
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (r==System.Windows.Forms.DialogResult.Yes)
this.Close();
}

txtnombre (Evento KeyPress)

private void txtnombre_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
txtdireccion.Focus();
}

txtdireccion (Evento KeyPress)

private void txtdireccion_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
txttelefono.Focus();
}

txttelefono (Evento KeyPress)

private void txttelefono_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
txtcentro.Focus();
}

txtce (Evento KeyPress)

private void txtcentro_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
txtobservaciones.Focus();
}

txtobservaciones (Evento KeyPress)

private void txtobservaciones_KeyPress(object sender, KeyPressEventArgs


e)
{
if (e.KeyChar == 13)
btnsalir.Focus();
}

Bueno les diré que no soy tan bueno en las explicaciones así que tratare de serlo más
claro. Comencemos con la explicación, si se dan cuenta que en el procedimiento del
TextBox hay dos argumentos que se pasa, que es el “Sender” y el “e”, bueno les diré

“La Práctica hace al Maestro” Página 33


que en el argumento “e” se encuentran todos los eventos, procedimientos y funciones
que están en ejecución, como lo es el “KeyChar”, que es una función que nos devuelve el
carácter que ha sido digitado, este carácter es de variable string, es por ello que usamos
la función “Asc”, que convierte en código ASCII a cualquier carácter que le enviemos a
esta función, bueno espero que hayan entendido, sino, les diré algo resumido lo que
significa el código okis. “Si la función Asc nos devuelve 13 en código ASCII, del
argumento enviado, que es la tecla que digitemos en ese momento, que lo obtenemos
mediante e.KeyChar, este dará el foco al siguiente TextBox”, así que para no hacerla
larga les voy a dejar una pequeña aplicación, que se parece mucha a esta, así que
resuélvanlo solos, y háganlo lo mejor posible okis.

Aplicación Propuesta 03

4.3 Utilización de Funciones

Aplicación N° 09

El siguiente programa permite ingresar los apellidos y nombres, fecha de ingreso, turno y
promedio de un alumno. Teniendo las siguientes características:

1. El primer nombre y apellido debe convertirse en mayúscula


2. En el turno solo debe aceptar las letras M, T y N.
3. El promedio debe ser un número entre 0 y 21.

“La Práctica hace al Maestro” Página 34


4. Los botones Nuevo y Salir deben permanecer desactivados hasta que se ingresen
todos los datos correctos.

DESARROLLO

 Paso N° 01: Diseñar el formulario


 Paso N° 02: Asignar los nombres a los respectivos controles

 Paso N° 03: Escribir las instrucciones con mucha lógica, y sobre todo que
funcione. Bueno primero comencemos con crear funciones okis.

Función Limpiar
void limpiar()
{
txtapenom.Text = "";
txtfecing.Text = "";
txtturno.Text = "";
txtpromedio.Clear();//*solo para que to te olvides que esto es valido
btnnuevo.Enabled = false;
btnsalir.Enabled = false;
txtapenom.Focus();
}

Función Minúsculas
void minuscula(System.Windows.Forms.KeyPressEventArgs e)
{
if (e.KeyChar < 97 || e.KeyChar > 122)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 32)
e.Handled = true;
}

Función mayúsculas
void mayuscula(System.Windows.Forms.KeyPressEventArgs e)
{
if (e.KeyChar < 65 || e.KeyChar > 90)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 32)
e.Handled = true;
}

Función Número
void numeros(System.Windows.Forms.KeyPressEventArgs e)
{

“La Práctica hace al Maestro” Página 35


if (e.KeyChar < 48 || e.KeyChar > 58)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 46)
e.Handled = true;
}

Función Ingresados
void ingresados()
{
if (txtapenom.Text != "" && txtturno.Text != "" && txtpromedio.Text
!= "" && txtfecing.Text!="")
{
btnnuevo.Enabled = true;
btnsalir.Enabled = true;
}
else
{
btnnuevo.Enabled = false;
btnsalir.Enabled = false;
}
}

Función MAYÚSCULAS
void MAYUSCULA()
{
String CADENA;
CADENA = txtapenom.Text.Trim();
CADENA = CADENA.ToUpper();
txtapenom.Text = CADENA;
}

 Paso N° 04: Después de escribir las instrucciones en las funciones, ahora nos toca
escribir las instrucciones en los eventos de cada control

private void btnnuevo_Click(object sender, EventArgs e)


{
limpiar();
}

private void btnsalir_Click(object sender, EventArgs e)


{
DialogResult r;
r = MessageBox.Show("Esta Seguro de salir", "Alerta",
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

private void txtturno_KeyPress(object sender, KeyPressEventArgs e)


{
mayuscula(e);
if (e.KeyChar == 13)
if (txtturno.Text != "M" && txtturno.Text != "T" && txtturno.Text !=
"N")
{
MessageBox.Show("Debe de Ingresar sólo letras M, T o N", "Alerta",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
txtturno.Text = "";
txtturno.Focus();

“La Práctica hace al Maestro” Página 36


}
else
{
txtpromedio.Focus();
ingresados();
}
}

private void txtpromedio_KeyPress(object sender, KeyPressEventArgs e)


{
numeros(e);
if (e.KeyChar == 13)
if (int.Parse(txtpromedio.Text) <= 0 || int.Parse(txtpromedio.Text)
>= 21)
{
MessageBox.Show("Solo se Aceptan numeros del 0-20", "Alerta",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
txtpromedio.Text = "";
txtpromedio.Focus();
}
else
ingresados();
}

private void txtfecing_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
{
txtturno.Focus();
ingresados();
}
}

private void txtapenom_KeyPress(object sender, KeyPressEventArgs e)


{
if (e.KeyChar == 13)
{
txtfecing.Focus();
MAYUSCULA();
ingresados();
}
}

private void frmaplicacion9_Load(object sender, EventArgs e)


{
limpiar();
txtturno.MaxLength = 1;
txtpromedio.MaxLength = 2;
}

private void btnnuevo_Click_1(object sender, EventArgs e)


{
limpiar();
}

private void btnsalir_Click_1(object sender, EventArgs e)


{
this.Close();
}

“La Práctica hace al Maestro” Página 37


Aplicación N° 10
Esta aplicación es algo parecido a las aplicaciones que vamos a hacer en el transcurso
del todo el manual, ósea aplicaciones para empresas comerciales, ya que este rubro son
los que nos da mas trabajo a los programadores.

Las características que les pido en este formulario es lo siguiente:

1. Al iniciar el formulario estén desactivados los botones de Depósito y Retiro y la


caja de texto de monto.
2. Al dar clic en el botón ok, este se ocultara y desactivara la caja de texto cliente, y
al mismo tiempo nos salga una ventana solicitándonos que ingresemos un monto
específico, para la apertura de la cuenta.
3. Que por cada depósito o retiro que este haga, deberá de estar contabilizado por el
sistema.
4. Y por último que si al retirar una cantidad mayor a la de su saldo, me deberá de
mostrar un error y no me permitirá retirar dicho monto

Ahora comencemos a desarrollar la aplicación.


 Paso N° 01: Diseñar el formulario, como se muestra, si quieren cámbienles de
color, porque ustedes son libres de decidir, pero cuidado con poner color rosado
en el formulario (si eres hombre).
 Paso N° 02: Asignar los nombres respectivos a los controles.

Control Name
TextBox1 txtcliente
TextBox2 txtmonto
TextBox3 txtcdeposito
TextBox4 txtcretiro
TextBox5 txttdeposito
TextBox6 txttretiro
TextBox6 txtsaldo
Button1 Btnok
Button2 btndeposito
Button3 btnretiro
Button4 btnnuevo
Button5 btnsalir
Button6 btnotra

“La Práctica hace al Maestro” Página 38


 Paso N° 03: Ahora lo más fácil, la codificación, es fácil porque es una aplicación
pequeña, no como la otra que había un montón para codificar, así que
comencemos, primero vamos a declarar variables a nivel del formulario, ósea
después de donde dice

public partial class FRMAPLICACION10 : Form


{
int td, cd, tr, cr, saldo;

Función Números
/**************************************************************/
//funcion de Verification de Ingreso de valores numericos
/**************************************************************/
void numeros(System.Windows.Forms.KeyPressEventArgs e)
{
if (e.KeyChar < 48 || e.KeyChar > 58)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 46)
e.Handled = true;
}

Función Letras

/**************************************************************/
//funcion que permite Ingresar solo letras
/**************************************************************/
void Letras(System.Windows.Forms.KeyPressEventArgs e)
{
if (e.KeyChar < 65 || e.KeyChar > 90)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 32)
if(!char.IsLetter(e.KeyChar))
e.Handled = true;
}

Función Iniciar
void Iniciar()
{
td = 0;
cd = 0;
tr = 0;
cr = 0;
txtcliente.Text = "";
txtmonto.Text = "";
txtcdeposito.Text = "";
txtcretiro.Text = "";
txttdeposito.Text = "";
txttretiro.Text = "";
txtsaldo.Text = "";
btnok.Visible = true;
btndeposito.Enabled = false;
btnretiro.Enabled = false;
txtcliente.ReadOnly = false;
txtmonto.ReadOnly = true;
txtcliente.Focus();
}

Evento Load del Formulario

“La Práctica hace al Maestro” Página 39


private void FRMAPLICACION10_Load(object sender, EventArgs e)
{
Iniciar();
}

btnok (Evento Click)


private void btnok_Click(object sender, EventArgs e)
{
if (txtcliente.Text.Length == 0)
{
MessageBox.Show("Debe de ingresar un nombre", "Banco - El Amigo",
MessageBoxButtons.OK, MessageBoxIcon.Information);
txtcliente.Focus();
return;
}
else
{
txtcliente.ReadOnly = true;
txtmonto.ReadOnly = false;
btnok.Visible = false;
btndeposito.Enabled = true;
btnretiro.Enabled = true;
saldo = 550;
MessageBox.Show("La Cuenta se aperturo con:" + saldo,"Banco - El
Amigo",MessageBoxButtons.OK, MessageBoxIcon.Information);
txtsaldo.Text = saldo.ToString();
td = saldo;
cd = 1;
txtcdeposito.Text = cd.ToString();
txttdeposito.Text = td.ToString();
txtmonto.Focus();
}
}

btndeposito (Evento Click)


private void btndeposito_Click(object sender, EventArgs e)
{
if (txtmonto.Text.Length == 0 || txtmonto.Text.Length == 0)
{
MessageBox.Show("Debe de ingresar un Monto", "Banco - El Amigo",
MessageBoxButtons.OK, MessageBoxIcon.Information);
txtmonto.Focus();
return;
}
else
{
int deposito;
deposito = int.Parse(txtmonto.Text);
td = td + deposito;
cd = cd + 1;
//'Estas tres líneas de código no es necesario, por que solo le
asignaríamos
//'a lblsaldo el valor de la variable td
//'lblsaldo.Text=(td.ToString)
saldo = int.Parse(txtsaldo.Text);
saldo = saldo + deposito;
txtsaldo.Text = saldo.ToString();
txtcdeposito.Text = cd.ToString();

“La Práctica hace al Maestro” Página 40


txttdeposito.Text = td.ToString();
}
}

btnretiro (Evento Click)

private void btnretiro_Click(object sender, EventArgs e)


{
if (txtmonto.Text == "" || txtmonto.Text == "0" )
{
MessageBox.Show("Debe de ingresar solo numeros mayores a 0", "Banco
- El Amigo", MessageBoxButtons.OK, MessageBoxIcon.Information);
txtmonto.Focus();
return;
}
int retiro;
retiro = int.Parse(txtmonto.Text);
saldo = int.Parse(txtsaldo.Text);
if (saldo < retiro)
{
MessageBox.Show("La cantidad que desea retirar excede a su saldo
actual","Lo sentimos", MessageBoxButtons.OK, MessageBoxIcon.Information);
txtmonto.Text = "";
txtmonto.Focus();
}
else
{
tr = tr + retiro;
cr = cr + 1;
txtcretiro.Text = cr.ToString();
txttretiro.Text = tr.ToString();
txtsaldo.Text = (saldo - retiro).ToString();
}
}

btnnuevo (Evento Click)


private void btnnuevo_Click(object sender, EventArgs e)
{
Iniciar();
}

btnotra (Evento Click)


private void btnotra_Click(object sender, EventArgs e)
{
txtmonto.Text = "";
txtmonto.Focus();
}

txtcliente (Evento KeyPress)


private void txtcliente_KeyPress(object sender, KeyPressEventArgs e)
{
Letras(e);
if (e.KeyChar == 13)
btnok.Focus();

“La Práctica hace al Maestro” Página 41


txtmonto (Evento KeyPress)
private void txtmonto_KeyPress(object sender, KeyPressEventArgs e)
{
numeros(e);
if (e.KeyChar == 13)
btndeposito.Focus();
}

btnsalir (Evento click)


private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Dsea Salir de la Aplicacion", "Banco - El Amigo",
MessageBoxButtons.OK, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

Creo que no les había explicado sobre el código del MessageBox.show, bueno
ahora les diré en el formato que debes de escribir para mostrar un mensaje.

MessageBox.show([Aquí va el mensaje que quieres mostrar, entre


comillas],[escribes el tiitulo de la ventana,entre comillas], [escoges los tipos de
Botones a mostrar, ya sea ok, yesno,cancel, etc.], [Aquí va el tipo de icono a
mostrar])

Si muestras un mensaje de decisión, aquí también puedes comparar la respuesta


que el usuario de, como lo hago yo, en el mensaje salir, este resultado se
almacena en una variable de tipo DialogResult

Aplicaciones Propuestas N° 04
Este formulario les pide ingresar el nombre del producto, precio anterior y precio actual,
luego deberá de calcular el alza en soles y el alza en porcentaje. El alza en porcentaje es
igual al alza en soles por 100 / precio anterior, ejemplo:

Precio Anterior = 50
Precio Actual = 80
Alza en Porcentaje = ((80-50) * 100)/50

“La Práctica hace al Maestro” Página 42


Aplicaciones Propuestas N° 05
Esta aplicación nos pide ingresar el nombre del profesor, número de horas normales que
ha trabajado y el número de horas extras, luego se debe de calcular el total que se le
debe pagar por el número de horas normales, el total por horas extras y el total a pagar.

 Si ha trabajado más de 48 horas su pago por horas es de S/. 8.00 y S/. 7.00 en
caso contrario.
 Por hora extra S/. 9.50.

Aplicación N° 11

Se debe de ingresar el nombre de un producto, su precio unitario y la cantidad comprada


de dicho producto, luego se debe calcular y visualizar el subtotal, el descuento en
porcentaje, el descuento en dólares y el total a pagar. El descuento en porcentaje se
depende del subtotal, de acuerdo a la siguiente tabla:

“La Práctica hace al Maestro” Página 43


SUBTOTAL DESCUENTO %
100 ó 101 2%
De 101.1 a 200 4%
De 200.1 a 500 6%
A partir de 500 10 %

Paso N° 01: Diseñar el formulario como se muestra en la figura.


Paso N° 02: Asignar los nombres a cada control.

Control Name…..
TextBox1 txtproducto
TextBox2 txtprecuni
TextBox3 txtcantcomp
TextBox4 txtsubtotal
TextBox5 txtdescP
TextBox6 txtdescS
TextBox7 txttotal
Button1 btncalcular
Button2 btnnuevo
Button3 btnsalir

Paso N° 03: Ahora nos toca hacer la codificación, si te ha estado saliendo todo bien hasta
ahora y haz entendido, no te será difícil. Así que comencemos:

Función Iniciar
void iniciar(Boolean activar)
{
txtproducto.Text = "";
txtproducto.ReadOnly = !activar;
txtprecuni.Text = "";
txtprecuni.ReadOnly = !activar;
txtcantcomp.Text = "";
txtcantcomp.ReadOnly = !activar;
txtsubtotal.Text = "";
txtdescP.Text = "";
txtdescS.Text = "";
txttotal.Text = "";
btncalcular.Enabled = activar;
btnnuevo.Enabled = !activar;
txtproducto.Focus();
}

btnnuevo (evento Click)

private void btnnuevo_Click(object sender, EventArgs e)


{
iniciar(true);
}

frmaplicacion11 (Evento Load)


private void frmaplicacion11_Load(object sender, EventArgs e)
{
iniciar(false);
}

“La Práctica hace al Maestro” Página 44


btnsalir (Evento Click)
private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Dsea Salir de la Aplicacion", "Banco - El Amigo",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btncalcular (Evento Click)


private void btncalcular_Click(object sender, EventArgs e)
{
double desc=0,descP,descS,subt,total; //variables solo para este
procedimiento
double precio,cantidad; //variables solo para este procedimiento
precio = Double.Parse(txtprecuni.Text);
cantidad = Double.Parse(txtcantcomp.Text);
subt = precio * cantidad;
if (subt>=100 & subt <=101)
desc=0.02;
if(subt>=101.1 & subt<=200)
desc=0.04;
if(subt>=201.1 & subt<=500)
desc=0.06;
if(subt>500)
desc=0.10;
if(subt<0)
MessageBox.Show("Error: No se permiten cantidades y precios
negativos","Venta de Productos");
descS = subt * desc;
total=subt-descS;
descP = desc * 100;
txtsubtotal.Text = string.Format("{0:n}", subt);//aparece la coma decimal
txtdescP.Text = descP.ToString() + " %";
txtdescS.Text = string.Format("{0:#.##}",descS);//el numero de decimales
txttotal.Text = string.Format("{0:#.##}", total);
btncalcular.Enabled = false;
btnnuevo.Enabled = true;
}

Hemos utilizado en este ejemplo una función (Iniciar) con parámetros. La variable
activar es de tipo (boolean) y es la que recibe el (true o false).
También en el procedimiento calcular hemos utilizado string.Format, que permite
aplicar formato a los números. A continuación te explicamos los diferentes tipos de
formatos.

“La Práctica hace al Maestro” Página 45


Formatos para datos numéricos

Tipo de
Especificador Ejemplo
Datos
Console.WriteLine(String.Format("{0:c}", 2.5));
c Currency

Decimal
d (Numero Console.WriteLine(String.Format("{0:d}", 200));
Entero)
Console.WriteLine(String.Format("{0:e}",
e Scientific
254325.22));

g General Console.WriteLine(String.Format("{0:g}",20.50));

Number
(Número
n con comas Console.WriteLine(String.Format("{0:n}",2548241.50))
para los
miles)
x Hexadecimal Console.WriteLine(String.Format("{0:x}",2548241);

Otro muy solicitado es el formato para indicar el número de dígitos decimales con el cual
será impreso un número:

Console.WriteLine(String.Format("{0:0.000}", 254.623645));
Console.WriteLine("Indicando número de decimales: {0:#.####}",
254.623645);

También podemos imprimir el número como porcentaje:

Console.WriteLine(String.Format("{0:0.0%}", 0.3));

Formato para Cadenas

Con las cadenas de caracteres podemos:

Aplicar espaciado hacia la derecha

Console.WriteLine(String.Format("{0,30}", "Identado a la derecha"));

Aplicar espaciado hacia la izquierda

Console.WriteLine(String.Format("{0,-5}", "Identado a la izquierda"));

Formato para Fechas

Cuando hablamos de Fechas, podemos imprimir sólo el día, el mes, el año o cualquier otro
tipo de información sobre esta que nos interese.

Te dejo los formatos y un ejemplo para cada opción:

“La Práctica hace al Maestro” Página 46


Especificador Tipo Ejemplo
Console.WriteLine(String.Format("{0:dd}",
dd Día
DateTime.Now ));
Nombre del Día Console.WriteLine(String.Format("{0:ddd}",
ddd
acortado DateTime.Now ));
Nombre del Día Console.WriteLine(String.Format("{0:dddd}",
dddd
– largo DateTime.Now ));
Console.WriteLine(String.Format("{0:gg}",
gg Era
DateTime.Now ));
Console.WriteLine(String.Format("{0:hh}",
hh Hora
DateTime.Now ));
Hora en formato Console.WriteLine(String.Format("{0:HH}",
HH
de 24h. DateTime.Now ));
Console.WriteLine(String.Format("{0:mm}",
mm Minutos
DateTime.Now ));
Console.WriteLine(String.Format("{0:MM}",
MM Meses
DateTime.Now ));
Abreviación del Console.WriteLine(String.Format("{0:MMM}",
MMM
Mes DateTime.Now ));
Nombre
Console.WriteLine(String.Format("{0:MMMM}",
MMMM Completo del
DateTime.Now ));
Mes
Console.WriteLine(String.Format("{0:ss}",
ss Segundos
DateTime.Now ));
Console.WriteLine(String.Format("{0:tt}",
tt AM o PM
DateTime.Now ));
Año en dos Console.WriteLine(String.Format("{0:yy}",
yy
dígitos DateTime.Now ));
Año en formato Console.WriteLine(String.Format("{0:yyyy}",
yyyy
largo DateTime.Now ));
Console.WriteLine(String.Format("{0:d}",
d Short Date
DateTime.Now ));
Console.WriteLine(String.Format("{0:D}",
D Long Date
DateTime.Now ));
Hora y Fecha en Console.WriteLine(String.Format("{0:f}",
f
formato corto DateTime.Now ));
Hora y Fecha en Console.WriteLine(String.Format("{0:F}",
F
formato largo DateTime.Now ));
Console.WriteLine(String.Format("{0:u}",
u Hora Universal
DateTime.Now ));

Por último una aclaración con respecto a los ejemplos. En las líneas de código he
colocado siempre Console.Writeln, esto no quiere decir que String.Format, sólo trabaja
con una aplicación del tipo consola. String.Format, retorna una cadena, la cual puedes
asignarla a una variable, imprimirla, a un componente, etc, ya depende de ti el uso que le
des al resultado obtenido.

“La Práctica hace al Maestro” Página 47


Aplicación N° 12
En esta aplicación nos pide ingresar el nombre del alumno, su nota N° 1 y su nota N° 2,
al hacer clic en el botón Obtener Promedio se debe visualizar: el promedio del alumno,
una observación que indica si el alumno está aprobado o desaprobado, la nota cambiara
de color, si esta aprobado se mostrara de color azul y en caso contrario de rojo, la
cantidad de puntos que le faltan para aprobar, si esta desaprobado o los puntos para
llegar a veinte en caso que está aprobado.

También se debe visualizar la Nota Cualitativa del alumno de acuerdo al promedio.


Se debe de controlar que sólo se ingresan notas entre 0 y 20.

Entre 0y5 Pésimo


Entre 5.1 y 10.4 Malo
Entre 10.5 y 14.4 Regular
Entre 14.5 y 17.4 Bueno
Entre 17.5 y 20 Excelente

 Paso N° 01: Diseñar el Formulario.


 Paso N° 02: Asignar los nombres a los controls.

TextBox1 txtalumno
TextBox2 txtcurso
TextBox3 txtn1
TextBox4 txtn2
TextBox5 txtpromedio
TextBox6 txtobservacion
TextBox7 txtpuntos
Label12 lblcualidad
Button1 btnotro
Button2 btnpromedio
Button3 btnfinalizar

Paso N° 03: El paso más fácil de este formulario, la codificación, así que hagan todo su
esfuerzo de copiar bien como en el cole………..

“La Práctica hace al Maestro” Página 48


Función Limpiar
void limpiar(Boolean condicion)
{
txtalumno.Text = "" ;
txtcurso.Text = "" ;
txtn1.Text = "";
txtn2.Text = "";
txtpromedio.Text = "";
txtobservacion.Text = "";
txtpuntos.Text = "";
lblcualidad.Text = "";
btnotro.Enabled = condicion;
btnpromedio.Enabled = !condicion;
txtalumno.Focus();
}
Función números
/**************************************************************/
//funcion de Verification de Ingreso de valores numericos
/**************************************************************/
void numeros(System.Windows.Forms.KeyPressEventArgs e)
{
if (e.KeyChar < 48 || e.KeyChar > 58)
if (e.KeyChar != 13 && e.KeyChar != 8 && e.KeyChar != 46)
e.Handled = true;
}
btnfinalizar (Evento Click)

private void btnfinalizar_Click(object sender, EventArgs e)


{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Banco - El
Amigo", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}
btnotro (Evento Click)

private void btnotro_Click(object sender, EventArgs e)


{
limpiar(false);
}
frmaplicacion12 (Evento Load)
private void frmaplicacion12_Load(object sender, EventArgs e)
{
limpiar(false);
}
btnpromedio (Evento c lick)
private void btnpromedio_Click(object sender, EventArgs e)
{
double N1,N2,P;
N1=int.Parse(txtn1.Text);
N2=int.Parse(txtn2.Text);
if (txtn1.Text == "" || N1<0 || N1> 20)
{
MessageBox.Show("Tiene que ingresar solo números entre 0 y 20 en
la primera nota","Información Académica");

“La Práctica hace al Maestro” Página 49


txtn1.Text = "";
txtn1.Focus();
return;
}
else
if (txtn2.Text == "" || N2 < 0 || N2 > 20)
{
MessageBox.Show("Tiene que ingresar solo números entre 0 y
20 en la segunda nota","Información Académica");
txtn2.Text = "" ;
txtn2.Focus();
return;
}
P = (N1+N2) / 2;
if(P >= 0 && P <10.5 )
{
txtpuntos.Text = "Le faltan " + (10.5 - P).ToString() + "
para ser aprobado(a)";
txtpromedio.ForeColor = System.Drawing.Color.Red ;
txtpromedio.Text = P.ToString ();
txtobservacion.Text = "Desaprobado(a)";
}
else
if (P > 10.4 && P < 20.1)
{
txtpuntos.Text = "Le faltan " + (20 - P).ToString() + "
para llegar a 20";
txtpromedio.ForeColor = System.Drawing.Color.Blue;
txtpromedio.Text = P.ToString();
txtobservacion.Text = "Aprobado(a)";
}
if(P>=0 && P<=5)
lblcualidad.Text = "Pésimo";
if(P>=5.1 && P<=10.4)
lblcualidad.Text = "Malo" ;
if(P>=10.5 && P<=14.4)
lblcualidad.Text = "Regular" ;
if(P>=14.5 && P<=17.4)
lblcualidad.Text = "Bueno" ;
if(P>=17.5 && P<=20)
lblcualidad.Text = "Excelente";
btnotro.Enabled = true ;
btnpromedio.Enabled = false;
}
Txtn1 (Evento K e y p r e s s )
private void txtn1_KeyPress(object sender, KeyPressEventArgs e)
{
numeros(e);
}
Txtn2 (Evento K e y p r e s s )
private void txtn2_KeyPress(object sender, KeyPressEventArgs e)
{
numeros(e);
}

“La Práctica hace al Maestro” Página 50


Aplicación Propuesta N° 06
En esta aplicación se debe de ingresar el nombre y el año de nacimiento de una
persona y se tiene que visualizar su edad, una observación que indica si es mayor
o menor de edad. Si es menor de edad se debe de mostrar cuantos años le faltan
para ser mayor de edad y si es mayor de edad se debe de mostrar hace cuantos
años es mayor de edad. También se debe de mostrar la etapa de la persona
teniendo en cuenta lo siguiente:

0 y 12 Niño
13 y 17 Adolescente
18 y 30 Joven
31 y 70 Adulto
70 a mas Anciano

Solo les voy a dar una pequeña ayuda, existe dos funciones para saber la fecha
actual, una es la de Now, que te devuelve la fecha actual, con días, meses, años,
horas, minutos, y segundo, y existe otra función que te devuelve el año ingresado, es
Year, esta función te devuelve la fecha de una variable o de un argumento que se le
envié, siempre y cuando sea una fecha, mejor dicho para obtener el año actual del
sistema la codificación seria DateTime.Now.Year, bueno creo que mucha ayuda les
he dado, así que suerte. (ahora te toca consultar un poquito)

“La Práctica hace al Maestro” Página 51


Métodos de la clase String
Siendo String una clase derivada de Array, los mismos atributos y métodos de ésta
(descritos en el capítulo anterior), son totalmente válidos. Tal es el caso de Length
(atributo), por ejemplo.
Específicamente, los métodos principales de la clase String son los siguientes

EndsWith Determina si el final de la instancia de String coincide con un substring dado.

Equals Determina si dos strings dados tienen el mismo valor.

Format Formatea un string conteniendo varios valores y especificadores acerca de


cómo cada valor debe ser formateado.

IndexOf Ubica la primera ocurrencia de un substring dado, en el string.

IndexOfAny Ubica la primera ocurrencia de cualquier carácter de un substring dado, en el


string.
Insert Inserta un substring en una posición específico dentro del string.

LastIndexOf Igual que IndexOf, pero comenzando desde el final del string.

LastIndexOfAny Igual que IndexOfAny, pero comenzando desde el final del string.

Replace Reemplaza todos los caracter4es de un substring indicado, por otro también
indicado.
Split Identifica los substrings en la instancia y los ordena por separado en un
arreglo de strings.

StartsWith Como EndsWith, pero revisando el comienzo del string.

Substring Entrega un substring de la instancia, comenzando en un índice dado.

ToLower Convierte el string as minúsculas.

ToUpper Convierte el string a mayúsculas.

Trim Elimina todos los espacios al comienzo y al final del string.

TrimEnd Elimina todos los espacios al final del string.

TrimStart Elimina todos los espacios al comienzo del string.

Aplicación N° 13
La siguiente aplicación es un ejemplo del uso de las funciones de cadena.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignar los nombres a los controles.

“La Práctica hace al Maestro” Página 52


Control Name

TextBox1 txtfrase
TextBox 2 txtlongitud
TextBox3 txtprimer
TextBox4 txtultimo
TextBox5 txtsegasexto
TextBox6 txtposA
TextBox7 txtminusculas
TextBox8 txtmayusculas
TextBox9 txttitulo
Button1 btnmuestra
Button2 btnnueva
Button3 btnsalir

Paso N° 03: Codificar, como siempre, lo bueno que con este ejemplo veremos o
mejor dicho recordaremos algunas funciones que de repente ya se han olvidado.

Funcion Limpiar ()
void limpiar (Boolean condicion)
{
txtfrase.Text = "";
txtlongitud.Text = "";
txtprimer.Text = "";
txtultimo.Text = "";
txtsegasexto.Text= "";
txtposA.Text = "";
txtminisculas.Text= "";
txtmayusculas.Text= "";
txttitulo.Text = "";
btnmuestra.Enabled = condicion;
btnnueva.Enabled = !condicion;
txtfrase.Focus();
}

btnsalir (Evento Click)


private void btnsalir_Click(object sender, EventArgs e)

“La Práctica hace al Maestro” Página 53


{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte
Pilas", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btnnueva (Evento click)


private void btnnueva_Click(object sender, EventArgs e)
{
limpiar(true);
}

frmaplicacion13 (Evento Load)


private void frmaplicacion13_Load(object sender, EventArgs e)
{
limpiar(false);
}

btnmuestra (Evento Click)


private void btnmuestra_Click(object sender, EventArgs e)
{
string Cadena = "";
Cadena = txtfrase.Text.Trim(); //quita los espacios en blanco al iinicio
y al final
if (Cadena.Length >6 && Cadena.Length <= 40)
{
txtlongitud.Text = Cadena.Length.ToString();
txtprimer.Text = Cadena.Substring(0, 1);//substrae un caracter en la
posicion 0
txtultimo.Text = Cadena.Substring(Cadena.Length - 1, 1);
txtsegasexto.Text = Cadena.Substring(1, 5);
txtposA.Text = (Cadena.IndexOf('a', 0, Cadena.Length) + 1).ToString();
txtminisculas.Text = Cadena.ToLower();
txtmayusculas.Text = Cadena.ToUpper();
txttitulo.Text = Cadena.Substring(0, 1).ToUpper()+
Cadena.Substring(1,Cadena.Length-1).ToLower();
btnmuestra.Enabled = false;
btnnueva.Enabled = true;
}
else
{
MessageBox.Show("ingrese una frase entre 6-40 caracteres");
txtfrase.Text = "";
txtfrase.Focus();
return;
}
}

Si se han dado cuenta he estado usando una función llamada Substring para
substraer caracteres de una cadena, esta función contiene dos parámetros como lo
es la posición inicial del carácter y el total de caracteres a substraer desde
la posición indicada.

“La Práctica hace al Maestro” Página 54


Aplicación N° 14
Esta aplicación nos pide ingresar el nombre y la fecha de nacimiento de una
persona y visualizarse por separado: el día, mes, año, número del día de la
semana, la fecha en letras y la fecha y hora actual.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignarles los nombres respectivos a los controles
Control Name

TextBox1 txtnombre
TextBox2 txtfecnac
TextBox3 txtdiaing
TextBox4 txtmesing
TextBox5 txtañoing
TextBox6 txtdiasem
Label7 lblfecing
Label8 lblfecact
Button1 btnok
Button2 btnsalir

 Paso N° 03: Crear el código, bueno usando más o menos el código de visual

Funcion (IsDate)
//funcion utilizada para verificar si la fecha dada
//esta correctamente ingresada en el textbox
public bool IsDate(string fecnacim)
{
DateTime aux;
return DateTime.TryParse(fecnacim, out aux);
}

frmaplicacion14 (Evento Load)


private void frmaplicacion14_Load(object sender, EventArgs e)

“La Práctica hace al Maestro” Página 55


{
lblfecact.Text = "Hoy es " + DateTime.Now.ToString();
}

btnalir (Evento Click)


private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btnok (Evento click)


private void btnok_Click(object sender, EventArgs e)
{
DateTime fecha;
String nmes="", diasemana="";
int dia, mes, año, ndia;
if (IsDate(txtfecnac.Text)==false)
{
MessageBox.Show("Debe de ingresar un fecha válida, como se muestra
en el ejemplo", "Funciones Tipo Fecha");
txtfecnac.Text = "";
txtfecnac.Focus() ;
return;
}
fecha = DateTime.Parse(txtfecnac.Text);
dia = fecha.Day;
mes = fecha.Month;
año = fecha.Year;
txtdiaing.Text = dia.ToString();
txtmesing.Text = mes.ToString();
txtañoing.Text = año.ToString();
if (fecha.DayOfWeek == DayOfWeek.Monday)
diasemana = "Lunes";
if (fecha.DayOfWeek == DayOfWeek.Tuesday)
diasemana = "Martes";
if (fecha.DayOfWeek == DayOfWeek.Wednesday)
diasemana = "Miercoles";
if (fecha.DayOfWeek == DayOfWeek.Thursday)
diasemana = "Jueves";
if (fecha.DayOfWeek == DayOfWeek.Friday)
diasemana = "Viernes";
if (fecha.DayOfWeek== DayOfWeek.Saturday)
diasemana = "Sabado";
txtdiasem.Text = diasemana;
switch(mes)
{
case 1: nmes = "Enero"; break;
case 2: nmes = "Febrero"; break;
case 3: nmes = "Marzo"; break;
case 4: nmes = "Abril"; break;
case 5: nmes = "Mayo"; break;
case 6: nmes = "Junio"; break;
case 7: nmes = "Julio"; break;
case 8: nmes = "Agosto"; break;
case 9: nmes = "Septiembre"; break;

“La Práctica hace al Maestro” Página 56


case 10: nmes = "Octubre"; break;
case 11: nmes = "Noviembre"; break;
case 12: nmes = "Diciembre"; break;
}
lblfecing.Text = diasemana + ", " + dia.ToString() + " de " + nmes +
" de " + año.ToString();
}

Aplicación N° 15
Esta aplicación es un ejemplo de la utilidad de las funciones tipo numéricas.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignar los nombres a cada control, respectivamente.

Control Name

TextBox1 txtnum
TextBox2 txtpartent
TextBox3 txtpartdec
TextBox4 txtvalabs
TextBox5 txtraizcuad
TextBox6 txtsigno
TextBox7 txtvaloct
TextBox8 txtvalhex
Button1 btnmuestra
Button2 btnnueva
Button3 btnsalir
 Paso N° 03: Crea o copiar el código, bueno si ya se sienten capaces de poder
resolver esta aplicación háganlo, para así saber que están aprendiendo.

Funcion (decAOctal)

//funcion para convertir un numero decimal a


//su equivalente en octal
public string decAoct(string n)
{
int Residuo,num,Cociente,i;

“La Práctica hace al Maestro” Página 57


string Numero="",NumOctal="";
num=int.Parse(n);
Cociente = num;
do
{
Residuo = Cociente % 8;
Cociente =(int)(Cociente / 8);
Numero = Numero + Residuo.ToString();
}
while (Cociente >= 8);
Numero = Numero + Cociente;

//invertir la cadena
for (i = (Numero.Length - 1); i >= 0; i--)
{
NumOctal = NumOctal + Numero.Substring(i, 1);
}
return NumOctal;
}
Funcion (decAhexa)

//funcion para convertir un numero decimal a


//su equivalente en Hexadecimal
public string decAhexa(string n)
{
int Residuo, num, Cociente, i;
string Numero = "", NumHexa = "";
num = int.Parse(n);
Cociente = num;
do
{
Residuo = Cociente % 16;
Cociente = (int)(Cociente / 16);
switch (Residuo)
{
case 10: Numero = Numero + "B"; break;
case 11: Numero = Numero + "B"; break;
case 12: Numero = Numero + "C"; break;
case 13: Numero = Numero + "D"; break;
case 14: Numero = Numero + "E"; break;
case 15: Numero = Numero + "F"; break;
default: Numero = Numero + Residuo.ToString(); break;
}
}
while (Cociente >= 16);
switch (Cociente)
{
case 10: Numero = Numero + "A"; break;
case 11: Numero = Numero + "B"; break;
case 12: Numero = Numero + "C"; break;
case 13: Numero = Numero + "D"; break;
case 14: Numero = Numero + "E"; break;
case 15: Numero = Numero + "F"; break;
default: Numero = Numero + Cociente.ToString(); break;
}

//invertir la cadena
for (i = (Numero.Length - 1); i >= 0; i--)
{
NumHexa = NumHexa + Numero.Substring(i, 1);
}

“La Práctica hace al Maestro” Página 58


return NumHexa;
}

Funcion IsNumero)

//funcion utilizada para verificar si EL NUMERO dado


//esta correctamente ingresada en el textbox
public bool IsNumero(string numero)
{
double aux;
return double.TryParse(numero, out aux);
}

Funcion Limpiar

void limpiar()
{
txtnum.Text = "";
txtpartent.Text = "" ;
txtpartdec.Text = "" ;
txtvalabs.Text = "" ;
txtraizcuad.Text = "";
txtsigno.Text = "" ;
txtvaloct.Text = "";
txtvalhex.Text = "" ;
txtnum.Focus();
}

btnnueva (Evento Click)

private void btnnueva_Click(object sender, EventArgs e)


{
limpiar();
}

frmaplicacion15 (Evento load)

private void frmaplicacion15_Load(object sender, EventArgs e)


{
limpiar();
}

btnsalir (Evento Click)

private void btnsalir_Click(object sender, EventArgs e)


{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btnmuestra (Evento Click)

private void btnmuestra_Click(object sender, EventArgs e)


{
if (IsNumero(txtnum.Text) ==false)
{

“La Práctica hace al Maestro” Página 59


MessageBox.Show("Debe de Ingresar un valor numérico", "Ejemplo de
Funciones Numéricas");
txtnum.Text = "";
txtnum.Focus() ;
return;
}
double num,numdec,raiz;
int nument;
num =Double.Parse(txtnum.Text);
nument = (int)Math.Truncate(num);
numdec =num-nument;
txtpartent.Text =nument.ToString();
txtpartdec.Text = string.Format("{0:0.##}",numdec);//2 decimales
txtvalabs.Text =Convert.ToString(Math.Abs(num));
if (num > 0)
{
raiz = Math.Sqrt(num);
txtraizcuad.Text = string.Format("{0:0.##}", raiz);
}
else
txtraizcuad.Text = "no existe raiz de cantidades negativas";
if (Convert.ToString(Math.Sign(num)) == "-1")
txtsigno.Text = "Negativo";
else
txtsigno.Text = "Positivo";
txtvaloct.Text = decAoct(txtpartent.Text);
txtvalhex.Text = decAhexa(txtpartent.Text);
}

Aplicación N° 16
La siguiente aplicación permite ejecutar desde el Visual C# algunos
programas.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignar los nombres a los respectivos controles.
Control Name

“La Práctica hace al Maestro” Página 60


Button1 Btncalculadora
Button2 btnword
Button3 btnexcel
Button4 btnexplorador
Button5 btndos
Button6 btnfinalizar

 Paso N° 03: Hacer la pequeña codificación.

btncalculadora (Evento Click)


private void btncalculadora_Click(object sender, EventArgs e)
{
Process proc = new Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "calc";
proc.Start();
}

btnword (Evento Click)


private void btnWord_Click(object sender, EventArgs e)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "winword";
proc.Start();
}

btnexcel (Evento Click)


private void btnExcel_Click(object sender, EventArgs e)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "excel";
proc.Start();
}

btnexplorador (Evento Click)


private void btnExplorador_Click(object sender, EventArgs e)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "explorer";
proc.Start();
}

bndos (Evento Click)


private void btnDos_Click(object sender, EventArgs e)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "cmd";

“La Práctica hace al Maestro” Página 61


proc.Start();
}

Btnfinalizar (Evento Salir)


private void btnfinalizar_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

Aplicación N° 17
Esta aplicación nos pide ingresar un texto y luego se debe de mostrar letra por letra
del texto junto con su valor ASCII y su valor Binario; además, el valor binario se
debe de desplazar de izquierda a derecha por el formulario.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignarles los nombres respectivos a los controles del formulario.

Control Name

TextBox1 txttexto
TextBox2 txtletra
TextBox3 txtascii
TextBox4 txtbinario
Label5 lblbinamove
Button1 btnok

 Paso N° 03: Crear el código, bueno solo codificaremos en el función binario y en


el botón Ok.

“La Práctica hace al Maestro” Página 62


Función Binario
public string binario(int num)
{
string ValorBin="";
int resto;
while (num > 1)
{
resto = num % 2 ;
num = num / 2;
ValorBin = resto.ToString().Trim() + ValorBin.ToString();
}
ValorBin = num.ToString().Trim() + ValorBin;
return ValorBin;
}

btnok (Evento Click)


private void btnok_Click(object sender, EventArgs e)
{
String Texto, Letra;
int x, Valor;
int t=0;
Texto = txttexto.Text.Trim();
lblbinamove.Visible = true;
for (x = 0; x < txttexto.Text.Length; x++)
{
txtbinario.Text = "";
lblbinamove.Left =5;
Letra = txttexto.Text.Substring(x, 1);
txtletra.Text = Letra.ToString();
Valor =Convert.ToInt32(Convert.ToChar(Letra));
txtascii.Text = Valor.ToString();
txtbinario.Text = binario(Valor);
lblbinamove.Text = txtbinario.Text;
MessageBox.Show("Press key");
for (t = 1; t < 1000; t = t + 1)
lblbinamove.Left = Convert.ToInt32(t);
}
}

“La Práctica hace al Maestro” Página 63


En programación un array es una zona de almacenamiento que contiene elementos de
un mismo tipo (enteros, boléanos, fechas).

4.6 Cuando utilizar un array

Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los
datos se realice de forma aleatoria e impredecible. Por ejemplo, cuando tenemos un
conjunto de números desordenados, y queremos saber si en el conjunto hay un número
en particular. Por el contrario, si los elementos pueden estar ordenados y se va a utilizar
acceso secuencial sería más adecuado utilizar una lista, mejor diseñada para estas
situaciones.

Declarar un Array

Para declarar un array de una dimensión, solamente debes especificar de qué tipo serán
los elementos de array, de esta forma:

<Tipo> [ ] <nombre> = new <Tipo> [<numero de elementos>]

Por ejemplo, si quiero crear un nuevo array de 8 números enteros:

int [ ] enteros = new int [8]

int es para decir que son enteros lo que voy a almacenar, enteros es el nombre del array
y new es el operador que indica al compilador que cree un nuevo array con una
capacidad de 8 elementos.

Si quieres establecer los 8 números enteros desde un principio, deberás incluir entre
llaves, los elementos separados por coma:

int [ ] a = {6,1,5,6,4,8,6,9,7,4,14,26,14,12,10};

Para declarar un array n-dimensional solo hay que tener en cuenta que a medida que le
agreguemos una coma (,) a los corchetes, se crea una nueva dimensión, por lo que si
hacemos [,] estamos creando un array bidimensional, si agregamos otra coma ([,,]) sería
tridimensional.

Acceder a sus elementos

Para acceder a un elemento en una posición dada del array hay que hacer algo como:
NombreArray [int posición];

“La Práctica hace al Maestro” Página 64


Es importante saber que para referirse al elemento de la posición n del array, hay que
escribirlo como:

NombreArray [n-1];

Esto se debe a que el elemento del array vendría siendo NombreArray [0];
Es un poco incómodo, pero con la práctica te acostumbras.

Ejemplos de arrays

Ahora veremos algunos ejemplos, para que se familiaricen con la sintaxis y vean cómo
usarlos en métodos y aplicaciones sencillas.

Aplicación N° 18
Esta Aplicación nos pide ingresar un número del 1 al 7 y se debe de visualizar
el día de semana al cual pertenece el número ingresado, para esta ocasión lo
vamos hacer usando un array.

 Paso N° 01: Diseñar el Formulario.


 Paso N° 02: Asignar los nombres respectivos a cada control.
Control Name

TextBox1 txtnum
Label2 lbldia
Button1 btnok
Button2 btnsalir

 Paso N° 03: Codificar, para esto primero declararemos variables a nivel del
formulario (ósea mejor dicho, después de donde dice código generado por el
diseñador de Windows Forms), y de ahí codificaremos en los diversos
eventos de cada control.
public partial class frmaplicacion18 : Form
{
public frmaplicacion18()
{
InitializeComponent();
}
string[] D = new string[7];
}

“La Práctica hace al Maestro” Página 65


frmaplicacion18 (Evento Load)
private void frmaplicacion18_Load(object sender, EventArgs e)
{
D[0] = "Lunes";
D[1] = "Martes";
D[2] = "Miercoles";
D[3] = "Jueves" ;
D[4] = "Viernes" ;
D[5] = "Sábado" ;
D[6] = "Domingo";
}

btnok (Evento Click)


private void btnok_Click(object sender, EventArgs e)
{
int N;
if (txtnum.Text == "" || int.Parse(txtnum.Text) < 1 ||
int.Parse(txtnum.Text) > 7)
{
MessageBox.Show("Ingrese un numero del 1-7", "Ponte Pilas");
txtnum.Text = "";
txtnum.Focus();
return;
}
N = int.Parse(txtnum.Text) - 1;
lbldia.Text = "El número ingresado representa el día " + D[N];
}

btnsalir (Evento Click)


private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}
Aplicación N° 19
Esta aplicación permite llenar los valores en un array de 16 elementos, escogidos
aleatoriamente, entre el 1 al 50, luego se pueden ordenar en forma ascendente y
restaurar los valores iniciales.

“La Práctica hace al Maestro” Página 66


 Paso N° 01: Diseñar el formulario.
 Paso N° 02: Asignar los nombres respectivos a cada control.
Control Name

TextBox1 txtarray0
TextBox2 txtarray1
TextBox3 txtarray2
TextBox4 txtarray3
TextBox5 txtarray4
TextBox6 txtarray5
TextBox7 txtarray6
TextBox8 txtarray7
TextBox9 txtarray8
TextBox10 txtarray9
TextBox11 txtarray10
TextBox12 txtarray11
TextBox13 txtarray12
TextBox14 txtarray13
TextBox15 txtarray14
TextBox16 txtarray15
Button1 btnnuevo
Button2 btnordenar
Button3 btnrestaurar
Button4 btnllenar
Button5 btnsalir

 Paso N° 03: Codificar, para estoy vamos a declarar arrays a nivel del
formulario y a crear funciones.

Declaración de Arrays a nivel del formulario

int[] ArrayText=new int[16];


int[] ArrayTemp = new int[16];

Función limpiar

void limpiar(bool condicion)


{
//Function Limpiar(ByVal Condicion As Boolean)
int x;
for(x = 0;x<15;x++)
ArrayText[x] = 0;
txtarray0.Text = "";
txtarray1.Text = "";
txtarray2.Text = "";
txtarray3.Text = "" ;
txtarray4.Text = "" ;
txtarray5.Text = "" ;
txtarray6.Text = "" ;
txtarray7.Text = "" ;
txtarray8.Text = "" ;
txtarray9.Text = "" ;
txtarray10.Text = "";
txtarray11.Text = "" ;
txtarray12.Text = "" ;
txtarray13.Text = "" ;

“La Práctica hace al Maestro” Página 67


txtarray14.Text = "" ;
txtarray15.Text = "" ;
btnordenar.Enabled = condicion ;
txtarray0.Focus();
}

Función Llenar Controles


void LlenarControles()
{
txtarray0.Text = ArrayText[0].ToString();
txtarray1.Text = ArrayText[1].ToString();
txtarray2.Text = ArrayText[2].ToString();
txtarray3.Text = ArrayText[3].ToString();
txtarray4.Text = ArrayText[4].ToString();
txtarray5.Text = ArrayText[5].ToString();
txtarray6.Text = ArrayText[6].ToString();
txtarray7.Text = ArrayText[7].ToString();
txtarray8.Text = ArrayText[8].ToString();
txtarray9.Text = ArrayText[9].ToString();
txtarray10.Text = ArrayText[10].ToString();
txtarray11.Text = ArrayText[11].ToString();
txtarray12.Text = ArrayText[12].ToString();
txtarray13.Text = ArrayText[13].ToString();
txtarray14.Text = ArrayText[14].ToString();
txtarray15.Text = ArrayText[15].ToString();
}

btnordenar (Evento Click)


private void btnordenar_Click(object sender, EventArgs e)
{
int J, Index, Temp;
//almacenamos el ArrayText en ArrayTemp para guardar los datos
//para después restaurarlo
for (J = 0;J<=15;J++)
ArrayTemp[J] = ArrayText[J];

//Método de Ordenación llamada BURBUJA


for(J=0;J<=15;J++)
{
for(Index = 0;Index<=15;Index++)
{
if (Index < 15)
{
if (ArrayText[Index] > ArrayText[Index + 1])
{
Temp = ArrayText[Index];
ArrayText[Index] = ArrayText[Index + 1] ;
ArrayText[Index + 1] = Temp;
}
}
}
}
LlenarControles();
btnrestaurar.Enabled = true;
}

btnrestaurar (Evento Click)


private void btnrestaurar_Click(object sender, EventArgs e)

“La Práctica hace al Maestro” Página 68


{
int Index;
for(Index=0;Index<=15;Index++)
ArrayText[Index] = ArrayTemp[Index];
LlenarControles();
}

btnllenar (Evento Click)


private void btnllenar_Click(object sender, EventArgs e)
{
int Index;
Random rnd = new Random();
for(Index=0;Index<=15;Index++)
ArrayText[Index] = rnd.Next(1,51); //genera numerosdel 1-50
LlenarControles();
btnordenar.Enabled = true;
btnrestaurar.Enabled = false;
}

btnnuevo (Evento Click)


private void btnnuevo_Click(object sender, EventArgs e)
{
limpiar(true);
}

btnsalir (Evento Click)

private void btnsalir_Click(object sender, EventArgs e)


{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

Aplicación N° 20
Esta aplicación permite manejar los elementos de un array de 16 elementos, estos
elementos son valores numéricos de tipo entero con los cuales se realiza los siguientes
procesos: Sumar filas, columnas, diagonales, etc. Bueno en realidad si ustedes
desean lo pueden hacer con un array de 4 x 4, sino hagan como yo con un solo array
de 16 elementos.

 Paso N° 01: Diseñar el formulario.


 Paso N° 02: Asignar los nombres correspondientes a cada control.

“La Práctica hace al Maestro” Página 69


Control Name Control Name
TextBox1 txtarray0 TextBox20 txtresC2
TextBox2 txtarray1 TextBox21 txtresC3
TextBox3 txtarray2 TextBox22 txtresC4
TextBox4 txtarray3 TextBox23 txtresF1
TextBox5 txtarray4 TextBox24 txtresF2
TextBox6 txtarray5 TextBox25 txtresF3
P
TextBox7 txtarray6 TextBox26 txtresF4
a
TextBox8 txtarray7 Button1 btnLimpArray
s
TextBox9 txtarray8 Button2 btnLimpRes
o
TextBox10 txtarray9 Button3 btnSumaC
TextBox11
N txtarray10 Button4 btnSumaF
TextBox12
° txtarray11 Button5 btnColum1
TextBox13 txtarray12 Button6 btnColum2
TextBox14
0 txtarray13 Button7 btnColum3
TextBox15
3 txtarray14 Button8 btnColum4
TextBox16
: txtarray15 Button9 btnFila1
TextBox17 txtresD1 Button10 btnFila2
TextBox18
C txtresD2 Button11 btnFila3
TextBox19 txtresC1 Button12 btnFila4
Button13 btnDiagonal1
Button14 btnDiagonal2
Button15 btnsalir

 Codificar, bueno como siempre, declaramos arrays a nivel del formulario y


crearemos funciones.

Declaración de Arrays a nivel del formulario


int[] ArrayControl=new int[16];
int[,] ArrayTemp=new int[4,4];
int[] ArraySuma=new int[4];
int[] Suma=new int[4];

“La Práctica hace al Maestro” Página 70


int Index, Temp, X, Y;

Función Limpiar Array


void LimpiarArray()
{
for(Index = 0;Index<=15;Index++)
ArrayControl[Index] = 0;
for(X = 0;X<=3;X++)
{
for(Y=0;Y<=3;Y++)
ArrayTemp[X, Y] = 0;
}
txtarray0.Text = "";
txtarray1.Text = "";
txtarray2.Text = "";
txtarray3.Text = "";
txtarray4.Text = "";
txtarray5.Text = "";
txtarray6.Text = "";
txtarray7.Text = "";
txtarray8.Text = "";
txtarray9.Text = "";
txtarray10.Text = "";
txtarray11.Text = "";
txtarray12.Text = "";
txtarray13.Text= "";
txtarray14.Text= "";
txtarray15.Text="";
txtarray0.Focus();
}

Función Asignar Array


void AsignarArray()
{
ArrayControl[0] = int.Parse(txtarray0.Text);
ArrayControl[1] = int.Parse(txtarray1.Text);
ArrayControl[2] = int.Parse(txtarray2.Text);
ArrayControl[3] = int.Parse(txtarray3.Text);
ArrayControl[4] = int.Parse(txtarray4.Text);
ArrayControl[5] = int.Parse(txtarray5.Text);
ArrayControl[6] = int.Parse(txtarray6.Text);
ArrayControl[7] = int.Parse(txtarray7.Text);
ArrayControl[8] = int.Parse(txtarray8.Text);
ArrayControl[9] = int.Parse(txtarray9.Text);
ArrayControl[10] = int.Parse(txtarray10.Text);
ArrayControl[11] = int.Parse(txtarray11.Text);
ArrayControl[12] = int.Parse(txtarray12.Text);
ArrayControl[13] = int.Parse(txtarray13.Text);
ArrayControl[14] = int.Parse(txtarray14.Text);
ArrayControl[15] = int.Parse(txtarray15.Text);
Index = 0;
for(X=0;X<=3;X++)
{
for(Y=0;Y<=3;Y++)
{
ArrayTemp[X, Y] = ArrayControl[Index];
Index = Index + 1;
}
}

“La Práctica hace al Maestro” Página 71


}

Función Limpiar Resultados


void LimpiarResultados()
{
txtresD1.Text = "";
txtresD2.Text = "";
txtresC1.Text = "";
txtresC2.Text = "";
txtresC3.Text = "";
txtresC4.Text = "";
txtresF1.Text = "";
txtresF2.Text = "";
txtresF3.Text = "";
txtresF4.Text = "";
}

Función Limpiar ArraySuma


void LimpiarArraySuma()
{
for(Index=0;Index<=3;Index++)
Suma[Index] = 0;
}

btnsalir (Evento Click)


private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte
Pilas", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btnLimpArray (Evento Click)


private void btnlimparray_Click(object sender, EventArgs e)
{
LimpiarArray();
}

btnLimpRes (Evento Click)


private void btnlimpres_Click(object sender, EventArgs e)
{
LimpiarResultados();
}

btnSumaC (Evento Click)


private void btnsumaC_Click(object sender, EventArgs e)
{
AsignarArray();
for(X=0;X<=3;X++)
{
ArraySuma[X] = 0;

“La Práctica hace al Maestro” Página 72


for (Y = 0; Y <= 3; Y++)
ArraySuma[X] = ArraySuma[X] + ArrayTemp[Y, X];
}
for(Index=0;Index<=3;Index++)
Suma[Index] = ArraySuma[Index];
txtresC1.Text = Suma[0].ToString();
txtresC2.Text = Suma[1].ToString();
txtresC3.Text = Suma[2].ToString();
txtresC4.Text = Suma[3].ToString();
}

btnSumaF (Evento Click)


private void btnsumaF_Click(object sender, EventArgs e)
{
AsignarArray();
for(Y=0;Y<=3;Y++)
{
ArraySuma[Y] = 0;
for(X=0;X<=3;X++)
ArraySuma[Y] = ArraySuma[Y] + ArrayTemp[Y, X];
}
for (Index = 0; Index <= 3; Index++)
Suma[Index] = ArraySuma[Index];
txtresF1.Text = Suma[0].ToString();
txtresF2.Text = Suma[1].ToString();
txtresF3.Text = Suma[2].ToString();
txtresF4.Text = Suma[3].ToString();
}

btnColum1 (Evento Click)


private void btncolumn1_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for(X=0;X<=3;X++)
Temp = Temp + ArrayTemp[X, 0];
txtresC1.Text = Temp.ToString();
}

btnColum2 (Evento Click)


private void btncolumn2_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (X = 0; X <= 3; X++)
Temp = Temp + ArrayTemp[X, 1];
txtresC2.Text = Temp.ToString();
}

btnColum3 (Evento Click)


private void btncolumn3_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (X = 0; X <= 3; X++)
Temp = Temp + ArrayTemp[X, 2];

“La Práctica hace al Maestro” Página 73


txtresC3.Text = Temp.ToString();
}
btnColum4 (Evento Click)

private void btncolumn4_Click(object sender, EventArgs e)


{
AsignarArray();
Temp = 0;
for (X = 0; X <= 3; X++)
Temp = Temp + ArrayTemp[X, 3];
txtresC4.Text = Temp.ToString();
}

btnFila1 (Evento Click)


private void btnfila1_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for(Y=0;Y<=3;Y++)
Temp = Temp + ArrayTemp[0, Y] ;
txtresF1.Text = Temp.ToString();
}

btnFila2 (Evento Click)


private void btnfila2_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (Y = 0; Y <= 3; Y++)
Temp = Temp + ArrayTemp[1, Y];
txtresF2.Text = Temp.ToString();
}

btnFila3 (Evento Click)


private void btnfila3_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (Y = 0; Y <= 3; Y++)
Temp = Temp + ArrayTemp[2, Y];
txtresF3.Text = Temp.ToString();
}

btnFila4 (Evento Click)


private void btnfila4_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (Y = 0; Y <= 3; Y++)
Temp = Temp + ArrayTemp[3, Y];
txtresF4.Text = Temp.ToString();
}

btnDiagonal1 (Evento Click)

“La Práctica hace al Maestro” Página 74


private void btndiagonal1_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for(Index=0;Index<=3;Index++)
Temp = Temp + ArrayTemp[Index, 3 - Index];
txtresD1.Text = Temp.ToString();
}

btnDiagonal2 (Evento Click)


private void btndiagonal2_Click(object sender, EventArgs e)
{
AsignarArray();
Temp = 0;
for (Index = 0; Index <= 3; Index++)
Temp = Temp + ArrayTemp[Index,Index];
txtresD2.Text = Temp.ToString();
}

Aplicación N° 21
La siguiente aplicación permite realizar operaciones con arrays como sumar dos
arrays, restar, multiplicar, etc.

 Paso N° 01: Diseñar el formulario.

 Paso N° 02: Asignar los nombres respectivos a los controles.

“La Práctica hace al Maestro” Página 75


Control Name Control Name

TextBox1 txta0 TextBox18 txtb8


TextBox2 txta1 TextBox19 txtres0
TextBox3 txta2 TextBox20 txtres1
TextBox4 txta3 TextBox21 txtres2
TextBox5 txta4 TextBox22 txtres3
TextBox6 txta5 TextBox23 txtres4
TextBox7 txta6 TextBox24 txtres5
TextBox8 txta7 TextBox25 txtres6
TextBox9 txta8 TextBox26 txtres7
TextBox10 txtb0 TextBox27 txtres8
TextBox11 txtb1 Button1 btnborrar
TextBox12 txtb2 Button2 btnLlenar
TextBox13 txtb3 Button3 btnsalir
TextBox14 txtb4 Button4 btnsuma
TextBox15 txtb5 Button5 btnresta
TextBox16 txtb6 Button6 btnmultiplica
TextBox17 txtb7 Button7 btndivide
Button8 btnecuacion
 Paso N° 03: Codificar, primero declarar los arrays a nivel del formulario y
después seguimos con las funciones okis.
double[] ArrayA=new double[9];
double[] ArrayB=new double[9];
String[] ArrayResp=new string[9];
int Index;

Función Asignar ControlA


void AsignarControlA()
{
txta0.Text = ArrayA[0].ToString();
txta1.Text = ArrayA[1].ToString();
txta2.Text = ArrayA[2].ToString();
txta3.Text = ArrayA[3].ToString();
txta4.Text = ArrayA[4].ToString();
txta5.Text = ArrayA[5].ToString();
txta6.Text = ArrayA[6].ToString();
txta7.Text = ArrayA[7].ToString();
txta8.Text = ArrayA[8].ToString();
}

Función Asignar ControlB


void AsignarControlB()
{
txtb0.Text = ArrayB[0].ToString();
txtb1.Text = ArrayB[1].ToString();
txtb2.Text = ArrayB[2].ToString();
txtb3.Text = ArrayB[3].ToString();
xtb4.Text = ArrayB[4].ToString();
txtb5.Text = ArrayB[5].ToString();
txtb6.Text = ArrayB[6].ToString();
txtb7.Text = ArrayB[7].ToString();
txtb8.Text = ArrayB[8].ToString();

“La Práctica hace al Maestro” Página 76


}
Función Llenar Resultado
void LlenarResultado()
{
txtres0.Text = ArrayResp[0].ToString();
txtres1.Text = ArrayResp[1].ToString();
txtres2.Text = ArrayResp[2].ToString();
txtres3.Text = ArrayResp[3].ToString();
txtres4.Text = ArrayResp[4].ToString();
txtres5.Text = ArrayResp[5].ToString();
txtres6.Text = ArrayResp[6].ToString();
txtres7.Text = ArrayResp[7].ToString();
txtres8.Text = ArrayResp[8].ToString();
}

Función Limpiar Arrays


void LimpiarArrays()
{
for(Index=0;Index<=8;Index++)
{
ArrayA[Index] = 0;
ArrayB[Index] = 0;
ArrayResp[Index] = "0";
}
}

Función Limpiar Controles

void LimpiarControles()
{
txta0.Text = ""; txta1.Text = ""; txta2.Text = "";
txta3.Text = ""; txta4.Text = ""; txta5.Text = "";
txta6.Text = ""; txta7.Text = ""; txta8.Text = "";
txtb0.Text = ""; txtb1.Text = ""; txtb2.Text = "";
txtb3.Text = ""; txtb4.Text = ""; txtb5.Text = "";
txtb6.Text = ""; txtb7.Text = ""; txtb8.Text = "";
txtres0.Text = ""; txtres1.Text = ""; txtres2.Text = "";
txtres3.Text = ""; txtres4.Text = ""; txtres5.Text = "";
txtres6.Text = ""; txtres7.Text = ""; txtres8.Text = "";
}

btnsalir (Evento Click)


private void btnsalir_Click(object sender, EventArgs e)
{
DialogResult r;
r = MessageBox.Show("Desea Salir de la Aplicacion", "Ponte Pilas",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (r == System.Windows.Forms.DialogResult.Yes)
this.Close();
}

btnllenar (Evento click)


private void btnllenar_Click(object sender, EventArgs e)
{
Random rnd=new Random();

“La Práctica hace al Maestro” Página 77


for(Index=0;Index<=8;Index++)
{
ArrayA[Index] = rnd.Next(-10, 10);//genera numeros entre -10 y 10
ArrayB[Index] = rnd.Next(-10,10);
}
AsignarControlA();
AsignarControlB();
}

btnsuma (Evento Click)


private void btnsuma_Click(object sender, EventArgs e)
{
for (Index = 0; Index <= 8; Index++)
ArrayResp[Index] = (ArrayA[Index] + ArrayB[Index]).ToString();
LlenarResultado();
}

btnresta (Evento Click)

private void btnresta_Click(object sender, EventArgs e)


{
for (Index = 0; Index <= 8; Index++)
ArrayResp[Index] = (ArrayA[Index] - ArrayB[Index]).ToString();
LlenarResultado();
}

btnmultiplica (Evento Click)


private void btnmultiplica_Click(object sender, EventArgs e)
{
for (Index = 0; Index <= 8; Index++)
ArrayResp[Index] = (ArrayA[Index] * ArrayB[Index]).ToString();
LlenarResultado();
}

btndivide (Evento Click)


private void btndivide_Click(object sender, EventArgs e)
{
for (Index = 0; Index <= 8; Index++)
{
if (ArrayB[Index] != 0)
ArrayResp[Index] = string.Format("{0:0.##}", (ArrayA[Index] /
ArrayB[Index]));
else
ArrayResp[Index] = "NE";
}
LlenarResultado();
}

btnecuacion (Evento Click)


private void btnecuacion_Click(object sender, EventArgs e)
{
for(Index=0;Index<=8;Index++)
ArrayResp[Index] = ((ArrayA[Index] * 2) + (ArrayB[Index] *
3)).ToString();
LlenarResultado();

“La Práctica hace al Maestro” Página 78


}

frmaplicacion21 (Evento Load)


private void frmaplicacion21_Load(object sender, EventArgs e)
{
LimpiarControles();
}

btnborrar (Evento Click)


private void btnborrar_Click(object sender, EventArgs e)
{
LimpiarControles();
LimpiarArrays();
}

Bueno señores, con esto acabo con la primera entrega, que es lo básico, me
despido esperando que este manual les sirva de mucho para iniciarse en C#.

Te recomiendo que los ejercicios trates de resolverlos nuevamente por tu propia


cuenta sin mirar el código que esta en este libro, solo así puedes iniciar la segunda
parte de este libro ya que esos conocimientos los utilizaremos más adelante.

Ya saben que cualquier pregunta o duda me escriben a mi correo


cesvan1967@hotmail.com que les responderé lo más rápido posible, así que hasta
la próxima, byes.

Machala, 08 de Septiembre del 2010

“La Práctica hace al Maestro” Página 79