Apunte Oficial

SIA200
Algoritmos y Programación
Por Matías Sánchez / Francisco Requena

Contenidos
1. Introducción ........................................................................................... 2
2. Comentarios........................................................................................... 3
3. Tipos de Variable y declaraciones .......................................................... 4
3.1. Expresiones Booleanas ........................................................................... 5
3.2. Strings .................................................................................................... 6
4. Entrada y salida ...................................................................................... 7
4.1. Impresión en pantalla ............................................................................ 7
4.2. Lectura en pantalla y conversión de tipos (parse): ................................. 9
5. Funciones (Métodos) ........................................................................... 10
6. Recursividad ......................................................................................... 12
7. Estructuras de control .......................................................................... 13
7.1. Estructuras condicionales selectivas .................................................... 13
7.2. Estructuras de repetición ..................................................................... 15
8. Arreglos................................................................................................ 17
8.1. Arreglos de una dimensión .................................................................. 17
8.2. Arreglos Multidimensionales: .............................................................. 20
9. Windows Forms ................................................................................... 23
9.1. Atributos de un objeto Forms: ............................................................. 24
9.2. Eventos: ............................................................................................... 25
9.3. Cuadros de diálogo: ............................................................................. 29
1. Introducción

Una de las principales razones por las cuales una persona aprende un lenguaje de
programación es para poder utilizar un computador como una herramienta que nos ayude
con la resolución de problemas (desde operaciones sencillas hasta una vasta gama de
problemas y procedimientos complejos).

Se podría decir que el proceso de crear un programa tiene dos fases: Primero, el
análisis y planteamiento de un problema que nos conduce a la especificación de un
algoritmo que lo resuelve y finalmente, la segunda fase que consiste en realizar la
transformación de dicho algoritmo a un programa.

La primera fase es la más difícil, dado que tendremos que definir tareas, variables,
flujos y cuáles serán las restricciones y validaciones que habremos de considerar. Además,
de entre varias soluciones posibles tendremos que escoger la que nos parezca más
adecuada para luego definir bien que pasos tendremos que seguir.
La segunda fase, en cambio, consiste básicamente en realizar una especie de
“traducción” de nuestro algoritmo previamente especificado al lenguaje de programación,
que en este curso será el C# (C Sharp).

La finalidad de este apunte es facilitar a ustedes la comprensión de este lenguaje

de programación y ayudar a que clarifiquen y complementen los conocimientos
adquiridos en clases, tanto para estudio personal como para la resolución de sus tareas y
trabajos. Está dividido en índices temáticos en los cuales se tratan los temas de manera
explicativa, con el apoyo de ejemplos ilustrativos para facilitar la comprensión.

Espero este apunte les sea de mucha utilidad y les deseo mucho éxito en este
curso.

Francisco Requena

Agradecimientos:

A quienes han contribuido a la elaboración de este documento, mediante el aporte de

documentación relevante y recomendaciones:

-Sebastián Cisterna
-Gustavo Moreno
-Nicolás Charmín
-Iván Abarca
-Jonathan Vásquez
-Matías Sánchez (el autor de esta iniciativa)
2. Comentarios

Los comentarios serán parte importante de nuestro código. No sólo sirven para
externos que ven nuestro código (como sus queridos ayudantes), sino que también los
pueden ayudar a ustedes a llevar un orden en caso de que su código se haga muy largo o
si utilizan muchas variables.
La forma de poner los comentarios en el código es la siguiente:

// Comentario de una linea

/* Comentarios
en bloque */

Los comentarios de linea se escriben poniendo //. Todo lo que este hacia la
derecha de los slash en esa linea se convierte en comentario.
Los comentarios en bloque se comienzan con /* y se cierran con */. Todo lo que se
encuentre entre estos dos signos se considerara comentario.
Al momento de compilar, el computador no tomara los comentarios como código,
y nos van a ayudar para explicar que es lo que estamos haciendo. En Visual C veremos los
comentarios en color verde.
Como sugerencia, utilizen comentarios cuando esten usando muchas variables con
nombres que no representen lo que son (como por ejemplo a, x, y, etc). De esta manera
pueden tener registrado que haran con cada variable.
Tambien es muy util para ustedes (y para corregir) que especifiquen que hace
alguna parte de su código, como por ejemplo:

//Aqui Imprimimos la Matriz por primera vez

3. Tipos de Variable y declaraciones

Antes de usar cualquier variable habremos de declararla. Una declaración de

variable consiste en asignar un tipo y un nombre, con lo cual el compilador será capaz de
almacenar la memoria necesaria para dado un tipo y la variable se identificará en el código
por el nombre que le asignemos. Los tipos de variable que se usaran en este curso son las
siguientes:

- int: Números enteros (e: 0, 1, 2, 3).

- char: Caracteres. (ej.: a, b, A, B, ?, 0)
- double: Números Reales (ej.: 4,5; 5,6; 2)
- string: Cadena de caracteres. Puede almacenar muchos caracteres y los
agrupa (ej.: “Hola Mundo”);
- bool: Variables Booleanas contienen el valor Verdadero o Falso.

Ejemplos de declaración:

int x = 0;
char letra = 'a';
double real = 5.2;
string palabra, frase = "Hola Mundo";
bool condicion = true;

En la declaración podemos además asignar un valor a las variables (como en los

ejemplos de arriba), pero ojo, no se puede asignar valor o usar una variable de ninguna
forma antes de declararla. Siempre tenemos que tener claro con que variables contamos y
cuáles son sus tipos. La recomendación es tener la declaración de variables siempre al
comienzo del programa, de tal forma que si necesitáramos agregar, modificar, o borrar
alguna variable, sepamos con facilidad en que parte del código las podemos encontrar.
Una variable no se puede declarar más de una vez y por lo general si queremos utilizarla
de cualquier manera debemos haberle dado un valor en algún momento (asignación de
valor o lectura).

Observaciones:
- Se puede declarar la variable primero y luego asignarle valor en otra línea de
código. Ejemplo:

int x; //Declaramos la variable “x”

x = 0; //Asignamos valor a la variable

- Se pueden declarar múltiples variables del mismo tipo en una sola linea.
Ejemplo:

int x, y, z;
 3.1. Expresiones Booleanas

Una expresión Booleana será el resultado de la comparación entre 2 variables o

bien, de una variable contra un valor dado. Tras hacer la comparación tomará un valor
Verdadero o Falso, el cual se podrá almacenar en una variable del tipo bool (en la forma
true o false).

Existen distintos operandos para comparar variables. Entre ellos tenemos:

== Igualdad
!= Desigualdad
< Menor estricto
<= Menor o igual
> Mayor estricto
=> Mayor o igual

Los operadores de Igualdad y Desigualdad no solo se aplican a valores numéricos,

tambien sirven para comparar, por ejemplo, si una palabra o letra es igual a otra.
La idea de que estas expresiones devuelvan un verdadero o un falso es realizar
acciones según sea necesario. Nos serán importantes para los distintos ciclos, tanto de
selección como de repetición, los cuales veremos más adelante. Estas expresiones serán
nuestras condiciones de ingreso a los distintos ciclos. Un ejemplo de expresiones
Booleanas:

int x = 1, y = 2;

Entonces:
x == y; //Falso
x != y; //Verdadero
x < y; //Verdadero
x > y; //Falso
x == 1; //Verdadero
x != 1; //Falso

Adicional a estos operadores de comparación, también podremos utilizar

operadores booleanos tales como && y ||, que son equivalentes a los operadores que se
utilizan en lógica para ‘y’ ( ) y ‘o’ ( ) respectivamente. El operador && tomará valor
verdadero sólo cuando ambas condiciones sean verdaderas, mientras el operador ||
tomará valor ‘verdadero’ si al menos una de las condiciones tiene el valor verdadero.
Ejemplo:

bool p = true, q = false;

Entonces:
q && p; //Falso
q || p; //Verdadero
 3.2. Strings
Los string poseen una serie de propiedades que pueden ser de mucha utilidad
para la resolución de ciertos problemas. Tengamos presente que este tipo de variable es
en esencia una cadena de caracteres (char). Pueden ser comparados usando los
operadores ‘==’ y ‘!=’. Además, podemos utilizar el operador ‘+’ para concatenar dos o
más string. Ejemplo:

string a = "Conca", b = “tenar”;

string c = a + b; //c será igual a “Concatenar”

A continuación, se encuentran algunas funciones más avanzadas que nos servirán

para el manejo de los string en este curso para la resolución de problemas, mediante un
ejemplo ilustrativo:

string palabra = "Ejemplo";

palabra.Length: Devuelve un número entero que representa el número de

caracteres en el string, en este caso sería 7.
palabra.Substring(): Como su nombre lo indica, devuelve un string que es una
‘subdivisión’ del original. Se puede usar de dos maneras:
-Escribiendo un número entre los paréntesis obtendremos la
palabra o frase desde el índice indicado (que comienza en 0)
hasta el final. En el ejemplo, palabra.Substring(2) retornará
el string “emplo”.
-En la forma palabra.Substring(x,y)donde el primer
parámetro ‘x’ será el índice de partida y el segundo parámetro
‘y’ será el largo del substring que obtendremos. Para el ejemplo,
palabra.Substring(1,4) retornará “jemp”.
palabra.IndexOf(): Recibe como parámetro un char o un string y nos devolverá
un entero que nos indicará en que posición del string se
encuentra (la primera coincidencia de izquierda a derecha) el
char o el string indicado. Por ejemplo
palabra.IndexOf("p") nos retornará el valor 4, que es el
primer índice en que se encuentra dentro de el string.
Nota: Si la letra o letras que buscamos no están en el string
que tenemos, este método retornará el valor -1.
palabra.ToUpper()/
palabra.ToLower(): Nos sirven para cambiar los string a mayúsculas (ToUpper) o
minúsculas (ToLower). Es importante notar que el lenguaje C#
es ‘case sensitive’, es decir, distingue entre ‘A’ y ‘a’ y las
considera distintas („A‟ == „a‟ será falso).
palabra[i] : Con esto podremos acceder al caracter que se encuentra en el
índice i (recordar que comienza desde 0).
4. Entrada y salida
4.1. Impresión en pantalla

Para imprimir en pantalla tenemos las funciones:

Console.WriteLine("");
Console.Write("");

La única diferencia entre ellas, es que Console.WriteLine(""); dará un salto de

línea después haber impreso en la consola lo que le indicamos; en cambio
Console.Write(""); dejará el cursor justo después de lo que imprimimos.

Lo que deseemos que aparezca en pantalla lo escribiremos dentro del paréntesis

de estas funciones. Todo lo que este entre comillas se escribirá textual en pantalla, por
ejemplo:

Console.WriteLine("Hola Mundo");

Se verá así en pantalla:

Si se fijan, el cursor quedo una línea más abajo de lo que escribimos debido al salto
de línea después de haber impreso. Ahora si hubiésemos hecho Console.Write("Hola
Mundo"); el cursor habría quedado justo después de la ‘o’.

Para poder imprimir variables, tendremos que colocar signos ‘+’ entre las comillas
y el nombre de la variable. De esta manera, si tenemos que:

int x = 1;
Console.WriteLine(x + "Hola Mundo");
Console.WriteLine("Hola " + x + " Mundo");
Console.WriteLine("Hola Mundo " + x);
Obtendríamos lo siguiente en pantalla:

En caso de imprimir un int o double saldrá en pantalla el valor numérico de la

variable, mientras que si imprimen un bool saldrá en pantalla su valor de verdad en la
forma “True” o “False”.

Otros comandos útiles que tenemos para las impresiones en pantalla son \t y \n.
donde \t es una tabulación y \n un salto de línea. Ellos deben ir dentro de las comillas y se
verían así:

Console.WriteLine("Hola \tMundo");
Console.WriteLine("Hola \nMundo");

En pantalla:

Donde se ve que la primera línea tiene la tabulación (es una especie de espacio) y
en la segunda vemos el salto de línea.
 4.2. Lectura en pantalla y conversión de tipos (parse):

Para las lecturas en pantalla en este curso utilizaremos Console.Readline();.

Esta función lo que hará es leer todo lo que el usuario ingrese desde su teclado y retornará
un string (cadena de caracteres). Lo que nos interesa de esta lectura es poder
almacenarla en alguna variable para después poder usarla.
El problema al que nos podemos ver enfrentados es que los tipos de datos no
fueran compatibles (ej: queremos leer un número (int o double) pero la función por si
sola nos devolverá un string). Para hacerlas compatibles transformaremos el string en
el tipo de datos que necesitemos usando TipoDeDato.Parse(string). En donde en
‘TipoDeDato’ colocaremos el tipo de dato que necesitamos, y el string sera la lectura.
Ejemplos de lecturas son las siguientes:

string entrada = Console.Readline();/*Almacenamos la lectura

directamente a una variable*/

int x;
x = int.Parse(Console.Readline()); //Transformamos la lectura a int

char letra;
letra = char.Parse(Console.ReadLine());

int x;
string y;
y = Console.ReadLine();
x = int.Parse(y);

De manera equivalente, se puede utilizar Convert.ToInt32(), por ejemplo, para

convertir una variable a número o bien en lugar de “Int32” (que es un entero de 32 bits)
otro tipo de variable.

Otra función que nos será de utilidad será Console.ReadKey();, la cual consiste en
esperar a que el usuario presione una tecla antes de continuar. Lo utilizaremos
principalmente al final de nuestro código para que el programa no finalize su ejecución
hasta que nosotros se lo indiquemos.
5. Funciones (Métodos)

Cuando le pedimos al compilador que ejecute nuestro código lo que hará es leer
todas las instrucciones dentro del Main para luego crear un ejecutable el cual es el que
vemos (en la consola). Las funciones son declaradas afuera del Main, pero su
funcionalidad está en que puedan ser llamadas por el Main para ser ejecutadas. A
continuación, un program.cs de ejemplo:

namespace ConsoleAplication
{
class Program
{
static void Main(string[] args)
{
Nombre(); // Llamado de la funcion en el Main
}

/* A continuación la declaracion del tipo de dato que la funcion

devolverá, su nombre y las variables que se le deben ingresar
como argumentos (su dominio), especificando su respectivo tipo*/

static TipoDeDato Nombre(Variables)

{
// Instrucciones, operatorias, etc.
return(Variable)
}
}
}

Respecto a esto, debemos tener algunos conceptos bastante claros: Al declarar

una función debemos indicar que tipo de dato devolverá. En caso que digamos que la
función devuelve un int, el valor que irá al main despues de haberla llamado sera un int.
Por ende, si la funcion es del tipo int entonces la variable que va en el return debe ser un
int. Si declaramos a la función como void, significara que la función no devolvera un
valor, lo cual es muy útil para impresiones en pantalla, por ejemplo, ya que no retorna
valor.
El nombre que le asignemos a la función sera el nombre con el que llamaremos a la
función en el Main y las distintas variables que pongamos dentro del paréntesis serán los
parámetros (variables) que se pedirán desde main para ejecutar la función. Debemos
especificar que tipo de variables son y darles un nombre cualquiera (no necesariamente
tienen que ser iguales al nombre de las variables con la que la llamaremos).
Dentro del código de la funcion podemos declarar nuevas variables de ser
necesario, pero estas variables solamente seran utilizables dentro de la funcion y no seran
reconocidas en el Main.
Un ejemplo de algunas funciones y su vista en pantalla es lo siguiente:
static void Main(string[] args) //Nuestro main
{
int x = 1, y = 2,suma; //Declaracion y asignacion
suma = Suma(x, y); //Llamado de la funcion Suma con x e y
Impresion(suma); /* Llamado de la funcion Impresion con
la variable suma */
Console.ReadKey();
}

static int Suma(int a, int b) //Declaracion de la funcion

{
int sumaf; //Declaracion de una variable
dentro de la funcion
sumaf = a + b;
return (sumaf); /* Valor que retorna la funcion
(int) */
}
static void Impresion(int algo) //Declaracion de la funcion
{
Console.WriteLine("La suma: " + algo);
}

Cuando la función ejecuta la línea return significa que ya se ha procesado un

cierto valor, el cual será retornado al Main y el llamado finalizará. Tener claro que este
valor debe ser del mismo tipo que el que se le asignó a la función en su declaración.
Finalmente, notar que una función del tipo void (vacío) no debe llevar un return.

Observaciones:
- Una función puede ser llamada por otra función. Incluso, una función puede ser
llamada por si misma. A esto último se le conoce en programación como
recursividad, lo cual profundizaremos a continuación.
6. Recursividad

En el ámbito de la programación, cuando hablamos de recursividad nos referimos

al hecho de definir algo (una propiedad u operación) en función de si mismo. En términos
prácticos, un método o función recursiva será aquel que para su funcionamiento realizará
uno o varios llamados a sí mismo. A priori, esto puede parecer difícil de comprender,
puesto que generalmente se hace la idea que de esta manera caeríamos en una especie
de trampa donde la función se llamaría dentro de sí misma infinitamente. Para evitar ello,
estableceremos para una función recursiva la siguiente estructura en dos partes:

- La parte propiamente recursiva, donde la función se llamará a si misma de

alguna manera.
- Una condición de término, la cual determinará cuando la función dejará de
llamarse a sí misma.

Un ejemplo para explicar la recursividad es hacer una función que calcule el

factorial de un número. Sabemos que el factorial de 0 por convención es 1. También
sabemos que para calcular el factorial de los demás números enteros positivos podemos
definir al factorial de un número entero 𝑛 en términos de otra operación factorial, tal que
𝑛! = 𝑛 ∙ 𝑛 − 1 !. Si traducimos esto a lenguaje de programación quedaría:

static int factorial(int n)

{
if (n == 0) //Condición de término
{
return (1);
}
else
return (n * factorial(n - 1)); //Llamado recursivo
}

Así, si la función es llamada con un número cualquiera mayor a cero, esta será
llamada nuevamente desde si misma con el mismo número menos uno hasta que n – 1
sea igual a cero, tras lo cual la función no se seguirá llamando a sí misma y retornará 1 al
llamado anterior, y este al anterior y así hasta la primera llamada, con lo cual se calculará
el resultado.
Ciertamente, esta forma de resolver problemas tiene sus ventajas y desventajas
respecto a la forma tradicional (iterativa) de plantear algoritmos. De manera recursiva los
problemas se pueden plantear de una forma mucho más elegante y comprensible. Los
ejemplos más comunes son el factorial y la sucesión de Fibonacci. Como desventaja, para
el computador será mucho más pesado resolver problemas a través de un planteamiento
recursivo que de modo iterativo.

Observación:
-Una función recursiva siempre tendrá su equivalente iterativa y viceversa
7. Estructuras de control
Ahora ingresaremos al tema de estructuras de ciclos y selección. En general, estas
herramientas son la base de la programacion básica. Las distintas estructuras serán
nuestra base para resolver problemas, a través de la resolución de preguntas como “¿Qué
pasa si son iguales? y ¿Qué pasa si son distintos? “, “¿Cuántas veces necesito repetir una
acción y cuando deseo detenerme?”.
En un principio puede ser confuso qué usar y bajo qué condición, pero con la
práctica verán que uno se acomoda a su uso.

7.1. Estructuras condicionales selectivas

7.1.1 If
El clásico if sera nuestra estructura mas básica. Consiste en una condición y una
secuencia de acción en el caso que la condición sea verdadera. Esta acción la
encerraremos entre llaves, de manera que su uso sea exclusivamente en el caso que
entremos al if. La sintáxis es la siguiente:

if (Condicion) //”Si „Condicion‟ es verdadero”

{
Acciones; //Entonces se ejecutará esto
}

Recordemos que la ‘Condicion’ es una expresión Booleana. En el caso que ella nos
devuelva verdadero, entonces entraremos al if. Si nos devuelve Falso, simplemente no
entraremos.

El if lo podemos acompañar de un else (“si no se cumple”). Lo escribiremos de la

siguiente manera:

if (Condicion) //”Si „Condicion‟ es verdadero” (se cumple)

{
Acciones if;
}else //”Si „Condicion‟ es falso” (no se cumple)
{
Acciones else;
}

No es necesario que un if venga acompañado de un else, pero no podemos poner

un else si no existe un if antes. Tambien podemos anidar muchos ifs. La idea es que si la
primera condición no se cumple pasemos a analizar una segunda condición, si ella
tampoco se cumple, otra y asi. Cuando anidamos los if si llegasemos a entrar a una
condición no analizaremos el resto, sino que nos quedaremos con la que si entramos.
La forma de escribir los if’s anidados es:

if (Condicion1)
{
Acciones;
}
else if (Condicion2)
{
Acciones;
}
else if (condicion3)
{
Acciones;
}
else
{
Acciones;
}
En resumen, si la condicion1 es falsa, analizaremos la condicion2, si esa tambien es
falsa, analizaremos la condicion3 y asi. Si todas las condiciones resultaron falsa, podríamos
terminar con un else.

7.1.2 Switch
La otra estructura de selección que usaremos es el switch. La estructura es la
siguiente:
switch (variable)
{
case (valor1): //“Si variable es igual a valor1”
Acciones;
break;
case (valor2): //“Si variable es igual a valor2”
Acciones;
break;
case (valor3): //“Si variable es igual a valor3”
Acciones;
break;
default: //“Si variable no es igual a ninguno”
Acciones;
break;
}
Llamaremos al switch con una variable (la cual obviamente tiene que estar
declarada y cuyo valor debe haber sido asignado previamente). Esa variable será
comparada con el valor que se le de a los distintos casos. Los valores que están
representados por valor1, valor2 y valor3 tienen que ser acorde con el tipo de variable
que le ingresamos al switch. Por ejemplo si ingresamos la variable int x los valores de los
casos no pueden ser caracteres. El default será el caso en que la variable que le
ingresemos sea distinta de todos los casos existentes. Este es opcional, pero el switch
claramente necesitara al menos un case para funcionar.
 A diferencia del if, el switch no pedirá condiciones booleanas, pero en el fondo
estará haciendo una comparación también (algo asi como variable == valor1).

7.2. Estructuras de repetición

Una estructura de repetición será aquella que vaya repitiendo todo el

procedimiento (todo lo que esté dentro de sus brackets { }) mientras se cumpla una cierta
condición dada. Cuando uno comienza a programar es muy común que con las
condiciones que le ingresemos entremos a un ciclo infinito o bien que no entre a la
estructura (esto se mejora con la practica).
Estas estructuras (ciclos, o bucles) son muy utiles cuando queremos repetir un
procedimiento n veces.

7.2.1. While/Do while

Entre los que usaremos comunmente estan el while y el do while. Sus respectivas
traducciones “mientras” y “hacer mientras” nos dan a entender que repetirán un
procedimiento “mientras” alguna condicion se cumpla. La única diferencia entre estos dos
ciclos es que en el do while necesariamente entraremos al menos una vez (fijense que la
condición esta despues del procedimiento), mientras que en el while puede que no
entremos nunca (si la primera vez que llegamos a él la condición es falsa). Se escriben de
la siguiente manera:

while (condicion)
{
Acciones;
}

do
{
Acciones;
}while(condicion);

Estos ciclos son bastante faciles de usar y cómodos, ya que bajo la condición que
tengamos tendremos la posibilidad de manipularla dentro del código. Por ejemplo, si en
algun punto logramos nuestro objetivo dentro del ciclo, podemos alterar el valor variable
de nuestra condición de manera que salgamos inmediatamente.
 7.2.2. For

El ciclo for requiere un poco más de sintáxis para usarlo. Nos pedirá la
inicialización de una variable, una condición y alguna alteración (incremento) a una
variable despues de terminar un ciclo. Se escribe así:

for (inicialización; condición; incremento)

{
Acciones;
}

La idea es que en la inicialización, condición y incremento (notar que esto se

refiere a un cambio en una variable, no necesariamente un incremento) usen todos la
misma variable. Esto no es una necesidad, pero no tendría mucho sentido (aunque
depende mucho del caso tambien).

Un ejemplo:
for (int i = 0; i < 10; i++)
{
Acciones;
}

En palabras, lo que hará será lo siguiente: El ciclo comenzará con la variable i en

valor cero, ejecutará las acciones dentro de los brackets y aplicará el incremento
especificado luego de ejecutar las acciones (en este caso, ++ significa un aumento de una
unidad a la variable). Luego, verificará si la condición se sigue cumpliendo (que i sea
menor que 10). De cumplirse el ciclo comenzará nuevamente, pero ahora con el valor
“incrementado” de i. El ciclo terminará en el momento en que la condición deje de
cumplirse.

Observación:
- Un ciclo while puede ser escrito de tal manera que cumpla la misma
funcionalidad que un for ya que este último es un caso particular del primero.
8. Arreglos
8.1. Arreglos de una dimensión

Los arreglos son una estructura de datos que nos ayudará a almacenar variables de
un mismo tipo de manera agrupada. La declaración de un arreglo se hará de la siguiente
manera:

TipoDeDato[] NombreArreglo = new TipoDeDato[TamañoDelArreglo];

O bien:
TipoDeDato[] NombreArreglo = {valores}; //Los valores separados por comas

La utilidad de los arreglos es el poder almacenar muchos valores dentro de una

misma variable. La capacidad del arreglo quedará definida tanto en ‘TamañoDelArreglo’
como vemos en la primera declaración, o en el caso de la segunda declaración, de la
cantidad de datos que pongamos en una declaración. Un Ejemplo sería el siguiente:

int[] numeros = new int[5];

El cual crearia un arreglo vacío de enteros con un tamaño de 5. Veamos un ejemplo

en que lo declaramos dandole valores:

int[] numeros = {4,5,3,1,2};

En donde creamos un arreglo del mismo tipo y del mismo tamaño, pero con los
valores ya asignados. Si declaramos un arreglo como int[] numeros = new int[5];
Inicialmente este no tendrá valores en sus índices, por lo cual deberemos llenarlo para
poder trabajar.

Los elementos del arreglo se enumeran desde el 0. De esta manera podremos

trabajar o extraer información del arreglo haciendo referencia a un índice del arreglo. Por
ejemplo:

int[] numeros = { 4, 5, 3, 1, 2 }

En donde el arreglo quedara de la siguiente forma:

Indice: 0 1 2 3 4
4 5 3 1 2

Fijense que el ultimo indice del arreglo es el tamaño menos 1 ya que los índices
comienzan desde 0. Para poder mostrar en pantalla algun valor del arreglo escribimos:
Console.Write("el indice 3 del arreglo es: " + numeros[3]);
En pantalla:

El ciclo en particular que nos va a ayudar mucho a trabajar con arreglos es el ciclo
for. Con él, seremos capaces de mover el índice y hacer distintas tareas sobre el arreglo.
Por ejemplo, si quisieramos imprimir todos los valores del arreglo, haríamos lo siguiente:

int[] numeros = { 4, 5, 3, 1, 2 };
for (int i = 0; i < numeros.Length; i++)
{
Console.Write(numeros[i]);
}
/* Nota: NombreDelArrglo.Length devuelve un entero que representa
el número de casillas del arreglo */

Con esto, la variable i se movera desde 0 hasta 4 (ultimo indice de este arreglo) y
cada ciclo imprimirá el valor de ‘numeros[i]’ en donde i sera el índice. Por lo tanto, cuando
i valga 0, imprimirá numeros[0] el cual es el primer indice de este arreglo. En pantalla
tendremos:

Al momento de trabajar con arreglos, debemos ser muy cuidadosos de no pedir un

indice que no exista dentro arreglo. Por ejemplo, para el arreglo numeros no existe un
valor menor a 0 o un valor mayor a 4. Por lo tanto si pedimos un indice que no existe
dentro del arreglo, el compilador nos lanzara un error y se verá algo asi:

int[] numeros = { 4, 5, 3, 1, 2 };
Console.Write(numeros[5]); // Llamando un indice que no existe
Y al ejecutar:

Y este error (exepción) nos dice claramente cual es el problema.

IndexOutOfRangeException se refiere a que el índice que estamos pidiendo, esta fuera del
rango del arreglo, y por lo tanto, un valor para numeros[5] no existe. Recordemos que los
arreglos pueden tener cualquier tipo de dato que este incluido en C#. En efecto, podemos
hacer arreglos de distintos tipos:

int[] numeros = { 4, 5, 3, 1, 2 };
char[] letras = new char[10];
string[] saludo = new string[3];
double[] reales = new double[100];
bool[] bombas = { false, true, false };

También podemos usar for para llenar un arreglo. Ejemplo:

for (i = 0; i < saludo.Length; i++)

{
if (i == 0)
{
saludo[i] = "hola";
}
else if (i == 1)
{
saludo[i] = "como";
}
else if (i == 2)
{
saludo[i] = "estan?";
}
}
Y luego imprimirlo:
for (i = 0; i < saludo.Length; i++)
{
Console.Write(saludo[i] + " ");
}

Y tener en pantalla:

8.2. Arreglos Multidimensionales:

Hasta el momento hemos visto el caso de arreglos de una dimensión, los cuales
podríamos decir que se comportan como un vector. Ahora veremos que tambien
podemos declarar arreglos de mas de una dimensión; una matriz de datos, incluso un
cubo de datos o mucho mas. Respecto al curso, sólo veremos hasta arreglos
bidimensionales, es decir, como una matriz. Primero veamos una declaración de un
arreglo bidimensional vacío:

int[,] matriz = new int[3,5];

Tambien podemos declarar estos arreglos bidimensionales dandole valores de

inmediato. Esto lo hariamos de la siguiente manera para un arreglo del las mismas
dimensiones que el anterior:

int[,] matriz = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 11, 12,

13, 14, 15 } };

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15

De esta declaración podemos ver dos diferencias inmediatas de la declaración

unidimensional. Ahora los brackets despues del int vienen con una coma entremedio. Esto
nos va a indicar que tiene dos dimensiones. Luego, en lugar de colocar un tamaño,
colocaremos dos tamaños. ¿Qué nos quieren decir estos tamaños?, nos indicaran el
tamaño de filas, y luego de columnas, siempre en ese orden. Por lo tanto para este
arreglo, tendriamos algo asi:

N° de Filas/ N° de Columnas: 0 1 2 3 4
1
2

De nuevo recordemos que los índices comienzan de 0, y por lo tanto el último

índice, tanto de las filas como de las columnas seran sus respectivos tamaños menos 1. Al
igual que con los arreglos unidimensionales si es que ingresamos un índice que está fuera
del rango del arreglo, lanzará un error de IndexOutOfRangeException. Una diferencia
notoria es que con un for no seremos capaces de imprimir un arreglo multidimensional
completo en pantalla. Como regla, se debe utilizar un ciclo for por cada dimensión que
tenga el arreglo.

Por ejemplo, para el caso de una matriz (arreglo bidimensional):

int[,] matriz = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, {11, 12,
13, 14, 15 } };
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 5; j++)
{
Console.Write(matriz[i, j] + " ");
}
Console.WriteLine();
}

Lo cual se vería asi en pantalla:

 La lógica detrás de esto es que al iniciar el primer for, la variable i tiene valor 0.
Luego entra al segundo for donde j también tiene valor 0 y se imprime la casilla [0, 0]. El
for que está al interior incrementará j hasta que se deje de cumplir la condición y no se
completará el ciclo exterior (el primer for) hasta que finalize el que está al interior. De
esta manera, sólo cambiará el índice de la columna (la secuencia será [0, 0], [0, 1], [0, 3],
etc..). Terminado el ciclo for interior, nos saltamos una linea (Console.WriteLine();) y
el índice i aumentará su valor en una unidad. De esa manera hasta que el for más
externo complete sus repeticiones.
9. Windows Forms

Antes que nada, consideramos importante para una mejor comprensión de esta
sección hacer una breve introducción del concepto de “objeto” en programación, dado
que para este caso no utilizarán la consola para probar sus códigos sino que ahora
trabajarán programas que mostrarán directamente una interfaz gráfica de ventanas con
sus respectivos controles (tales como botones) y donde cada uno de estos elementos,
incluida la misma ventana, es un objeto.

Un objeto corresponde a una instancia de una cierta clase. Cómo ejemplo,

podríamos decir que el iPhone es un objeto de clase celular. Para los programas de
Windows Forms usaremos objetos de la clase textBox, button entre otros.

Básicamente, un objeto está caracterizado por los atributos que lo definen y los
métodos que dispone. Como ejemplo, podríamos decir que hay una clase “persona” cuyos
atributos serían su edad, estatura, peso, color de pelo, etc. Sus métodos (funciones) serían
las acciones que la persona podría realizar, como por ejemplo hablar o caminar.

En el entorno que nos ofrece el C# podremos encontrar múltiples objetos que nos
serán de utilidad para elaborar una interfaz que permita al usuario hacer uso de las
funcionalidades que programaremos. A continuación mencionaremos algunos objetos de
uso recurrente:

Objeto Windows Form:

Entre los objetos más comunes para el manejo de ventanas encontramos los botones, las
etiquetas (labels), los cuadros para ingresar texto y algunos elementos que nos podrían
ser útiles para elaborar formularios tales como listas desplegables y cuadros que
contienen diferentes opciones.

Un ejemplo:
 9.1. Atributos de un objeto Forms:

Los objetos de Windows Forms poseen muchos atributos (propiedades), de los

cuales haremos mención a los más utilizados. Para efectos prácticos, estas son las
variables que definen la apariencia y usabilidad de los distintos objetos, y podemos
trabajarlas como cualquiera de las otras variables que hemos visto anteriormente
asignándoles valor o bien comparando su valor actual contra un cierto valor determinado.
Algunas de las variables más utilizadas son:

 BackColor: corresponde al color del fondo del objeto. Existen no sólo los colores
típicos, sino combinaciones similares a las de las páginas Web.
 BackgroundImage: lo que conseguimos con esta propiedad es la de asignarle al
fondo de la ventana una imagen ya definida por nosotros mismos (en estos casos
es recomendable salvar esta imagen en el directorio “…Bin\Debug” a modo de
orden).
 Font: esta propiedad nos permite modificar lo referente a la fuente que utilizamos
en la ventana, desde la tipografía, tamaño, tal como lo hacemos en el procesador
de texto.
 ForeColor: esta propiedad nos permite modificar el color de la fuente utilizada en
la ventana.
 Size: par ordenado que nos permite modificar el ancho y el alto de la ventana, éste
está expresado en pixeles.
 Text: esta propiedad modifica el texto que despliega el objeto en pantalla, así
como en el caso de los textbox podemos acceder al texto que ingresa el usuario a
través de esta propiedad. Es del tipo string.
 Icon: Modifica el icono que aparece en la barra antes mencionada.
 Enabled: Esta propiedad, al estar en estado False, impide al usuario a manipular el
objeto. Es del tipo bool.
 ReadOnly: en este caso, estamos dando la cualidad de que el objeto sólo podrá ser
leído por el usuario, el cual no podrá modificar ni ingresar texto en él
(independiente de que sí podrá colocar el cursor en él). Es tipo bool.
 Visible: Propiedad que permite ocultar el objeto al momento de ejecutar el
programa. Es tipo bool.
 Ítems: Colección de elementos que puede contener el objeto. Puede ser una lista
de strings.
 SelectionMode: Nos permite definir si el objeto permite seleccionar, uno, más de
uno o ninguno de los campos (si los tiene).
Podemos acceder a modificar las variables de un objeto seleccionándolo con el mouse y
modificando los campos en la ventana “Propiedades”:

El campo (Name) es uno de los más importantes ya que este determina cual será el
nombre de referencia con el cual nos vamos a referir a el objeto en particular. Mediante
esta referencia podremos acceder a las propiedades (atributos) del objeto cuando veamos
el código de nuestra aplicación de ventanas.

9.2. Eventos:

Ahora que nos encontramos frente a una interfaz gráfica que contiene botones,
campos, cuadros de texto y etiquetas, nuestra tarea será determinar el cómo responderán
nuestros objetos al interactuar el usuario con ellos. Debemos programar nuestros objetos
de tal manera que ante un determinado evento el programa ejecute cierta acción. Por
ejemplo, al crear un botón podríamos ubicarlo en nuestra ventana, cambiar su texto y su
color (entre otros atributos). Pero al compilar, si es que aún no hemos establecido que
sucede al hacer click al botón esté pasará a ser un simple adorno en nuestra pantalla. Los
eventos se modifican en la ventana propiedades haciendo click en el ícono del relámpago:
 Cuando hacemos doble click en un objeto, el programa crea de manera automática
una función que responderá a un evento al hacer click en él o cambiar de selección en el
caso de que fuera una lista. Generalmente, la función lleva por nombre
nombreObjeto_Evento. Nótese que en el form1.cs (vista código) podemos ver las
funciones existentes e incluso podemos programar algunas nuevas con los nombres y
funcionalidades que nosotros queramos (generalmente del tipo void) y asignar la función
que hayamos creado a determinado evento. Por ejemplo crearemos la función
“cambiarTexto” en nuestro programa:

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void cambiarTexto(object sender, EventArgs e)

{
//código
}
/* Deben poner como parámetros “object sender y EventArgs e” para
que la función sea reconocida como evento*/
private void button1_Click(object sender, EventArgs e)
{
//código
}
}
}

Y luego podremos seleccionar esa función para cualquier evento que queramos:
En el espacio de las funciones podemos cambiar la apariencia y contenido de los
elementos de nuestra ventana. Como mencionábamos anteriormente, para acceder a una
“variable atributo” de nuestros objetos podemos hacer lo siguiente:

Donde lo que va después del punto puede ser una de las variables que
encontramos en la ventana propiedades. Al igual que cualquier variable, podemos
asignarle un nuevo valor y también podemos realizar condicionantes al valor que esta
variable tome. Tener presente que podemos declarar variables tanto dentro de estos
eventos como fuera de ellos.

A continuación veremos un ejemplo del uso de eventos para cambiar las propiedades de
algún objeto:

En este ejemplo, se diseñó una ventana con un label que tiene el texto “Hola!” a la
cual llamaremos “saludo” (propiedad “(Name)”) y un button con el texto “Despedirme” al
cual llamaremos “boton1”. Para este ejemplo, programaremos que ante el evento que
boton1 sea presionado el texto (propiedad “Text”) del label saludo cambie a “Chao”.
 Para hacer esto debemos seleccionar el objeto boton1 y establecer el código para
realizar la acción que queremos dado el evento que en este caso será “hacer click” en el
botón:

Hacemos doble click en el campo del evento “Click” y el programa nos generará
automáticamente una función vacía en la cual podremos establecer que sucederá al
ocurrir este evento:

private void boton1_Click(object sender, EventArgs e)

{

Ahora indicaremos al programa que debe cambiar el texto del objeto llamado
saludo a “Chao”:

private void boton1_Click(object sender, EventArgs e)

{
saludo.Text = "Chao";
}

También podemos establecer que una vez el texto sea “Chao” al presionar el botón
este cambie a “Hola” y que el botón diga “Saludar” en vez de “Despedirme” y viceversa:

private void boton1_Click(object sender, EventArgs e)

{
if (saludo.Text == "Hola!")
{
saludo.Text = "Chao";
boton1.Text = "Saludar";
}
else
{
saludo.Text = "Hola!";
boton1.Text = "Despedirme";
}
}
 9.3. Cuadros de diálogo:

Los cuadros de dialogo se utilizan en las aplicaciones de ventana para mostrar

información relevante, así como también para pedir cierta información al usuario. La idea
de este tipo de objeto es que podamos programar una interacción con el usuario que nos
podría resultar útil para establecer ciertas condiciones durante ciertos eventos que
ocurran mientras se ejecuta el programa.

Para mostrar un cuadro de dialogo debemos escribir lo siguiente:

MessageBox.Show("Mensaje","Titulo", MessageBoxButtons.<TipoDeBotones>);

Donde en el campo <TipoDeBotones> debemos escoger cuales serán los botones (de
entre un set de predeterminados) que tendrá nuestro cuadro de dialogo:

A continuación, un ejemplo de cuadro con botones AbortRetryIgnore:

Al igual que sucede con los botones de nuestra ventana, si no programamos una
respuesta a las acciones del usuario, nuestro cuadro de diálogo será un simple decorativo
en el programa.
Para almacenar la respuesta del usuario debemos declarar una variable del tipo
DialogResult, la cual podremos utilizar para responder ante determinado botón que
presione el usuario:

Como se puede apreciar en la imagen de arriba, en la segunda línea de código

estamos estableciendo una cierta respuesta a qué ocurrirá cuando el usuario presione el
botón “Omitir” (Ignore) mediante un if.