Conceptos Fundamentales C#

C#.Net para Docentes y AlumnosProgramando en C#

Texto adaptado para la Unidad Curricular de Programación de los Alumnos y Docentes de la Especialidad Computación de la

Ciudad de Buenos Aires.

Gustavo E. Romay22/02/2010

.NET para Docentes y Alumnos. – Programando en C#

Introducción

En la actualidad, existen gran variedad de lenguajes para el desarrollo de sistemas, sin embargo, muchos de ellos poseen puntos en comunes, entre ellos y de suma actualidad e importancia, la forma de poder llegar a resolver un sistema utilizando la programación orientada a objetos, el manejo de los tipos de variables, la existencia de procesos como los ciclos, la toma de decisión, funciones, etc.

Este manual lo he dedicado, para que aprendamos a conocer el lenguaje C#, lenguaje que forma parte de la plataforma .NET desarrollado por la empresa Microsoft.

Les diré, que poco a poco, C# superó con creces todas mis expectativas, pues es un lenguaje moderno, potente, flexible y netamente orientado a objetos.

Todo lo que hecho, lo he probado utilizando los sistemas operativos Windows XP y Windows Vista, y se darán cuenta inmediatamente que los códigos expuestos son sencillos y podrán ser mejorados y optimizados por ustedes.

Con respecto al desarrollo de este apunte, he dividido al manual; para un mejor orden y entendimiento, en unidades, y fundamentalmente con una secuencia de complejidad en aumento que notarán a medida que vayan avanzando.

Decidí empezar con una breve introducción a la tecnología .NET, continué con la programación en el lenguaje C# propiamente dicha (variables, decisión, ciclo, funciones, etc.), utilizando la programación estructura – solo con un fin pedagógico -, y a medida que fui avanzando introduje los conceptos básicos de la programación orientada a objetos para terminar explicando lo referente a la interfaz visual que provee el software.

Todo comienzo es complejo, ronda ese halo de incertidumbre, les podrá

pasar que les cueste creer las excelencias de este lenguaje y de la programación orientada a objetos, pero tengan confianza, que a medida que uno se involucra en el aprendizaje, le dedique horas de práctica, lo irá entendiendo, y formará parte de un conjunto de herramientas mentales para proponer soluciones informáticas de calidad.

Por cada problema a resolver que nos surja, vamos a tener que analizar, diseñar y programar todo lo que una aplicación necesita para llegar a la solución solicitada, esto ya auspicia un trabajo arduo pero también un desafío personal que debemos aceptar.

Mi consejo, es que tengan un poco de paciencia. Cuando empecemos a confeccionar pequeños programas para consola y más adelante a desarrollar aplicaciones con entorno grafico bajo Windows, verás lo útil que fue haber aprendido a programar sentencia por sentencia en consola para crear pequeños programas, funciones, clases, etc.

Hay que tener en cuenta que los objetos más utilizados para el desarrollo de aplicaciones, ya fueron desarrollados por Microsoft (ventanas, botones, cajas de texto, cuadros de diálogo, etc.) por lo tanto solamente tendremos que


aplicarles bloques de código con un mínimo esfuerzo, para obtener los resultado requeridos para cada aplicación.

He dejado para el final el desarrollo de aplicaciones bajo Windows, creyendo que hubiese sido complicado que comprendan este lenguaje sin el conocimiento previo resumido en el párrafo anterior.

Ha llegado el momento de comenzar a aprender, espero que lo disfruten como yo lo hecho al escribir este manual.


Conceptos fundamentales de C#.


ÍndiceÍndiceUnidades Pagina

Unidad 1Introducción al .NET

6

Unidad 2Elementos básicos de un programa en C#

15

Unidad 3Toma de Decisiones

36

Unidad 4Los Ciclos

52

Unidad 5Las funciones y los métodos

68

Unidad 6Los Arreglos

90

Unidad 7Las Colecciones

108


Unidad 1Unidad 1

Introducción al .NET y C#.Introducción al .NET y C#.

Tiempo Estimado: 60 minutos

Programar bajo Windows era una tarea realmente compleja y difícil, pues requería un alto grado de especialización. Hoy en día existen varios framework, desarrollados por diferentes empresas que se hacen valer en el mercado informático, dando cada vez más y mejores prestaciones, provocando que encuentren adeptos y fanáticos de los mismos.

Entre las empresas más importantes que han estado desarrollando lenguajes para desarrollo de sistemas, nos encontramos con las compañías de renombre como Sun con su lenguaje Java, y Microsoft con .NET.

El lenguaje que vamos a utilizar este curso, va ser uno de los que provee .Net, denominado C#.

El primer componente que debemos conocer del .NET, es el CLR (common lenguaje runtime), este es un programa que lee línea a línea y ejecuta los programas que iremos creando.

Cuando programemos en C# el programa fuente generado por el programador, se compilará en un modulo denominado assenbly, que contiene el programa escrito en CIL (lenguaje intermedio para ser ejecutado por el runtime), gracias al assenbly y el runtime el .NET nos permite tener una gran flexibilidad y que las aplicaciones sean multiplataforma.

El .NET posee un CLS (especificaciones comunes de lenguaje), cuyo fin es el de permitir utilizar diferentes lenguajes de programación, siempre cuando se posean especificaciones específicas, para poder interactuar con el runtime.

Para empezar a trabajar, deberemos instalar el .NET es vuestras computadoras. En caso no tener una versión comercial como el .Net Visual Studio 2005, 2008 o 2010, pueden bajarse de la página web de Microsoft, la versión “express” que es totalmente gratuita (solo deberán registrase dentro de los 30 días, luego de haberla instalada). Actualmente ya está la versión 2010 express esperándolos, lista para ser bajada.


Vamos ya, a confeccionar nuestra primera aplicación.

Ejecutemos el .NET y nos aparecerá la siguiente ventana.

Luego accedan al menú, y en la parte superior seleccionen con el mouse o el teclado: Archivo, Nuevo proyecto y aplicación de consola.

Un nueva ventana se presentará ante la vista de ustedes, indicándole la posibilidad de ponerle un nombre y una ubicación a la aplicación. Le he puesto como nombre a la aplicación “ejemplo1” y la ubicación del mismo es en una carpeta que debemos crear; por ejemplo, “c:/cursonet/ejemplos”, esto será fundamental para llevar un orden de lo que iremos trabajando y ademas facil de ubicar a la hora de buscar un programa.

Luego presionen el botón de Aceptar, para continuar con la aplicación.


Luego de los pasos anteriores, veremos una nueva ventana dividida en varias áreas, además de una estructura ya conformada con varias líneas de programación proporcionada por el IDE (entorno de desarrollo integrado).

Y ya se estarán preguntando que es todo esto.

¡Dadme un poco de tiempo!, y a medida que avancemos con el curso, les iré explicando línea por línea; por ahora agreguemos una sola línea a nuestro ejemplo1.

La línea que debemos agregar – dentro de la función principal llamada Main() - a ejemplo1, es la siguiente:

System.Console.WriteLine("Hola Mundo");

C# cuenta con IntelliSense, a medida que vamos tipeando nos aparecerá una ventana con la lista de los miembros de esa clase, al encontrarlo pueden presionar “Enter” y se dispone el miembro seleccionado en el editor.

El editor cuenta con el resaltado de sintaxis por colores, indicando azul para las palabras claves, los comentarios con verde, rojo las cadenas de caracteres y con negro el resto del texto.

Esta línea nos permitirá mostrar por consola un mensaje. Es muy importante respetar las palabras claves, mayúsculas y minúsculas y el punto y coma al final de cada línea.

Nuestro código, quedará de la siguiente manera:

using System;using System.Collections.Generic;


using System.Text;

namespace ejemplo1{ class Program { static void Main(string[] args) { System.Console.WriteLine("Hola Mundo"); } }

}

Para poder probarlo, deberemos acceder al ítem del Menú, Depurar y luego iniciar sin depurar. Deberíamos ver el siguiente resultado:

Ya funciona, por lo tanto lo podemos guardar, para eso debemos ir al Menú, Guardar todo.

Solo a pedido de vuestra curiosidad, veamos en detalle algunas de las líneas del código dispuesto. Las primeras líneas comienzan con la palabra Using, esta es una directiva que ayuda al compilador para ubicar una clase que se utiliza en esta aplicación. El lenguaje C#, provee un conjunto de clases que se conoce con el nombre de Biblioteca de Clases del .NET Framework (FCL), donde podremos encontrar una cantidad de herramientas ya definidas para nuestros sistemas.

Otra línea que debemos tener en cuenta es class Program, en ella se

declara la clase (dentro de una clase ingresaremos las variables y los métodos o funciones de nuestra aplicación). Presten atención que luego de la instrucción se abre una llave, indicando el comienzo de la clase y al final debe existir una llave de cierre.

La línea siguiente es static void Main(string[] args), esta es

la funcion principal Main(), debe estar presente para que una aplicación

funcione, también se abre y cierra con llaves. Luego de la palabra reservada Main siguen un par de paréntesis, esto nos indica que es un método.

Para finalizar la sentencia System.Console.WriteLine("Hola Mundo"); , se denomina instrucción y es la que realizará la tarea de mostrar

por consola el mensaje “hola Mundo”. Que aparezca por pantalla el mensaje o que uno puede ingresar alguno, se debe a una clase denominada Console,

palabra tambien reservada dentro de nuestra instrucción, luego de Console y


separado por un punto vemos WriteLine, este es el método por el cual nos muestra información por consola. El mensaje se encuentra encerrado entre parentesis y comillas, este se conoce como una cadena de caracteres, literal o simplemente cadena.

Veamos otro ejemplo para esta unidad. El objetivo será mostrar un mensaje en varias lineas, pero solo con una instrucción.

Vamos a ser uso de 2 caracteres, la barra diagonal inversa (\) y la letra n. la barra \ se denomina carácter de escape y sirve para indicarle; combinada con la letra n, que imprima y continue en la linea siguiente.

using System;using System.Collections.Generic;using System.Text;

namespace ejemplomustraenvariaslineas{ class Program { static void Main(string[] args) { Console.WriteLine("Bienvenidos \nal mundo de \nla Programacion!"); } }

}

Luego de ejecutar el programa, vemos lo siguiente:

Existen otros caracteres de escape, lo dispongo en al siguiente tabla:

Secuencia de Escape Descripción

\n Posiciona el curso en la linea siguiente.\t Desplaza al cursor a la primera tabulacion horizontal.\r Posiciona el curso al inicio sin saltar a la linea siguiente.\\ Se utiliza para colocar un barra inversa en la cadena.\” Lo utilizamos para colocar la doble comilla en la cadena.


Cuando damos formato a una cadena, haremos uso de los elementos de formato explicados anteriormente, ellos van entre llaves y un valor que indica la posición del argumento a mostrar dentro de una lista de argumentos. Empieza en 0 (cero). Por ejemplo:

Console.WriteLine("{0}\n{1}","Bienvenidos al","Mundo de la programación!");

El resultado se ve del siguiente modo:

Ya hemos terminado la primera unidad. El objetivo era que podamos dar el primer paso para empezar a programar en C#. Y para eso era fundamental tener el .NET, instalarlo y saber iniciarlo. Luego agregamos una sola línea en el editor ya provisto por el .NET. Y para finalizar aprendimos a ejecutarlo, para que nos muestre el mensaje programado por consola.


Tareas a desarrollar de la Unidad 1.

1. Crear un nuevo proyecto que muestre por consola, nuestro Nombre y Apellido.

2. Quitar al ejemplo anterior un punto y coma y ver el error que se genera.3. Realizar un programa que muestra la información concerniente a

nuestra entidad educativa o empresa laboral. Disponer la información en varios renglones.


Soluciones de las tareas a desarrollar, de la Unidad 1.

1. Código de la Aplicación.


namespace solucion1{ class Program { static void Main(string[] args) { Console.WriteLine("{0}", "Gustavo E. Romay"); } }}

Visualiza lo siguiente:

2. Código del Problema anterior y he sacado el punto y coma de la instrucción donde se imprime por consola.

Console.WriteLine("{0}", "Gustavo E. Romay")

Lista de errores.

3. el código es el siguiente:


namespace solucion3{ class Program


{ static void Main(string[] args) { Console.WriteLine("{0}\n{1}", "SG", "Sistemas de Información."); Console.WriteLine("\n"); Console.WriteLine("{0}\n{1}\n{2}", "Av. Boedo 640", "Ciudad Autonoma de Buenos Aires.","Argentina"); Console.WriteLine("\n \n"); Console.WriteLine("{0}\n{1}", "II/2009","*******");

} }}

Visualiza lo siguiente:


Unidad 2

Los elementos básicos de un

Programa en C#.

Tiempo estimado: 120 minutos

Comencemos con la segunda unidad, presentando los elementos básicos que conformarán un programa hecho en el lenguaje C#.

Para comunicarnos con nuestra computadora, vamos a necesitar un lenguaje de programación, y como he dicho, este será el C#, poderoso y sencillo de aprender.

No solo basta saber las instrucciones de un lenguaje de programación para crear una aplicación, además, deberemos aprender algún método o forma de programación, es decir, los pasos que deberá cumplir la PC para resolver algún problema que se nos ha planteado.

Esta lista de pasos que lleva a un determinado fin o solución, nos va a generar un Algoritmo. Un Algoritmo podemos definirlo como, una lista bien definida, ordenada y finita de operaciones que nos permitirá hallar la solución a un problema determinado. Posee un estado inicial, pasos sucesivos y bien definidos para llegar a un estado final, obteniendo la solución necesaria para nuestra aplicación.

Veamos un ejemplo.

Propongo realizar un programa, que nos muestre los pasos a seguir para organizar un baile con nuestros amigos.

Los pasos a seguir que propongo son: fijar el día y el horario, realizar las invitaciones, repartir las invitaciones, recibir las confirmaciones de los invitados, encargar los sándwich, comprar las bebidas y seleccionar la mejor música.

Podemos ya editarlo.



namespace organizacionbaile{ class Program { // funcion principal del programa. // aqui comienza la aplicacion. static void Main(string[] args) { System.Console.WriteLine("BAILE"); System.Console.WriteLine("fijar el día y el horario"); System.Console.WriteLine("Realizar las invitaciones"); System.Console.WriteLine("Repartir las invitaciones"); System.Console.WriteLine("Recibir las confirmaciones de los invitados"); System.Console.WriteLine("Encargar los sándwich"); System.Console.WriteLine("Comprar las bebidas"); System.Console.WriteLine("Seleccionar la mejor música"); /* si me olvide de algo ustedes * lo pueden agregar */; } }}

Voy a comentar lo que he hecho, en base a la estructura del programa que estamos trabajando.

En C# existen varias secciones en el programa, ellas cumplen determinadas funciones. La más importante y principal es la función Main(), pues es invocada por el sistema operativo para que inicie nuestra aplicación.

En nuestro programa he puestos algunos comentarios, eso significa, que no será tomado en cuenta por nuestro compilador. Si el comentario es de solo

una línea bastará utilizar la doble barra // seguido del comentario, si en cambio queremos realizar un cometario de varios renglones, deberemos abrir con barra

y asterisco /* seguir con el comentario y cerrar con asterisco y barra */.

Veamos algunos ejemplos de comentarios:

// declaracion e inicio de variables.

/* Sistema desarrollado por GER

Calculo del promedio de notas de alumnos.*/

Ya hemos hablado de Main(), en ella hemos dispuesto un bloque de

código definido entre llaves {}. Todo lo que este entre llaves va a pertenecer a la función principal Main(), fuera de ella pertenecerá a otra función u otra


característica del programa que iremos viendo. En nuestro ejemplo encontramos los pasos del algoritmo. Cada paso lo denominaremos Sentencia. Una sentencia es una instrucción que se ejecutará cuando sea invocada.

Notemos que en la estructura existe una clase denominada Class Program, que también tiene un bloque de código cerrado por llaves, esta contiene a la función principal Main().

Adentrándonos en C#, puedo decir, que este es un lenguaje orientado a Objetos, por lo tanto será necesario definir una clase para luego crear nuestro programa. La clase “Class Program”, ya viene definida cuando creamos un nuevo proyecto, pero el objetivo en poco tiempo, es que nosotros empecemos a armar nuestras propias clases.

Antes hemos definido el namespace denominado por nosotros con el nombre de organizacionbaile, aquí se dispone de otro bloque de código y la clase se encuentra dentro de él, ya volveremos a profundizar sobre estos temas, por ahora he querido hacer notar la importancia de estas secciones que conforman un programa.

Continuando con las sentencias, vemos que esta invoca a un método denominado WriteLine(). Un método es similar a una función, por lo tanto deben pertenecer a una clase, en este caso la clase se llama Console.

En la clase “Console”, encontraremos una cantidad de métodos necesarios para trabajar por consola, puedo enumerar algunos de ellos, como el de mostrar mensajes, ingresar datos, etc.

Para invocarlos lo haremos se la siguiente manera:

Console.WriteLine(“HOLA”);

A los métodos se les pasa información para que puedan trabajar, esta información se dispone entre paréntesis y la llamaremos parámetro. Además cada método necesita de un tipo de dato, en el caso de WriteLine (), le hace falta un parámetro de tipo cadena es decir conformado por letras, números o caracteres especiales encerrado entre comillas dobles, en este caso la cadena es “HOLA”.

Para finalizar cada sentencia se deberá en forma obligatoria, disponer de

un punto y coma “;“. Esto es, de suma importancia, pues el compilador de C#; gracias a este símbolo, reconocerá la finalización de la sentencia, la ejecutará y continuará con la instrucción siguiente.

Una vez que ejecutemos el programa, veremos lo siguiente:


Errores en los programas.

Una parte importante de la programación, es poder reconocer los errores que irán apareciendo; a medida que vayamos programando, con el fin de corregirlo y que el programa trabaje correctamente.

Tendremos 2 tipos de errores, errores de sintaxis y los errores de lógica.

Los errores de sintaxis – una vez que el compilador los detecte - se dispondrán en una ventana en la parte inferior, con una descripción del mismo indicando la línea en que este se haya producido, por lo tanto nos limitaremos a corregirlos.

Siempre empecemos a corregir de arriba hacia abajo, pues puede ocurrir que los errores estén encadenados con los de las primeras sentencias y los que siguen no posean error alguno de sintaxis.

Los errores de lógica, son más difíciles de corregir, pues, ellos son cuando no tenemos errores de sintaxis y sin embargo nuestro programa no realiza lo que deseamos. Para este caso se requiere un buen análisis del problema, y corregir el algoritmo que se ha adoptado para la aplicación que estemos desarrollando.

Para probar el tema de errores y ver lo que sucede, he sacado unas comillas correspondiente a la cadena de la última sentencia, inmediatamente nos mostrará el error de sintaxis que esto ha generado.

Observemos, que a pesar de ser un único error, aparecen una cantidad de líneas; casi tantas como las sentencias del bloque de instrucciones que contiene el código.


Deben probarlo, saquen unas comillas y vean que pasa.

Luego corrijamos los errores – en mi caso había sacado la comillas de la última sentencia - , vuelvan a compilar y todo se ha solucionado y funciona correctamente.

Diferencia entre el método Write() y el WriteLine().

Hemos visto, que en nuestra aplicación, el método WriteLine() nos ha permitido disponer de un mensaje en la consola, y luego se ha producido un salto de línea. Si en cambio, hubiésemos utilizado el método Write(), este, una vez que dispone el mensaje, no produce un salto de línea, por lo tanto, si a continuación se dispone de otro mensaje, se ubicará a su lado.

Veámoslo con un ejemplo:

Mostraré mi nombre y la actividad que desempeño.


namespace writeywriteline{ class Program { static void Main(string[] args) {


System.Console.Write("Mi nombre es: "); System.Console.WriteLine("GUSTAVO"); System.Console.Write("Actividad que desempeño: "); System.Console.WriteLine("DOCENTE"); } }}

Por consola vemos lo siguiente:

Las variables en C#.

Una computadora para trabajar necesita poder almacenar y manipular información, y sin duda, esta será de diferentes tipos. Entendiéndose por tipo si es un nombre de una persona, en este caso el tipo será una cadena, un sueldo de un empleado será numérico, la fecha de cumpleaños, un tipo fecha, etc.

Para el manejo de la información; a utilizar en nuestros sistemas, lo haremos a través del uso de las variables.

Las variables funcionan en forma similar a una caja de almacenaje. Para poder acceder a estas cajas o variables, deberemos ponerle un nombre o etiqueta, cuyo fin es la de poder identificarlas cuando las necesitemos.

En C#, para poder hacer uso de una variable deberemos declararla, es decir indicar, el nombre de la misma y el tipo que le corresponde. Para esto, les daré las siguientes recomendaciones:

Los nombres de las variables deben empezar con alguna letra. Puede contener números, pero no al inicio del nombre.

No pueden llevar signos salvo el guion abajo _. No pueden llevar acento. Recomiendo que se escriban en minúsculas, para diferenciar de las

clases, funciones, etc. C# es sensible a las mayúsculas y minúsculas por lo tanto una

variable llamada costo es diferente a otra llamada Costo.Con respecto al tipo de variable a requerir y recordando que se debe

utilizar el tipo de variable específica, nos va a permitir ahorrar memoria y optimizar la información que utilizaremos, presento la siguiente tabla de tipos de variables más comunes:


Tipo Información que guardaBool Variable booleana. Guarda solo verdadero o falso (true

y false).Byte Guarda un byte de información, es decir un valor

entero entre 0 y 255.Char Guarda un carácter (character) de tipo Unicode.Float Guarda valores numéricos decimales.Int Este tipo, guarda valores numéricos de tipo entero.String Se utiliza para guardar valores de tipo cadena.

Los pasos a seguir será el de declarar y luego inicializar las variables, para que puedan ser usadas en las aplicaciones. Para declarar la variable, basta con poner el tipo y luego el nombre de la misma. No deben olvidarse de terminar con un punto y coma.

Les presento algunos ejemplos.

Int edad;Float sueldo;String nombre;Int contador,cantidad;

Al inicializar las variables, también podemos indicarle un valor por primera vez. Lo realizaremos, utilizando un operador de asignación el signo igual “=” y a continuación el valor asignado.

Ejemplos:

edad=0;sueldo=0.00f;nombre=”patricia”;contador=0;cantidad=50;

Por comodidad podemos declarar e inicializar las variables en una sola sentencia, por ejemplo:

String nombre=”patricia”;

Si quisiéramos mostrar los valores de las variables en la consola, podemos utilizar los métodos Write() y WriteLine(), con la posibilidad de

poder definir una cadena de formato y una lista de variables.

En la cadena de formato indicaremos el mensaje, y la posición de la

variable en el mismo. La posición de la variable está indicada por llaves “{}” y un índice que indica la posición empezando por el valor 0, quedaría así {0}, {1}, en la lista de variables. En la lista, dispondremos de las variables que queremos mostrar.

Programemos un ejemplo.


Realizar un programa que Indique el precio de lista y el de costo de un artículo.


namespace declarainiciavariables{ class Program { static void Main(string[] args) { string producto = "camisa"; float precio = 50.00f; float costo = 30.00f; Console.WriteLine("El articulo {0} tiene un precio al publico de {1}$ y su costo {2}$", producto, precio, costo);

} }}

Luego de ser depurado, debería verse así:

Las operaciones aritméticas.

Ya que hemos aprendido y sabemos como guardar la información, debemos aprender la manera de poder manipularla. Comencemos con las operaciones aritméticas básicas como, la suma, la resta, la multiplicación, la división, etc. Cada operación aritmética tiene su propio operador, que es el encargado de procesar los valores, en un determinado cálculo y obtener un resultado final numérico.

Operador Descripción Ejemplo

= Asignación. Int a=10;Int b=5;Float resultado =0.00f;

+ Suma valores. resultado=a+b+5;En resultado se asignará 20.

- Resta de valores. resultado=a-b;En resultado se asignará 5.

* Multiplicación de valores. resultado=a*b;En resultado se asignará 50.


/ División decimal de valores. resultado=a/b;En resultado se asignará 2.

% Módulo de la división, nos provee el resto de la misma.

resultado = a%b;En resultado se asignará 0.

Antes de comenzar con un ejemplo de operaciones aritméticas, es importante destacar la precedencia de los operadores dentro de operaciones aritméticas complejas.

En el caso de esta expresión “total = 2 * 5 – 6”, podemos inferir que el resultado sea 4 (si hacemos 2 * 5 y luego le restamos 6) o -2 (si hacemos 5 menos 6 por 2), para salvar lo visto, el orden de operación que indica el compilador del lenguaje C# es el siguiente:

1º 2 º 3 º 4 º 5 º

* / % + -

Y en caso de querer cambiar el orden de ejecución de las operaciones, tendremos que utilizar el paréntesis (). Este nos ayudará a crear las expresiones aritméticas que necesitemos para resolver nuestros cálculos. Pues el paréntesis precede a todos los demás operadores.

Observen las expresiones y sus resultados que he dispuesto como ejemplos.

Resultado= 4 * 3 + 10 = 22Resultado= 4 * (3 + 10) = 42

Ingresemos el nuevo ejemplo, codificando diferentes casos de operaciones aritméticas:


namespace operacionesaritmeticas{ class Program { static void Main(string[] args) { // declaracion e inicio de variables. float a, b, resultado; a = 10; b = 5; resultado = 0; //suma resultado=a+b; Console.WriteLine("la suma de 10 + 5 es {0}", resultado); //resta resultado = a - b;


Console.WriteLine("la resta de 10 - 5 es {0}", resultado); //multiplicacion resultado = a * b; Console.WriteLine("la multiplicacion de 10 * 5 es {0}", resultado); //division resultado = a / b; Console.WriteLine("la division de 10 / 5 es {0}", resultado); //modulo resultado = a % b; Console.WriteLine("El modulo entre 10 % 5 es {0}", resultado); } }}

Debería verse de la siguiente manera por consola:

El ingreso de Datos, el método ReadLine()

Hasta el momento, los valores que hemos utilizados estaban en el código del programa, a partir de ahora, con el método ReadLine(), el usuario podrá ingresar el dato que desee para realizar las operaciones que correspondan.

No hace falta incluir ningún parámetro en sus paréntesis, si deberán tener en cuenta, que siempre devuelve una cadena de caracteres. Esta cadena se deberá inmediatamente asignar a una variable creada por nosotros, además de convertirla en el tipo de dato necesaria para poder operar, caso contrario, se perderá el valor ingresado o aparece un mensaje de error.

Su estructura es la siguiente:

nombre = Console.ReadLine();

Veamos un ejemplo para ver como funciona.

En este ejemplo, podemos ingresar nuestro nombre por teclado, y luego visualizarlo por consola, junto con mensaje adicional.



namespace metodoreadline{ class Program { static void Main(string[] args) { string nombre = ""; Console.Write("Escriba su nombre: "); nombre = Console.ReadLine(); Console.WriteLine("Hola {0} como esta usted.", nombre); } }}

Visualización por consola:

Conversión del tipo de Variables.

Tal vez, ya hemos notado que el método ReadLine(), nos presenta una limitación, pues, solo nos devuelve una cadena de caracteres, no permitiéndonos realizar operaciones de tipo aritméticas. Para salvar esta situación, deberemos convertir la cadena ingresada a un tipo de dato numérico.

C#, nos provee de una clase, llamada Convert. Y para ser uso de la misma; deberé referirme a la conversión entre diferentes tipos de variables, al momento de programar, utilizaremos para esta tarea los métodos que detallo a continuación:

Clase: ConvertMétodo Conversión que realiza

ToInt32() Convierte de string a int.ToSingle() Convierte de string a Float.ToBoolean() Convierte de string a Booleana

Un ejemplo del uso de esta clase Convert y utilizando el método ToInt32, es el siguiente:

a=Convert.ToInt32(entrada);


Ahora veámoslo, en un ejemplo completo:

Realizar un programa, que incremente, el sueldo de un empleado, en función de un porcentaje dado.

Se deberá ingresar los datos del empleado (nombre, sueldo y porcentaje de aumento) y mostrarlos por consola.


namespace conversionvariables{ class Program { static void Main(string[] args) { string entrada = ""; string nombre = ""; float sueldo = 0.00f; float porcentajeaumento = 0.00f; Console.Write("Escriba el nombre del empleado: "); nombre = Console.ReadLine(); Console.Write("Ingrese el Sueldo: "); entrada = Console.ReadLine(); sueldo = Convert.ToSingle(entrada); Console.Write("Ingrese el Porcentaje de Aumento: "); entrada = Console.ReadLine(); porcentajeaumento = Convert.ToSingle(entrada); sueldo = sueldo * (1 + (porcentajeaumento / 100)); Console.WriteLine("El Empleado {0} debera cobrar {1} .", nombre,sueldo); } }}

Una vez que lo hemos ejecutado el programa, su visualización es la siguiente:

Metodología para la resolución de problemas por computadora.


El método más adecuado, para resolver problemas utilizando el lenguaje C# de .Net, es el lenguaje Orientado a Objetos, sin embargo utilizaremos al inicio de este manual, la metodología estructurada, con el objetivo de obtener conocimientos de los métodos que vamos a usar y mayor experiencia en la resolución de problemas, y luego con estos buenos antecedentes, encarar la Orientación a Objetos con mayor seguridad.

La metodología estructurada, se basa en el concepto de la subdivisión del problema a resolver. Es decir que tomamos el problema general y lo dividimos en problemas más pequeños o sub-problemas, hasta que lo podamos resolver directamente.

Los pasos que debemos seguir son:

Entender el problema. Reconocer los datos que estarán en juego. Armar el algoritmo. Pasar el código con el lenguaje que estemos utilizando a la

computadora. Ejecutarlo. En caso de error, corregir.

Empecemos por resolver un problema sencillo y fácil de entender.

Confeccionemos un programa, para el cálculo del área y del perímetro de un rectángulo.

La primera etapa era entender el problema por lo tanto, debemos abocarnos a la tarea de entender el problema, y luego, ya lo podemos subdividir.

Luego de pensar un rato, me ha quedado de la siguiente manera.


Me he ayudado, para visualizar mejor la solución de este problema, la utilización de una estructura de tipo organigrama, pues se ajusta perfectamente a nuestro análisis.

Un organigrama es un modelo abstracto y sistemático, que permite obtener una idea uniforme acerca de la estructura formal o problema. Lo representamos con bloques relacionados de con un orden de importancia de arriba hacia abajo y de izquierda a derecha.

El paso siguiente, es el de reconocer los datos para nuestro ejemplo, a continuación los detallo:

Nombre de la variable Tipo Inicializaciónarea Float 0.0

perimetro Float 0.0ancho Float 1.0

alto Float 1.0valor String “”

El paso que sigue, es el del armado del algoritmo que se deduce del análisis realizado con el organigrama. Para ello utilizaremos la siguiente simbología o pseudocódigo:

Inicio Pedir ancho Pedir alto area = ancho*alto perimetro = 2*(ancho*alto) mostrar area mostrar perímetro Fin

Calculo de Area y Perimetro del Rectangulo

Pedir Datos

Pedir ancho

Pedir alto

Calcular Area

Calcular Perimetro

Mostrar Resultados

Mostrar Area

Mostrar Perimetro


Lo vemos en un lenguaje o idioma, donde solo destacamos las directivas que deberán realizarse.

Y ahora ya podemos crear el código de nuestra aplicación.

Realizar un programa, donde le usuario ingrese el alto y ancho de un rectángulo, y luego, determine y muestre el resultado de su área y perímetro.


namespace areaperimetrorectangulo{ class Program { static void Main(string[] args) { // declaramos las variales que necesitamos float area = 0.0f; float perimetro = 0.0f; float ancho = 0.0f; float alto = 1.0f; string valor = ""; Console.Write("Ingrese el Ancho: "); valor = Console.ReadLine(); ancho = Convert.ToSingle(valor); Console.Write("Ingrese el Alto: "); valor = Console.ReadLine(); alto = Convert.ToSingle(valor); area = ancho * alto; perimetro = 2 * (alto + ancho); Console.WriteLine("El Area es {0}", area); Console.WriteLine("El Perimetro es {0}", perimetro);

} }}

En la consola vemos:


En resumen, para programar una computadora, necesitaremos conocer un lenguaje de programación y una metodología correcta para la resolución de los problemas que se nos van a presentar. En nuestro caso el lenguaje C# es el indicado y como metodología estamos viendo la programación estructura para luego; y sin problemas, adoptar la programación orientada a objetos.



1. Realizar un programa, que calcule la superficie y el perímetro de un círculo. (se sabe que la Superficie= pi * radio al cuadrado y el Perímetro =2 pi * radio). Valor de pi=3,14

2. Hacer un programa, que convierta centímetros en pulgadas. (1 pulgada = 2,5 centímetros).

3. Generar una aplicación, que convierta la moneda pesos en dólares. El usuario deberá ingresar el monto en pesos y la cotización del día del dólar (u$s) y por consola el sistema deberá mostrar la conversión.

4. Una empresa necesita un programa que calcule el sueldo neto de un empleado. Para esto, el usuario deberá ingresar el nombre del empleado, el sueldo bruto, el descuento y la bonificación. Para finalizar se deberá mostrar el resultado por la consola.



1. Código fuente de la resolución del problema número 1 es:


namespace solucion1{ class Program { static void Main(string[] args) { // declaracion e inicializacion de variables. float pi = 3.14f; float radio = 0.0f; float superficie = 0.0f; float perimetro = 0.0f; string cadena = ""; Console.WriteLine("Cálculo de la superficie y Périmetro de un Círculo."); Console.Write("\n\nIngrese el Radio del Círculo: "); cadena = Console.ReadLine(); radio = Convert.ToSingle(cadena); superficie = pi * (radio * radio); perimetro = 2 * pi * radio; Console.WriteLine("\n La superficie es: {0} \n El Périmetro es: {1}",superficie,perimetro); } }}

La visualización por consola es:

2. La solución a este problema, es la siguiente:



namespace solucion2{ class Program { static void Main(string[] args) {

// declaracion e inicializacion de variables float medidacentimetros = 0.0f; float medidapulgadas = 0.0f; float pulgada = 2.5f; string cadena = ""; Console.WriteLine("Conversión de Centímetros a Pulgadas."); Console.Write("\n\n Ingrese los centimetros: "); cadena = Console.ReadLine(); medidacentimetros = Convert.ToSingle(cadena); medidapulgadas = medidacentimetros / pulgada; Console.WriteLine("\n\n {0} centimetros son {1} pulgadas.",medidacentimetros,medidapulgadas); } }}

Su visualización debería quedar así:

3. El código del tercer problema a resolver es el siguiente:


namespace solucion3{ class Program { static void Main(string[] args) { // declaracion e inicialzacion de la variables float pesos = 0.0f; float dolares = 0.0f; float cotizacion = 0.0f; string cadena = "";

Console.WriteLine("Conversión de Peso ($) a Dolar (u$s)."); Console.Write("\n\n Ingrese la Cotizacion del Dolar: "); cadena = Console.ReadLine(); cotizacion = Convert.ToSingle(cadena);


Console.Write("Ingrese la Cantidad en Pesos: "); cadena = Console.ReadLine(); pesos= Convert.ToSingle(cadena); dolares = pesos / cotizacion; Console.WriteLine("\n{0} Pesos son {1} dolares.",pesos,dolares); } }}

Por consola se debe ver lo siguiente:

4. La respuesta al último problema es la siguiente:


namespace solucion4{ class Program { static void Main(string[] args) {

// declaracion e inicialzacion de la variables string nombre = ""; float sueldobruto = 0.0f; float descuento = 0.0f; float bonificacion = 0.0f; float sueldoneto = 0.0f; string cadena = ""; Console.WriteLine("Calculo de un Sueldo Neto de un Empleado."); Console.Write("\n\n Ingrese el Nombre del Empleado: "); cadena = Console.ReadLine(); nombre = cadena; Console.Write("\nIngrese el sueldo Bruto: "); cadena = Console.ReadLine(); sueldobruto= Convert.ToSingle(cadena); Console.Write("\nIngrese la Bonificacion: "); cadena = Console.ReadLine(); bonificacion = Convert.ToSingle(cadena); Console.Write("\nIngrese el Descuento: "); cadena = Console.ReadLine(); descuento = Convert.ToSingle(cadena); sueldoneto = sueldobruto+bonificacion-descuento; Console.Write("\n\n*******************************"); Console.WriteLine("\n Empleado: {0}\n Sueldo Neto a cobrar: {1}.",nombre,sueldoneto);


Console.WriteLine("*******************************"); } }}

Por consola:


Unidad 3

Toma de Decisiones.


No todos los problemas que tengamos que resolver, podremos utilizar una solución del tipo lineal. A veces, el programa deberá tomar una decisión, frente a una o más alternativas, y luego ejecutar una o varias sentencias de la opción que se ha elegido.

Por ejemplo, si hace mucho frio nos podemos poner una campera abrigada para salir a nuestro trabajo, otra opción podría ser ponernos un buzo. Es decir, que necesitamos que exista una condición para poder tomar una decisión. En el lenguaje C#, se provee la posibilidad de crear expresiones relacionales y expresiones lógicas, que se evaluarán, y en función del resultado de esa evaluación, se llevaran a cabo ciertas sentencias o no, en función del algoritmo que conforma nuestro programa.

Operadores Relacionales

A los operadores relacionales, los necesitaremos para expresar la relación que existen entre dos valores. Estos valores, pueden ser expresados en forma explícita (Ejemplo: 5, 12.4, -3) o implícita, por medio de variable (Ejemplo: nombre, sueldo). Las expresiones que se conforman con los valores y los operadores relacionales se evalúan, y nos dan un resultado, este puede ser Verdadero o Falso (True o False).

Los operadores relaciones son:

Signo Operador Ejemplo resultado

== Igualdad 5==54==(1-5)

TrueFalse

!= No igual 6!=58!=(2*4)

TrueFalse

> Mayor 6>-1(2-10)>11

TrueFalse

< Menor (2-3)<710<2

TrueFalse


>= Mayor e igual (10*2)>=2012>=20

TrueFalse

<= Menor e igual 18<=(40*3)16<=5

TrueFalse

La Decisión (If).

En el lenguaje C#, tenemos un tipo de estructuras, denominadas selectivas.

Las estructuras selectivas, son aquellas que nos permiten seleccionar, un camino, entre 2 o más caminos posibles. Cada uno de estos caminos, puede poseer o no sentencias para ser ejecutadas por el compilador del lenguaje. La selección del camino a seguir, se lleva a cabo luego de evaluar una expresión relacional o una variable y obtener el resultado (verdadero o falso).

Una de las estructuras selectivas que posee C#, es el “si” condicional, materializado en la sentencia If(), cuya estructura es la siguiente:

If (expresión)Sentencia a ejecutar;

En expresión, se presentará las expresiones relacionales, cuyo resultado; como ya lo he dicho, solo puede ser Verdadero o Falso.

Un ejemplo:

If(valor>5)Valor=valor*15; En caso de ser falsa la expresión, se ignorará las sentencias a ejecutar.

Veamos un ejemplo:

Evaluar el ingreso de un número, indicando si es positivo o negativo.


namespace positivonegativo{ class Program { static void Main(string[] args) { // inicializacion de variables int numero = 0;


string valor = ""; Console.Write("Ingrese un Numero: "); valor = Console.ReadLine(); numero=Convert.ToInt32(valor); if (numero>=0) Console.WriteLine("El valor {0} es positivo",numero); if (numero < 0) Console.WriteLine("El valor {0} es negativo", numero);

} }

}

En este ejemplo he usado 2 decisiones (If), el número ingresado por el usuario, será evaluado en ambas, pero solo ejecutará las sentencias, donde el resultado de la evaluación se considere verdadera (true).

Hasta el momento, solo hemos ejecutado una sola sentencia, si quisiéremos que el compilador ejecute un Bloque de Código (varias sentencias agrupadas) la estructura sería la siguiente:

If (expresión){

Sentencia 1;Sentencia 2;Sentencia 3;…Sentencia n;

}

Un ejemplo para este caso, es el que detallo a continuación:

Ingresar el sueldo de un empleado, e incrementarlo en un 10%, si este es menor a 1000$.


namespace sueldoaumento// aumento de un 10% para los sueldos menores a 1000${ class Program { static void Main(string[] args) { Double sueldo = 0.00; string valor = ""; Console.Write("Ingrese el Sueldo de un Empleado:"); valor = Console.ReadLine(); sueldo = Convert.ToDouble(valor); if (sueldo < 1000) { sueldo = sueldo * 1.1;


Console.WriteLine("El sueldo Incrementado en un 10% es {0}", sueldo); } } }

}

El uso del Else (sino)

En los problemas anteriores solo se han ejecutado las sentencias, si la expresión era verdadera, pero es muy común frente a una decisión, tener que realizar alguna tarea si esta es falsa; para esto, ampliamos la sentencia If con el Else.

Esta es la nueva estructura:

If (expresión)Sentencia;

elseSentencia;

En caso de utilizar un Bloque de Código, la estructura se conforma del siguiente modo.

If (expresión){Sentencia 1;Sentencia 2;…Sentencia n;}

else{Sentencia 1;Sentencia 2;…Sentencia n;}

Realizaremos un ejemplo, para cada uno de los casos, con solo una sentencia y con un bloque de código.


Para el primer caso – con solo una sentencia para ejecutar - , el problema a resolver es el siguiente:

Ingresar un valor entero, e indicar si es par o impar.


namespace paroimpar{ class Program { static void Main(string[] args) { int numero = 0; string valor = ""; Console.Write("ingrese un valor entero:"); valor=Console.ReadLine(); numero = Convert.ToInt32(valor); // decision - utilizamos el operador de modulo % if (numero%2==0) Console.WriteLine("el valor {0} es par", numero); else Console.WriteLine("el valor {0} es impar", numero); } }}

Para probar el if else, con un bloque de código, construiremos el siguiente caso:

Ingresar 2 valores, y obtener el cociente de ambos. (Tener en cuenta, que no existe en el campo de los números reales, la división por 0 (cero)).


namespace obtenercociente{


class Program { static void Main(string[] args) { float dividendo = 0.0f; float divisor = 0.0f; float cociente = 0.0f; string valor = ""; Console.Write("ingrese el valor del dividendo:"); valor = Console.ReadLine(); dividendo = Convert.ToInt32(valor); Console.Write("ingrese el valor del divisor:"); valor = Console.ReadLine(); divisor = Convert.ToInt32(valor);

if (divisor != 0) { cociente = dividendo / divisor; Console.WriteLine("el cociente entre {0} y {1} es {2}", dividendo, divisor, cociente); } else { Console.WriteLine("No se puede obtener un Cociente."); Console.WriteLine("NO se puede dividir por 0."); }

} }}

Decisiones anidadas.

En un bloque de código pueden ir todo tipo de instrucciones, por lo tanto puede existir otra decisión, es decir que nos podemos encontrar con una decisión dentro de una decisión (Un If dentro de otro If), esto se denomina decisiones anidadas. No nos resultará ningún problema, si respetamos las estructuras que hemos visto y además nos cuidamos de los errores lógicos; que como programadores, podemos llegar a cometer frente a un análisis mal hecho.


Una de la maneras de resolver el problema, de ingresar 3 números enteros e indicar cúal es el mayor, puede ser la siguiente. (utilizaremos if anidados).

Para resolver este problema vamos a hacer uso de una variable auxiliar denominada mayor.


namespace numeromayordetres{ class Program { static void Main(string[] args) { int a = 0; int b = 0; int c = 0; int mayor = 0; string valor = ""; // ingreso de numeros a, b y c Console.Write("ingrese el valor de a:"); valor = Console.ReadLine(); a = Convert.ToInt32(valor); Console.Write("ingrese el valor de b:"); valor = Console.ReadLine(); b = Convert.ToInt32(valor); Console.Write("ingrese el valor de c:"); valor = Console.ReadLine(); c = Convert.ToInt32(valor); if (a > b) { if (a > c) { mayor = a; Console.WriteLine("el valor mayor entre {0} ,{1} y {2} es {3}", a, b, c, mayor); } else { mayor = c; Console.WriteLine("el valor mayor entre {0} ,{1} y {2} es {3}", a, b, c, mayor); } } else { if (b > c) { mayor = b; Console.WriteLine("el valor mayor entre {0} ,{1} y {2} es {3}", a, b, c, mayor); } else { mayor = c;


Console.WriteLine("el valor mayor entre {0} ,{1} y {2} es {3}", a, b, c, mayor); } } } }}

Expresiones lógicas.

C# tambien posee operadores lógicos, utilizados, para el armado de expresiones lógicas. Ellos son:

Operador Significado Ejemplo Resultado&& Y (conjuncion) (5==5) && (5<10) True|| O (disyuncion) (-2=4) || (7>10) False! No !(9=9) False

Para obtener los resultados de una operación lógica, tendrán que hacer uso de las tablas lógicas.

Las que deben conocer, son las de conjunción, disyunción y negación.

Aquí las desarrollo, para que luego podamos darles uso en los programas.

p Q p&&q p||q !(p)True True True True FalseTrue False False True FalseFalse True False True TrueFalse False False False True

Podemos ejemplificar lo visto, con el siguiente programa.

Realizar un programa, que nos indique si una persona está habilitada para conducir automóviles. Para eso, deberá tener la edad suficiente; mayor de 18 años. En caso de ser menor de 18 y mayor de 16, podrá conducir con el permiso de los padres.



namespace expresioneslogicas{ class Program { static void Main(string[] args) { int edad = 0; bool permiso = false; bool habilitado = false; string valor=""; Console.Write("Ingrese la edad: "); valor = Console.ReadLine(); edad=Convert.ToInt32(valor);

if (edad >= 18) { habilitado = true; } else { Console.Write("Posee Permiso de sus Padres: "); valor = Console.ReadLine(); permiso = Convert.ToBoolean(valor); if (((edad >= 16) && (edad < 18)) && (permiso == true)) { habilitado= true; } else { habilitado = false; } } if (habilitado == true) Console.WriteLine("Esta habilitado para conducir."); else Console.WriteLine("NO, esta habilitado para conducir.");

} }}

Switch


La sentencia Switch, es otra estructura selectiva que se utiliza en el lenguaje de C# de .NET. La particularidad de este, es que permite tomar una opción de varias, dependiendo del valor de una variable.

El valor de la variable, se compara con los diferentes casos que hemos armado en la estructura selectiva, en caso de coincidir, se ejecutará el Bloque de Código que pertenece a esa opción. Si la variable no ha encontrado ninguna opción, se puede poner al final una opción por defecto denominada Default.

Para indicar el final dentro de un bloque de código, utilizaremos la sentencia Break. Esta nos permitirá salir de la estructura selectiva Switch en la cual está trabajando, en caso contario seguirá analizando las opciones siguientes hasta el final.

La estructura de Switch, es la siguiente:

switch (opción){Case 1:Sentencias;Break;

Case 2:Sentencias;Break;

Case n:Sentencias;Break;

Default:Sentencias;Break}

El Switch es utilizado a menudo, en aquellos programas donde necesitamos armar un menú, con diferentes opciones.

Crear un programa, que el usuario pueda ingresar 2 valores y le permita elegir la opción de cómo operar dichos valores; entre ellas, de sumar, restar o salir.


namespace menuswitch{ class Program {


static void Main(string[] args) { int a = 0; int b = 0; int opcion = 0; int resultado = 0; string valor=""; Console.Write("Ingrese un valor: "); valor = Console.ReadLine(); a = Convert.ToInt32(valor); Console.Write("Ingrese otro valor: "); valor = Console.ReadLine(); b = Convert.ToInt32(valor); // armado del menu de opciones Console.WriteLine("1 - Suma"); Console.WriteLine("2 - Resta"); Console.WriteLine("3 - Salir"); Console.Write("Ingrese la opcion deseada: "); valor = Console.ReadLine(); opcion = Convert.ToInt32(valor); switch (opcion) { case 1: resultado = a + b; Console.WriteLine("la suma de {0} mas {1} es {2}", a, b, resultado); break; case 2: resultado = a - b; Console.WriteLine("la resta de {0} menos {1} es {2}", a, b, resultado); break; case 3: Console.WriteLine("Sale del Programa"); break;

default: Console.WriteLine("Ha ingresado una opción no válida"); break; }

} }}


En esta unidad, hemos vistos estructuras selectivas que les permitirán a nuestros programas la toma de decisiones. Es fundamental, la práctica intensiva de estas sentencias, pues involucra el uso de expresiones relacionales y lógicas que el programador debe usar con suma confianza para la complejidad de las aplicaciones que desarrollará en el futuro.



1. El usuario deberá Ingresar un valor, y determinar si este es par o impar.

2. Crear un programa, que permita realizar un descuento del 10%, de un importe si este supera los 2000$. Dicho importe debe ser ingresado por el usuario del sistema.

3. Hacer un programa, donde el usuario, pueda ingresar un valor del 1 al 7, y el sistema indique el día de la semana que le corresponde en función de su posición (ejemplo 1 – lunes, 2-martes, etc.).



1. Código del primer problema a desarrollar.


namespace solucion1{ class Program { static void Main(string[] args) { /* El usuario deberá Ingresar un valor, y determinar si este es par o impar */ int valor = 0; Console.Write("Ingrese un valor: "); valor = Convert.ToInt32(Console.ReadLine()); if (valor % 2 == 0) { Console.WriteLine("El valor {0} es Par.",valor); } else { Console.WriteLine("El valor {0} es Inpar.", valor); }

} }}

Muestra por consola

2. El código es:


namespace solucion2


{ class Program { static void Main(string[] args) { /* *Crear un programa, que permita realizar un descuento * del 10%, de un importe si este supera los 2000$. * Dicho importe debe ser ingresado por el usuario del * sistema. */ float importe = 0.0f; int descuento = 20; Console.Write("Ingrese el Importe: "); importe = Convert.ToSingle(Console.ReadLine()); if (importe >= 2000) { importe = importe - (importe * descuento / 100); } Console.WriteLine("El importe a abonar es: {0}",importe); } }}

Por consola nos da:

3. El último problema lo he resuelto de la siguiente manera.


namespace solucion3{ class Program { static void Main(string[] args) { /* Hacer un programa, donde el usuario, pueda ingresar * un valor del 1 al 7, y el sistema indique el día de * la semana que le corresponde en función de su posición * (ejemplo 1 – lunes, 2-martes, etc.). */ int valor = 0; Console.Write("Ingrese un valor (1 a 7): "); valor =Convert.ToInt32( Console.ReadLine()); switch (valor) { case 1: Console.WriteLine("LUNES");


break; case 2: Console.WriteLine("MARTES"); break; case 3: Console.WriteLine("MIERCOLES"); break; case 4: Console.WriteLine("JUEVES"); break; case 5: Console.WriteLine("VIERNES"); break; case 6: Console.WriteLine("SABADO"); break; case 7: Console.WriteLine("DOMINGO"); break; default: Console.WriteLine("Error en el ingreso del Valor."); break; } } }}

Por consola debemos ver.


Unidad 4

Los Ciclos.


En nuestra vida hay tareas semejantes, que las realizamos en forma reiterada durante día, en la semana, etc. Me atrevo hacer algunas referencias como, desayunar, algún deporte en forma semanal, la concurrencia a nuestras escuelas o trabajos; donde tomamos el mismo colectivo, a la misma hora, etc., es decir que tenemos las actividades casi estandarizadas.

En nuestras aplicaciones, también, habrá sentencias que deberán ejecutarse en forma repetitiva. Para estos casos, vamos a ver en C#, algunas estructuras de suma utilidad. Entre ellas el ciclo for (para), while (mientras), etc.

Ciclo Para (For).

El primer ciclo que aprenderemos, es el ciclo For (en inglés significa para). Este ciclo lo utilizaremos, cuando tengamos definido, la cantidad de reiteraciones del Bloque de Código que tengamos que realizar.

La estructura de esta sentencia es la siguiente.

For (inicialización ; condición ; incremento){

Bloque de código}

Analizaremos cada uno de las partes, que conforma la estructura del ciclo For, en el orden que el compilador las interpreta:

El orden es el siguiente, Inicialización, condición, bloque de código y por último el incremento.

Inicialización: se le da un valor inicial a la variable que va a controlar el bucle. La inicialización se realizara como una asignación normal,


ejemplo: n=1. Hay que realizar la asignación de la variable antes del bucle.

Condición: en esta sección debe ir una operación relacional. Esta, va a controlar cuando termina el bucle, ejemplo: n<=20. Seguirá en el bucle mientras n sea menor o igual que 20.

Bloque de código: aquí irán, las instrucciones (cualquier sentencia en C#) que se realizarán mientras se cumpla el ciclo.

Incremento: indicamos como se modificará el valor de la variable de control (inicializada en el primer punto) para cada vuelta del ciclo, ejemplo: n=n+1

El funcionamiento es el siguiente:

Al ejecutarse un bucle For, lo primero que se lleva a cabo es la inicialización de la variable de control y luego la condición. Si la condición es verdadera (true), se pasa al código y por último, se produce el incremento e la variable de control. En caso que la condición sea falsa (False), se salta el bloque de código y continua con las sentencias siguientes del programa.

Empezaremos con un ejemplo sencillo, para ver como funciona el bucle definido For.

Realizar un programa, que permita mostrar los primeros 10 numero naturales (1, 2, 3,…. 10).


namespace numerosnaturales{ class Program { static void Main(string[] args) { int n = 0; // inicializando la variable de control Console.WriteLine("Comienza el bucle"); for (n = 1; n <= 10; n = n + 1) { Console.WriteLine("{0}",n); } Console.WriteLine("finaliza el bucle"); } }}


Podemos también probar; con las siguientes modificaciones, el ciclo For que les muestro a continuación:

Inicializamos con -10 y mostrará los números enteros entre los valores -10 y 10.

for (n = -10; n <= 10; n = n + 1) { Console.WriteLine("{0}",n); }

En caso que muestro a continuación, he cambiado la variable de control, y he modificado el incremento. En este caso va en decremento y muestra los valores desde 100 hasta 0.

for (n = 100; n >= 0; n = n - 1) { Console.WriteLine("{0}",n); }

En este último caso, se mostrará los valores entre 1 y 10 pero en dos en dos.

for (n = 1; n <= 10; n = n + 2) { Console.WriteLine("{0}",n); }

Por pantalla se visualiza lo siguiente:


Contadores y Acumuladores.

Hay 2 conceptos muy importantes y necesarios a la hora de programar, ellos son los contadores y los acumuladores.

El contador, es un variable que tiene la capacidad de incrementar o disminuir su valor en uno.

Un ejemplo:

n=n+1;

Si quisiéramos saber cuántos alumnos hay en un curso, deberíamos contarlos, por lo tanto, haríamos uso de un contador.

En cambio el acumulador, también es una variable pero, permite incrementar o disminuir su valor en cualquier número.

Un ejemplo:

Sueldo = sueldo+500;

Un caso posible, es aquel, si tenemos que sumar lo recaudado por un local de ventas en un día, para determinarlo, deberíamos hacer uso de un acumulador.

Apliquemos lo que hemos aprendido en un ejemplo.

Procesar los primeros 100 números naturales, he indicar cuantos pares hay y sumar la totalidad de los valores.


namespace contadoracumulador{


class Program { static void Main(string[] args) { int n = 0; // inicializando la variable de control int cuentapares = 0; int acumulatodo = 0; Console.WriteLine("Comienza el bucle"); for (n = 1; n <= 100; n = n + 1) { if (n % 2 == 0) cuentapares = cuentapares + 1; // contador acumulatodo = acumulatodo + n; // acumulador

} Console.WriteLine("Existen {0} pares.", cuentapares); Console.WriteLine("La suma de todos los valores es {0}",acumulatodo);

} }}

En C# tenemos unos contadores especiales, denominados, operador de incremento (++) y operador de decremento (--). Estos serán usados, como sufijos o prefijos de la siguiente manera.

Contador Sufijo prefijon=n+1 n++ ++nn=n-1 n-- --n

En el caso de que el operador actúe como sufijo, evaluará la expresión, con el valor actual de la variable y luego incrementará la variable.

En cambio cuando usamos el prefijo, primero se incrementa y luego se evalúa la expresión.

¡Puedo ver la cara de ustedes!Vamos con un ejemplo, que aclare lo enunciado:



namespace sufijoprefijo{ class Program { static void Main(string[] args) { int numero = 10; Console.WriteLine("valor inicial: {0}", numero); Console.WriteLine("el valor incial con numero++: {0}", numero++); Console.WriteLine("valor inicial luego de numero++: {0}", numero); Console.WriteLine("el valor con ++numero: {0}", ++numero); } }}

Hay otros operadores de suma utilidad, que paso a detallar:

Acumulador Operador Ejemplonumero=numero+5 += numero+=5numero=numero-5 -= numero-=5numero=numero*5 *= numero*=5numero=numero/5 /= numero/=5

Resolvamos el siguiente problema. Se desea determinar el promedio general y el de cada alumno de un curso de un establecimiento educativo. Se sabe, que el curso está compuesto por 5 alumnos, y cada alumno posee 3 notas.

Aclaración. En este caso podemos aplicar un bucle que tenga en cuenta los 5 alumnos, y también, sería bueno aplicar otro bucle para ingresar las 3 notas de cada alumno.


namespace promedioalumnos{ class Program


{ static void Main(string[] args) { // inicializacion y asginacion de variables int cantidadalumno=0; int cantidadnotas = 0; float nota = 0.0f; float acumulanotaalumnos = 0.0f; float acumulapromedio = 0.0f; float promediototal = 0.0f; float promedioalumno = 0.0f; string valor = ""; // controla la cantidad de alumnos for (cantidadalumno = 1; cantidadalumno <= 5; cantidadalumno++) { Console.WriteLine(" **** Calculo del Promedio del Alumno {0} **** ",cantidadalumno); acumulanotaalumnos = 0; // controla la cantidad de notas for (cantidadnotas = 1; cantidadnotas <= 3; cantidadnotas++) { Console.Write("Ingrese la {0} nota del alumno: ",cantidadnotas); valor = Console.ReadLine(); nota = Convert.ToSingle(valor); acumulanotaalumnos = acumulanotaalumnos + nota;

} // muestra solo el promedio del alumno promedioalumno = acumulanotaalumnos / 3; Console.WriteLine("El promedio del Alumno es: {0}", promedioalumno); acumulapromedio = acumulapromedio + promedioalumno; } // muestra el promedio Total promediototal = acumulapromedio / 5; Console.WriteLine(" **************************************************** ", promediototal); Console.WriteLine(" **** El promedio General de los Alumnos es: {0} **** ", promediototal); } }}


Ciclo Mientras (Do While).

Cuando estudiamos el ciclo For, indique que era un bucle definido, pues sabíamos de antemano, cuantas veces se iría a realizar el proceso.

Pero, existen problemas, donde el número de bucle a realizarse se desconoce, para estos casos usaremos el bucle indefinido While (mientras). Es decir que el bucle, se va realizar, mientras se cumpla una expresión relacional, y esta sea verdadera.

El ciclo Do While, posee la siguiente estructura:Do{Bloque de Código;} While (condición);

Vemos, que esta estructura de Do While, realiza la evaluación al final, por lo tanto, ya sea esta verdadera o falsa, siempre se ejecutará el bloque de código, al menos una vez. En caso que sea falsa saldrá del bucle, y en caso contrario, de que sea verdadera, saltará al inicio del bucle donde esta Do.

En resumen, se garantiza la entrada al bucle.

Vamos a resolver un problema de conversión de unidades métricas, para ver como funciona el bucle Do While.

El usuario ingresará una medida en pulgadas y deseará saber, a cuantos centímetros equivale. Al final, se le deberá preguntar al usuario si quiere seguir trabajando con el sistema (de esta forma, le permitimos al usuario, que ejecute el programas las veces que este quiera).



namespace conversionpulgadacentimetros{ class Program { static void Main(string[] args) { string opcion = "n"; string valor = ""; float medidapulgada = 0.0f; float medidacentimetro = 0.0f; // comienza el bucle Do While do { Console.Write("Ingrese su medida en Pulgadas:"); valor = Console.ReadLine(); medidapulgada = Convert.ToSingle(valor); medidacentimetro = medidapulgada * 2.54f; Console.WriteLine("{0} pulgadas es igual a {1} centimetros.",medidapulgada,medidacentimetro); Console.Write("Desea continuar s/n ..."); opcion = Console.ReadLine();

}while (opcion=="s"); // finaliza el ciclo Do While } }}

Ciclo Mientras (While).

Habiendo visto y comprendido el bucle Do While, estamos en condiciones de ver el bucle While. Se asemeja al Do While, pero difiere, que este realiza la evaluación al principio de una expresión lógica, por lo tanto puede ocurrir que el bloque de código, nunca se ejecute si la evaluación es Falsa. Su estructura es así:

While (condición);{Bloque de Código;}


Aplicaremos el bucle While, en un programa.

Realizar un programa que disminuya en 1 en 1 la temperatura de una piscina hasta 23 grados y lo muestre. Dicho proceso se realiza, siempre que la temperatura ingresada por el Usuario, sea mayor de 23 grados.


namespace temperatura{ class Program { static void Main(string[] args) { int temperatura = 0; string valor = ""; Console.Write("Ingrese la Temperatura de la Piscina: "); valor = Console.ReadLine(); temperatura = Convert.ToInt32(valor); while (temperatura > 23) { temperatura = temperatura - 1; Console.WriteLine("La temperatura es {0}",temperatura); }

} }}

Al igual que el If, los bucles (For, Do While y While) pueden estar anidados, siempre y cuando respetemos las estructuras de cada uno de ellos, y para eso, deberán prestar mucha atención, en el momento de confeccionar los programas.


En resumen, los ciclos que hemos visto, nos permiten optimizar aquellos programas que poseen un bloque de código que se deba repetir. En el caso del For nos permite repetir un bloque un número determinado de veces, bajo la inspección de una variable de control.

En cambio el ciclo Do While, nos permite repetir el código un número indeterminado de veces, dependiendo de una relación lógica. Es importante tener en cuenta, que al menos una vez se ejecutará el bloque de instrucciones.

El ciclo While, también debe evaluar una expresión lógica, pero a diferencia de Do While lo realiza al inicio del bucle. Eso puede provocar que nunca se realice el bucle; por ende no se ejecute el bloque de código, dependiendo del resultado de la relación lógica.



1. Calcular el factorial de un número. Recordamos que el factorial de 0 y de 1 es 1, y el resto de los valores naturales se calculan, multiplicando todos los valores desde 1 hasta el valor que deseamos saber su factorial. Un ejemplo del factorial de 5 es: 5!=5*4*3*2*1=120

2. Hacer un programa donde se ingrese un valor y mostrar la tabla de multiplicar del mismo, con el producto del mismo con el valor 1 al 12.

3. Hacer un programa que encuentre los valores primos entre 1 y 500.

4. Un globo aerostático en ascenso, toma el valor de la temperatura en 10 oportunidades, determinar:Temperatura promedio.Temperatura mayor.



1. Para la solución del primer problema, he desarrollado el siguiente código.


namespace solucion1{ class Program { static void Main(string[] args) { // Calcular el factorial de un número // declaracion de variables int valor = 0; int n = 0; int factorial = 1; Console.Write("Ingrese el valor: "); valor = Convert.ToInt32(Console.ReadLine()); for (n = 1; n <= valor;n++ ) { factorial=factorial*n; } Console.WriteLine("El factorial de {0} es {1}.", valor, factorial); } }}

La vista por consola es:


2. El código del siguiente problema es:


namespace solucion2{ class Program { static void Main(string[] args) { /*Hacer un programa donde se ingrese un valor y mostrar la tabla de multiplicar del mismo, con el producto del mismo con el valor 1 al 12. */ // inicializacion y declaracion de variables int n=0; int producto = 0; int valor = 0; Console.Write("Ingrese el valor : "); valor = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("\n \n *** Tabla del {0} ***",valor); for (n = 1; n <= 12; n++) { producto = n * valor; Console.WriteLine("{0} x {1} = {2}",n,valor,producto); } } }}

Por consola veremos:

3. El código es:



namespace solucion3{ class Program { static void Main(string[] args) { /* Hacer un programa que encuentre los valores primos * entre 1 y 500. */ // inicializacion y declaracion de variables int n = 0; int m = 0; int contadordivisible = 0; Console.WriteLine("\n \n *** Valores Primos entre 1 y 500 ***"); for (n = 1; n <= 500; n++) { for (m = 1; m <= n;m++ ) { if (n % m == 0) contadordivisible = contadordivisible + 1; } if (contadordivisible == 2 || contadordivisible == 1) Console.Write(", {0}",n); contadordivisible = 0; } Console.WriteLine("\n Fin del Programa"); } }}

Se muestra por pantalla lo siguiente:

4. La solución del último problema es:using System;using System.Collections.Generic;using System.Text;

namespace solucion4{ class Program { static void Main(string[] args) { /* Un globo aerostático en ascenso, toma el valor de la * temperatura en 10 oportunidades, determinar:


* Temperatura promedio. * Temperatura mayor. */ // variables int n=0; float temperatura = 0.0f; float suma = 0.0f; float promedio = 0.0f; float temperaturamayor = 0.0f; for (n = 1; n <= 20; n++) { Console.Write("Ingrese una temperatura:"); temperatura = Convert.ToSingle(Console.ReadLine()); suma = suma + temperatura; if ((temperatura > temperaturamayor) || (n == 1)) temperaturamayor = temperatura; } Console.WriteLine("la suma es : {0}", suma); promedio=suma/20; Console.WriteLine("el promedio es: {0}",promedio); Console.WriteLine("La temperatura mayor es: {0}", temperaturamayor); } }}

Por consola vemos lo siguiente:


Unidad 5

Las Funciones y los Métodos.


Son muchas las ventajas, de aprender a utilizar funciones y métodos en nuestros programas, entre ellas podemos enumerar que: son código reutilizables, permiten trabajar en forma más ordenada, los programas son más legibles a la hora de visualizar, realizan procesos específicos, etc.

Con el conocimiento de las funciones y los métodos, nos estamos encaminando hacia la programación orientada a objetos.

Las Funciones

Las funciones, son un elemento más de los programas, que contiene código y pueden ser ejecutadas.

Dentro de los programas, vamos a llamar o invocar a la función y esta ejecutará, el bloque de sentencias que se encuentren en su interior, luego cuando finaliza y ejecuta la última línea del bloque, regresa a la línea siguiente del programa que la ha invocado.

Ya hemos utilizado un función, que es la que se dispone cuando nos ubicamos en un nuevo proyecto, ella es la función principal llamada Main(), y a


partir de ahí podemos crear la cantidad de funciones que necesitemos para nuestra aplicación.

En la programación orientada a objetos (POO), existen las clases, estas contienen código, y este código se encuentra en una función que se denomina método.

Por ejemplo, cuando convertimos una cadena en un valor flotante, hemos utilizado el método tosingle(), que se encuentra dentro de la clase convert.

La estructura de una función, consta de 5 secciones, ellas son:

Modificador tipo nombre (parámetro){Bloque de código;}

Explicare cada una de estas secciones, y para que se entienda mejor empezaré por la definición del tipo de función, dejando el modificador para lo último.

Tipo: indicaremos el tipo de información que regresa la función. En caso de no regresar nada se denuncia como void.

Nombre: todas las funciones serán identificadas por su nombre, pues se utilizará para invocarla desde el programa. Es práctico, comenzar la funciones con letra mayúscula (Ej.: Promedio), y en caso de utilizar más de una palabra, empezar cada una de ellas con mayúscula sin dejar espacio (Ejemplo: PromedioTriangulo). Además es importante que el nombre tenga referencia con lo que hace la función.

Parámetro: algunas funciones necesitan información para trabajar, denominada parámetros. Los parámetros, son un conjunto de variables, en caso de no tener la necesidad de enviar datos o variables, se disponen los paréntesis vacios.

Bloque de código: Son el conjunto de sentencia en lenguaje C#. Todo lo que hemos visto hasta el momento puede ir dentro del bloque de código.

Modificador: por último; como lo he dicho, los modificadores cambian el funcionamiento de la función. Nosotros, vamos a usar el modificar static, pues nos va a permitir usar la función, sin tener que declarar un objeto de la clase a la que pertenecemos (temas a desarrollar más adelante).

En un programa, podemos pensar que todos son objetos que pertenecen a una clase, y esta debe estar declarada para poderse utilizar en nuestro sistema.


Tipos de funciones.

A la hora de programar, nos podemos encontrar con 4 tipos de funciones, ellas son las que:

Solo ejecutan código. Regresan valores. Reciben parámetros. Reciben parámetros y regresan valores.

Explicare cada una de ellas, como también expondré un ejemplo de cada tipo de función.

Funciones que solo ejecutan código

Estas funciones solo llevan a cabo una tarea o función, al momento de ser invocadas, por lo tanto el tipo de la misma será void.

Para poder utilizar una función habrá que declararla, esto se realiza dentro del bloque de código de una clase. En nuestros ejemplo los hacemos en la clase class Program, que ya viene definida, cuando disponemos de un nuevo proyecto. Recordamos que nuestra función principal Main() (que actúa como administradora del programa) también, ya viene definida dentro de la clase class Program.

Manos al teclado, y comenzamos con el desarrollo de nuestra primera función.

Realizar un programa donde el usuario, ingrese dos números e indicar el promedio de los mismos.


namespace ejecutasolocodigo{ class Program { static void Main(string[] args) { Promedio(); // invocacion a la funcion } // declaracion de la funcion promedio static void Promedio() { // declaracion de variables float a = 0.0f; float b = 0.0f; float resultadopromedio = 0.0f;


string valor = "";

Console.Write("ingrese un valor:"); valor = Console.ReadLine(); a = Convert.ToSingle(valor); Console.Write("ingrese otro valor:"); valor = Console.ReadLine(); b = Convert.ToSingle(valor);

resultadopromedio = (a + b) / 2; Console.WriteLine("El promedio es : {0}",resultadopromedio); } }}

Las variables que hemos utilizados, las he declarado dentro de la función y solo tiene validez en ese contexto. Estas variables se denominan locales y solamente serán reconocidas dentro de esa función.

Funciones que regresan valores.

Nuestro siguiente tipo de función, es aquella que puede regresar un valor. Quiere decir que al invocar la función, se ejecutará el código y regresará un valor como resultado de la ejecución del bloque de código de la misma.

Recordamos que aquí, deberemos poner el tipo de variable que va retornar, además la función utilizará un comando especial para regresar este valor denominado return.

Antes de ir al ejemplo, monto una estructura simple, de cómo debemos programar este tipo de función.

En Main()

Float resultadopromedio=0.0f;resultadopromedio=Promedio();

En la función:

Return resultadopromedio;


Utilizamos el ejemplo anterior; el de ingresar dos números e indicar su promedio. Pero, el resultado lo recibe dentro de la función Main(), desde donde fue invocada la función Promedio().


namespace regresaunvalor{ class Program { static void Main(string[] args) { // declaracion de las variables float resultadoregresado = 0.0f; // invocacion de la funcion resultadoregresado = Promedio(); Console.WriteLine("El promedio es : {0}", resultadoregresado); } // declaracion de la funcion promedio static float Promedio() { // declaracion de variables float a = 0.0f; float b = 0.0f; float resultadopromedio = 0.0f; string valor = "";

Console.Write("ingrese un valor:"); valor = Console.ReadLine(); a = Convert.ToSingle(valor);

Console.Write("ingrese otro valor:"); valor = Console.ReadLine(); b = Convert.ToSingle(valor);

resultadopromedio = (a + b) / 2;

return resultadopromedio;

} }}

El resultado que se muestra, luego de ser ejecutado el programa, debe ser igual que el anterior.

Funciones que reciben parámetros.


Los tipos de funciones que hemos visto, piden directamente al usuario los valores de las variables necesarias para trabajar. Ahora, en la invocación de la función, le enviaremos los valores que la función necesita. Estos valores, se denominan parámetros, y deben estar definidos con su nombre y tipo.

Nuevamente, dispongo de una estructura simple, de como debemos programar este tipo de función.

En Main()

Float valor1=0.0f;Float valor2=0.0f;

Promedio(valor1,valor2);

En la función

Static void promedio(float a, float b)

Utilizaremos el ejemplo anterior, pero esta vez el resultado se muestra en la función, luego de enviarle los valores, invocando la función desde Main().


namespace recibeparametros{ class Program { static void Main(string[] args) { // declaracion de variables float valor1 = 0.0f; float valor2 = 0.0f; string valor = "";

Console.Write("ingrese un valor: "); valor = Console.ReadLine(); valor1 = Convert.ToSingle(valor);

Console.Write("ingrese otro valor: "); valor = Console.ReadLine(); valor2 = Convert.ToSingle(valor);

Promedio(valor1, valor2);

}

// declaracion de la funcion promedio static void Promedio(float a, float b) {


// declaracion de variables float resultadopromedio = 0.0f; resultadopromedio = (a + b) / 2; Console.WriteLine("El promedio es : {0}",resultadopromedio);

} }}

Utilizamos en el envío de parámetros, valores implícitos (promedio(valor1,valor2)) pero, no habría ningún tipo de problema, si quisiéramos haber enviado valores explícitos (promedio(4.0f,7.5f)).

Funciones que reciben parámetros y regresan valores.

El último caso de la funciones que analizaremos, es aquella invocada que envía parámetros, llevará a cabo las tareas incluidas en el bloque de instrucciones, y el resultado, lo devolverá al lugar donde se invocó la función.

Nuevamente haremos uso de la instrucción return, para regresar el valor calculado.

Debemos prestar suma atención, con el tipo de parámetros y valores que se regresan, generalmente son del mismo tipo.

Monto una estructura simple, de cómo deberemos programar este tipo de función.

En Main()

Float valor1=0.0f;Float valor2=0.0f;Float resultado=0.0f;

resultado=Promedio(valor1,valor2);

En la función

Static float promedio(float a, float b)Float resultadopromedio;


return resultadopromedio;

Por última vez, utilizamos el mismo ejemplo de ingreso de dos valores y la obtención de su promedio. Y esta vez, el resultado se muestra dentro de la función Main(), mientras que en la función, luego de tomar los valores, calcula el resultado y lo retorna.


namespace enviaparametrosrecibevalores{ class Program { static void Main(string[] args) { // declaracion de variables float valor1 = 0.0f; float valor2 = 0.0f; float resultado = 0.0f; string valor = "";

Console.Write("ingrese un valor: "); valor = Console.ReadLine(); valor1 = Convert.ToSingle(valor);

Console.Write("ingrese otro valor: "); valor = Console.ReadLine(); valor2 = Convert.ToSingle(valor);

resultado=Promedio(valor1, valor2); Console.WriteLine("El promedio es : {0}", resultado); }

// declaracion de la funcion promedio static float Promedio(float a, float b) { // declaracion de variables float resultadopromedio = 0.0f; resultadopromedio = (a + b) / 2; return resultadopromedio; } }}


Nuevamente no ha cambiado la pantalla que muestra el resultado del problema propuesto.

Antes de pasar a otro tema, propongo un problema para resolver y profundizar las funciones.

Confeccionar un programa, que permita al usuario elegir si muestra el precio de una artículo, en dólares (u$s) o en euros (€). El precio inicial, es ingresado en pesos ($) por el mismo usuario.

Sin duda, que antes de empezar, merece un análisis. Pero a priori, creo que podemos hacer 3 funciones, una para el ingreso del precio original y las otras dos restantes para la conversión.


namespace conversiondolareseuros{ class Program { static void Main(string[] args) { // inicializacion de variables string opcionsalida = "s"; string valor = ""; int opcion = 0; float preciopeso = 0.0f; float precioconvertido = 0.0f; do { Console.WriteLine("Conversión de Pesos ($)."); Console.WriteLine("1 - A Dolares (u$s)"); Console.WriteLine("2 - A Euros (€)"); Console.Write("Elija la opcion deseada de Conversión..."); valor = Console.ReadLine(); opcion = Convert.ToInt32(valor); if (opcion == 1) { preciopeso=Ingresaprecioenpesos(); precioconvertido = Pesoadolar(preciopeso); Console.WriteLine("El articulo de {0} $ es equivalente a {1} u$s",preciopeso,precioconvertido); } if (opcion == 2) { preciopeso = Ingresaprecioenpesos(); precioconvertido = Pesoaeuro(preciopeso);


Console.WriteLine("El articulo de {0} $ es equivalente a {1} €", preciopeso, precioconvertido); }

// opcion para continuar en el sistema Console.Write("Desea continuar ... s/n "); valor = Console.ReadLine(); opcionsalida = valor; } while (opcionsalida == "s"); } // funcion de ingreso de precio en peso static float Ingresaprecioenpesos() { float precio; string valor = ""; Console.Write("Ingrese el precio del articulo en pesos ($)"); valor = Console.ReadLine(); precio = Convert.ToSingle(valor); return precio; } // funcion de conversion de peso a dolar static float Pesoadolar(float a) { float resultado = 0.0f; resultado=a*3.44f; return resultado; }

// funcion de conversion de peso a Euro static float Pesoaeuro(float a) { float resultado = 0.0f; resultado = a*4.44f; return resultado; }

}}


Paso de valores por Copia y por Referencia.

Es importante saber y determinar, el ámbito, en el cual las variables que se han definido mantienen su valor.

Para esto debemos introducir dos conceptos muy importantes:

1 – las variables solo pueden ser utilizadas, en el ámbito (parte del programa) donde fueron creadas. Solo puedo copiar el contenido de la variable.

2 – si invocamos una función y pasamos parámetros, una copia del valor y del parámetro pasa a la función.

Para entender mejor estos conceptos vamos a ver 2 ejemplos.

El código que se encuentra a continuación; de esta breve explicación teórica, está diseñado para explicar el primer concepto.

En el programa, tendremos 2 funciones (Main() y Cambiar()), además vamos a declarar y asignar una variable (numero=10).

Ingresemos el ejemplo a nuestro editor.


namespace pasoporcopia{ class Program { static void Main(string[] args) { // inicializamos las variables a utilizar int numero = 10; Console.WriteLine("Valor antes de invocar a la funcion: {0}", numero); cambiar(numero); Console.WriteLine("Valor nuevamente en la Main(): {0}", numero); } static void cambiar(int numero) { // cambio el valor de la variable Console.WriteLine("Valor dentro de la funcion antes de cambiar: {0}", numero); numero = 20; Console.WriteLine("Valor dentro de la funcion cambiada: {0}", numero); } }}


He mostrado el valor que se le ha asignado la variable, en diferentes instancias del programa. Y vemos, que la variable fue afectada dentro de la función, pero al salir de la misma regresa a su valor original.

En realidad, lo que ha pasado, es que no se paso la variable al invocar la función, sino que solo se ha pasado su valor.

Para nuestro segundo concepto, vamos a modificar el código recién expuesto.

En este caso, ha diferencia del anterior, voy a disponer de una nueva instrucción ref, cuando declare las variables en la función y cuando la invoque.

En este ejemplo no solo pasaremos el valor, sino, que también la referencia de la variable que estamos utilizando. Por lo tanto cuando regrese a la función principal Main(), el valor de la variable mantiene el valor modificado en la función cambiar().

Esto es muy útil, cuando deberemos devolver varios valores, pues return solo regresa un único valor.

Nuevamente, utilicemos el editor para probar el siguiente ejemplo:


namespace pasoporreferencia{ class Program { static void Main(string[] args) { // inicializamos las variables a utilizar int numero = 10; Console.WriteLine("Valor antes de invocar a la funcion: {0}", numero); cambiar(ref numero); Console.WriteLine("Valor nuevamente en la Main(): {0}", numero);


} static void cambiar(ref int numero) { // cambio el valor de la variable Console.WriteLine("Valor dentro de la funcion antes de cambiar: {0}", numero); numero = 20; Console.WriteLine("Valor dentro de la funcion cambiada: {0}", numero); } }}

Como último ejercicio de esta unidad, vamos a resolver el problema de, dados 2 valores asignados a las variables a y b, intercambiar los valores en dichas variables.


namespace intercambiovariables{ class Program { static void Main(string[] args) { // inicializamos las variables a utilizar int a = 10; int b = 20; Console.WriteLine("el valor de a es {0} y el de b {1} ", a, b); Intercambiar(ref a, ref b); Console.WriteLine("luego del cambio."); Console.WriteLine("El valor de a es {0} y el de b {1} ", a, b); } // intercambio del valor de las variables static void Intercambiar(ref int a, ref int b) { // incializa una variable auxiliar int auxiliar = 0; auxiliar = a; a = b; b = auxiliar; } }}


Las funciones nos van admitir tener en nuestras aplicaciónes, secciones especiales de código. Esto nos permitirá tener programas ordenados, códigos reutilizables, fácil de localizar las diferentes secciones luego de un tiempo que no lo tocamos o por otro programador que ve por primera vez el código, etc.



1. Realizar un programa que el usuario pueda seleccionar una opción entre sumar, multiplicar, restar, dividir dos valores. Por cada opción se deberá invocar a una función que realice el proceso.

2. Confeccionar una aplicación, donde un cliente de un Banco, puede operar (solicitar saldo, depositar o retirar dinero) hasta que este, no necesite realizar ninguna operación más.

3. Confeccionar una aplicación, que permita determinar cuanto debe pagar un usuario de telefonía en función, del plan que ha adquirido. Se ingresaran los pulsos consumidos por el usuario y el plan de telefonia adoptado. Plan familiar el pulso 0,19 / pulso excedente 0.17 / hasta 800 pulsos Plan comercial el pulso 0,17 / pulso excedente 0.15 / hasta 1000 pulsos Se deberá confeccionar el cálculo de cada plan en una función.

El usuario determina cuando quiere salir de la aplicación.



1 – la solución del primer programa es:


namespace solucion1{ class Program { static void Main(string[] args) { /*Realizar un programa que el usuario pueda seleccionar una *opción entre sumar, multiplicar, restar, dividir dos * valores. Por cada opción se deberá invocar a una * función que realice el proceso. */ // definicion de variables float unvalor = 0.0f; float otrovalor = 0.0f; int opcion = 0; float resultado = 0.0f; string operacion = "";

Console.Write("Ingrese un valor: "); unvalor = Convert.ToSingle(Console.ReadLine()); Console.Write("Ingrese otro valor: "); otrovalor = Convert.ToSingle(Console.ReadLine()); Console.Write("\n\n Opciones \n 1 - Suma \n 2 - Multiplica \n 3 - Resta \n 4 - Divide \n\n Ingrese la opcion deseada .... " ); opcion = Convert.ToInt32(Console.ReadLine()); switch (opcion) { case 1: resultado=suma(unvalor,otrovalor); operacion = "suma"; break; case 2: resultado = multiplicacion(unvalor, otrovalor); operacion = "multiplicacion"; break; case 3: resultado = resta(unvalor, otrovalor); operacion = "resta"; break; case 4: if (otrovalor == 0) { Console.WriteLine("No existe la division. El Divisor debe ser distinto de cero."); resultado = 0;


operacion = "Opcion es no valida"; } else { resultado = division(unvalor, otrovalor); operacion = "división"; } break; default: resultado = 0; operacion = "Opcion es no valida"; break; }

Console.WriteLine("la {0} de {1} y {2} es {3}",operacion,unvalor,otrovalor,resultado);

} // funcion suma static float suma(float a, float b) { float resultadofuncion=0.0f; resultadofuncion=a+b; return resultadofuncion; } // funcion resta static float resta(float a, float b) { float resultadofuncion = 0.0f; resultadofuncion = a - b; return resultadofuncion; } // funcion multiplicacion static float multiplicacion(float a, float b) { float resultadofuncion = 0.0f; resultadofuncion = a * b; return resultadofuncion; } // funcion division static float division(float a, float b) { float resultadofuncion = 0.0f; resultadofuncion = a / b; return resultadofuncion; }

}}

Se muestra por consola lo siguiente:


2 - para el segundo problema, el código solución es el siguiente:


namespace solucion2{ class Program { static void Main(string[] args) { /*Confeccionar una aplicación, donde un cliente de un Banco , puede operar (solicitar saldo, depositar o retirar dinero) hasta que este, no desee realizar ninguna operación mas. */ // inicializacion de variables string opcion=""; int codigooperacion = 0; float saldo = 0.0f; float importe = 0.0f; do { Console.Write("\n\n Operación a Realizar.\n 1-consulta de saldo \n 2-Deposito \n 3-Extracción \n\n\nIngrese el tipo de operación ..."); codigooperacion = Convert.ToInt32(Console.ReadLine()); switch (codigooperacion) { case 1: Console.WriteLine("\n\n **** el saldo es: {0} ****",saldo); break; case 2: Console.Write("Ingrese el importe a depositar: "); importe = Convert.ToSingle(Console.ReadLine()); saldo=Deposito(ref saldo,importe); break; case 3: Console.Write("Ingrese el importe a extraer: "); importe = Convert.ToSingle(Console.ReadLine()); if (importe <= saldo)


saldo = Extraer(ref saldo, importe); else Console.WriteLine("No es posible su saldo es menor al importe ha extraer."); break; default: Console.Write("*** no es una operacion valida ***"); break; }

Console.Write("\n\n Desea continuar s/n ..."); opcion = Console.ReadLine(); } while (opcion == "s");

} // funcion Depositar static float Deposito(ref float saldo,float auximporte) { saldo=saldo+auximporte; return saldo; } // funcion Extraer static float Extraer(ref float saldo, float auximporte) { saldo = saldo - auximporte; return saldo; } }}

Por consola vemos:


3 – para el último problema, he desarrollado el siguiente código:


namespace solucion3{ class Program { static void Main(string[] args) { /* Confeccionar una aplicación que permita determinar cuanto debe pagar un usuario de telefonía en función del plan que ha adquirido. Se ingresaran los pulsos consumidos por el usuario y el plan de telefonia adoptado. Plan familiar el pulso 0,19 / pulso excedente 0.17 / hasta 800 pulsos * Plan comercial el pulso 0,17 / pulso excedente 0.15 / hasta 1000 pulsos Se deberá confeccionar el cálculo de cada plan en una función. El usuario determina cuando quiere salir de la aplicación. */

// definicion de variables int pulsos = 0; string plan = "";


string opcion=""; float costopulso=0.0f; float costopulsoexcedente = 0.0f; int pulsosexcedente = 0; float apagar = 0.0f;

do { Console.Write("ingrese la cantidad de Pulsos consumidos:"); pulsos = Convert.ToInt32(Console.ReadLine()); Console.Write("ingrese el plan familiar/comercial:"); plan = Console.ReadLine(); if (plan == "familiar") { costopulso = 0.19f; costopulsoexcedente = 0.17f; pulsosexcedente = 800; apagar = PulsosPagar(pulsos,costopulso,costopulsoexcedente,pulsosexcedente); } if (plan == "comercial") { costopulso = 0.17f; costopulsoexcedente = 0.15f; pulsosexcedente = 1000; apagar = PulsosPagar(pulsos, costopulso, costopulsoexcedente, pulsosexcedente); }

Console.WriteLine("\n\n El abonado del plan {0} consumio {1} pulsos. Debe pagar {2}$", plan, pulsos, apagar);

Console.Write("Desea continuar ... s/n. "); opcion = Console.ReadLine();

} while (opcion == "s");

} // funcion calculo de los pulsos a pagar static float PulsosPagar(int apulsos,float acostopulso,float acostopulsoexcedente,int apulsosexcedente) { float apagarauxiliar=0.0f; float apagarexcedido = 0.0f; if (apulsos <= apulsosexcedente) { apagarauxiliar = apulsos * acostopulso; } else { apagarexcedido = (apulsos - apulsosexcedente) * acostopulsoexcedente; apagarauxiliar = (apulsosexcedente * acostopulso)+apagarexcedido; }

return apagarauxiliar; } }


}

Vemos en consola:


Unidad 6

Los Arreglos.


Los arreglos (array), nos permitirán administrar la información fácilmente y en forma optima, cuando necesitemos gran cantidad de variables. En lenguaje C#, existen varias instrucciones, para gestionar el trabajo que se realiza utilizando los arreglos.

Retomando el problema que ha resuelto los promedios de los 5 alumnos, recordamos que al finalizar, obteníamos el último promedio. Pero que pasaría, si quisiéramos, mostrar el primer, o el tercer promedio de los alumnos; con excepción del último que ya está en pantalla; sería imposible volver atrás. Pues, hemos trabajado con una única variable. Para este caso; e infinidad de casos más, como gestionar una lista de precios, el armado de una agenda personal, los gastos de las semana, etc.; vamos hacer uso de los arreglos.

Los arreglos, son un grupo de variables referenciadas por un único nombre y un índice. Este índice, se basa en índice 0 (cero), es decir que el primer elemento no es el 1 sino que es el 0. Cuando hablemos del tamaño de un arreglo, nos estaremos refiriendo a la cantidad de elementos que este posee. Este valor debe estar prefijado, ya sea en forma explícita (por un valor Ej.: 10) o implícita (por una variable Ej. cantidad).

Los arreglos pueden tener diferentes dimensiones, comenzaremos el estudio de los mismos, con aquellos de una solo dimensión, llamados también unidimensionales o vectores.

Los arreglos deben ser declarados antes de su uso, y lo haremos de la siguiente manera:

Tipo[ ] nombre =new tipo [cantidad];

Los arreglos en C# son Objetos, por lo tanto deben ser creados, para eso utilizamos la instrucción New. Al inicio debemos definir el tipo de dato que va a contener el arreglo, luego el nombre (es conveniente utilizar letra minúscula, pues son considerados como variables), la instrucción New y por último, volvemos a indicar el tipo que hemos elegido, con la cantidad de elementos que posee.

Ejemplos de declaración de arreglos.


float[ ] notas =new float[10];

En nuestro caso el arreglo será de tipo flotante, lo identificamos con el nombre notas, luego New para crearlo y por ultimo instanciamos con [ ] indicando que tendrá 10 elementos (de 0 a 9).

Otros ejemplos de declaración de arreglos válidos:

Int cantidad=10;float[ ] notas =new float[cantidad];

float[ ] notas = {1.5f,3.0f,2.4f} // si ya conocemos los valores;

Para asignarle un valor, a algún elemento del arreglo unidimensional, deberemos conocer su nombre y su posición, indicada como índice y entre corchetes.

Ejemplo:

nota[3] = 7.5f;

Lo más usual, va ser utilizar como índice, una variable de control de algún bucle; tema que ya hemos visto.

En este ejemplo, muestro los valores de los elementos que lo componen (no se pueden mostrar más elementos que la cantidad asignada, el compilador dará error al intentar acceder a leer un elemento inexistente).

For (n=0; n>=10; n++){

Console.writeLine(“el valor es: {0}”, nota[n]);}

Para el uso de elementos de los arreglos, deberemos considerar, que los elementos del arreglo son variables, por lo tanto, se podrán realizar todas las operaciones que estas realizan.

impuestoiva= precio[3] * 2.1f;

Ya estamos en condiciones de realizar nuestra primera aplicación utilizando arreglos.

Hagamos una aplicación, donde el usuario, ingrese 10 valores y pueda determinar el promedio, el valor mayor y el menor.

using System;using System.Collections.Generic;


using System.Text;

namespace arreglospromediomayormenor{ class Program { static void Main(string[] args) { // definicion y declaracion de variables

string valor = ""; int n = 0; float promedio = 0.0f; float acumula = 0.0f; float minimo = 0.0f; float maximo = 0.0f; float[] numero = new float[10];// creamos el arreglo for (n=0;n<10;n++) { Console.Write("Ingrese un valor: "); valor = Console.ReadLine(); numero[n]=Convert.ToSingle(valor); } maximo = numero[0]; // incializamos a maximo con el primer elemento minimo = numero[0];// incializamos a minimo con el primer elemento for (n = 0; n < 10; n++) { if (numero[n] > maximo) maximo = numero[n];

if (numero[n] < minimo) minimo = numero[n];

acumula = acumula + numero[n]; }

promedio = acumula / 10; Console.WriteLine("El promedio es : {0}",promedio); Console.WriteLine("El valor mayor es : {0}",maximo); Console.WriteLine("El valor menor es : {0}",minimo); } }}


En resúmen, es más sencillo manejar arreglos como una lista, que gran cantidad de variables con diferentes nombres.

Arreglos con 2 dimensiones (bidimensional o matriz)

Todos hemos solicitado una carta de precios en algún restaurant, y en ella vemos los platos de comida y su respectivo precio. Si lo pasamos a un arreglo bidimensional, podemos pensar que son 2 columnas, una corresponde a los platos de comida y la otra contiene los precios, y si contamos la cantidad de platos que ese restaurant ofrece, estaríamos deduciendo la cantidad de filas (por ejemplo 50 platos). Es decir que tendríamos una matriz compuesta de 2 columnas y 50 filas.

Plato PrecioMilanesa con papas fritas 18 $Filete de merluza con ensalada

20 $

… …Zapallitos rellenos 15 $

Declaración de los arreglos bidimensionales.

La declaración de los arreglos bidimensionales, es similar a los de solo una dimensión.

Ejemplo de la declaración de arreglos bidimensionales.

float[ , ] precios =new float [2,10];

En nuestro caso la tabla será de tipo flotante, lo identificamos con el nombre precios, luego New para crearlo y por ultimo instanciamos con [ , ] indicando que tendrá 2 columnas y 10 filas es decir 20 elementos en total.

Otros ejemplos de declaración de arreglos bidimensionales válidos:

Int fila=10;Int columna=2;float[ , ] precios =new float [fila , columna];

Para asignarle un valor a algún elemento al arreglo bidimensional, deberemos conocer su nombre y su posición dentro de la matriz (la fila y su columna).

Ejemplo:

precio[2,3] = 10.5f;


Lo más usual, va ser cargar una matriz utilizando bucles. Para eso, vamos a tener que utilizar dos bucles anidados, uno con una variable de control de las filas y el otro con una variable diferente de control, correspondiente a las columnas.

Vamos a confeccionar un ejemplo:

Confeccionaré una matriz compuesta por 5 productos, con sus precios de costo y los de lista.

Producto Precio Costo Precio listaTv 550 $ 700$DVD 220 $ 300$… …Licuadora 100 $ 150$


namespace cargamatriz{ class Program { static void Main(string[] args) { int fila = 5; int columna = 3; string valor = ""; // declaracion de la matriz

string[,] productos = new string[fila,columna]; for (fila=0;fila<=4;fila++) { for (columna = 0; columna <= 2;columna++ ) { Console.Write("ingrese informacion fila {0} columna {1} :", fila, columna); valor = Console.ReadLine(); productos[fila, columna] = valor; } } } }}


Hay mucho para discutir, como porque se ingresaron precios en formato string, en el ingreso de los datos dice información y no definir que estamos ingresando realmente, etc. Ya vamos a ver como mejorar, pero la idea era, que vean como se carga una matriz con bucles anidados.

Vamos a confeccionar una nueva aplicación utilizando matrices.

Fuimos contratados por una empresa de turismo, que desea saber:

Cuál es el destino con el pasaje más caro. Cuál es el precio del pasaje más barato. Existe el destino Mar del plata.

Dicha empresa posee en la actualidad 10 destinos. (Por lo tanto podemos crear una matriz de 10 filas por 2 columnas).

Destino Pasaje ($)Bariloche 190 $Mar del plata 75 $… …Jujuy 180 $


namespace agenciaturismo{ class Program { static void Main(string[] args) { int fil = 10; int col = 2;


bool existe = false; string[,] turismo = new string[fil, col]; // declaro la matriz turismo for (fil = 0; fil <= 9; fil++) // Carga de destinos y precios { Console.Write("Ingrese el destino: "); turismo[fil,0] = Console.ReadLine();

Console.Write("Ingrese el costo del Pasaje: "); turismo[fil,1] = Console.ReadLine(); Console.WriteLine("*******************************"); } // declaracion de variables string destinocaro=""; float pasajecaro=0.0f; float pasajebarato=0.0f; // inicializacion destinocaro = turismo[1, 0]; pasajecaro = Convert.ToSingle(turismo[1, 1]); pasajebarato = Convert.ToSingle(turismo[1, 1]);

for (fil = 0; fil <= 9; fil++) { // determina el destino mas caro if (Convert.ToSingle( turismo[fil, 1]) > pasajecaro) { destinocaro = turismo[fil, 0]; pasajecaro = Convert.ToSingle(turismo[fil, 1]); } // determina el pasaje mas barato if (Convert.ToSingle(turismo[fil, 1]) < pasajebarato) { pasajebarato = Convert.ToSingle(turismo[fil, 1]); } // determina si existe o no el destino mar del plata if (turismo[fil, 0] == "mar del plata") { existe=true; } } Console.WriteLine("El destino mas caro es {0} a un precio {1}: ", destinocaro, pasajecaro); Console.WriteLine("El pasaje mas barato es {0}", pasajebarato); if (existe == true) { Console.WriteLine("Existe el destino Mar del Plata."); } else { Console.WriteLine("NO Existe el destino Mar del Plata."); }


} }}

Arreglos del tipo JaggedExiste un tipo de arreglos especial denominado Jagged. Este tipo de

arreglo lo podremos utilizar cuando necesitamos de una matriz con columnas de diferentes filas. Pues si utilizamos el tipo de matriz que hemos visto, para este problema determinado, posiblemente estaríamos desperdiciando memoria.

Por ejemplo, si queremos procesar las notas de alumnos de diferentes cursos, puede llegar a ocurrir que en un curso tenga 10 alumnos pero en otro 15. Para este ejemplo sería adecuado utilizar este nuevo tipo de arreglo.

Curso0 Curso1 Curso2 Curso37 5 4 108 8 89 9

6

Este arreglo, actúa como contenedor de otros arreglos, deberá ser declarado de una forma especial para poder utilizarlo. Para esto, primero deberemos declarar el arreglo contenedor y luego cada uno de los arreglos independientes.

Aquí le muestro una estructura de un arreglo jagged:

// declaramos el arreglo contenedor para la carga


// de edades de 4 familias int[][] edades = new int[4][]; // declaramos los arreglos - edades por familia edades[0] = new int[4]; // esta familia posee 4 integrantes edades[1] = new int[3]; // esta familia posee 3 integrantes edades[2] = new int[5]; // esta familia posee 5 integrantes

edades[3] = new int[7]; // esta familia posee 7 integrantes

Declaramos un arreglo jagged con el nombre de edades, podemos observar que junto al tipo he puesto dobles corchetes (int [ ][ ]), esto indica que es un arreglo de arreglo y no una matriz o arreglo estándar. En el lado derecho del signo igual la instrucción New para la creación del objeto, el tipo y el primer corchete con un numero 4 indicando que va tener en su interior 4 arreglos (en este caso la cantidad de familias); el corchete siguiente vacio pues no sabemos la cantidad que va a contener cada columna o que la cantidad es variable.

Luego, he inicializado cada uno de los vectores con la cantidad de elementos que estos posee, en nuestro caso la primera familia tiene 4 integrantes, la segunda 3 y así sucesivamente.

Si conociéramos las edades de cada familia, otra manera de declarar e inicializar el arreglo jagged, seria de esta manera:

int [][] edades=new int[4][]; edades[0] = new int[] {45,39,16,9}; edades[1] = new int[] {25,23,3}; edades[2] = new int[] {47,42,17,16,10}; edades[3] = new int[] {62,56,25,22,18,15,10};

Otra manera más de declaración de arreglos tipo Jagged es la siguiente:

Presten atención a las llaves y a la separación por coma de cada uno de los vectores.

int[][] edades = new int[][] { new int[] { 45, 39, 16, 9 }, new int[] { 25, 23, 3 }, new int[] { 47, 42, 17, 16, 10 }, new int[] { 62, 56, 25, 22, 18, 15, 10 }

};

Para acceder a un elemento del arreglo Jagged para asignarle un valor no solo necesitamos el nombre del mismo sino que también los índices de su ubicación. Ejemplo:

Edades[1][4]=9; // le asignamos 9 al cuarto integrante de la primera familia, es decir primera columna y cuarta fila.

Y para mostrar por consola los elementos del arreglo Jagged, podemos editar los siguiente:

Console.WriteLine("la edad es : {0}",edades[2][3]);


Vamos a realizar un problema viendo un arreglo jagged.

Carguemos las edades de cuatro familias con diferentes cantidades de integrantes. Luego mostrar las edades de cada familia por pantalla.

Para resolver este problema utilizaremos una función especial denominada “getlength” esta permite determinar la cantidad de elementos del arreglo.


namespace arreglojagged{ class Program { static void Main(string[] args) { int n=0; int m = 0; int cantidadintegrantes = 0; // declaramos el arreglo contenedor para la carga // de edades de 4 familias int [][] edades=new int[4][]; // declaramos los arreglos - edades por familia edades[0] = new int[] {45,39,16,9}; edades[1] = new int[] {25,23,3}; edades[2] = new int[] {47,42,17,16,10}; edades[3] = new int[] {62,56,25,22,18,15,10}; for (n = 0; n <= 3;n++ ) { cantidadintegrantes = edades[n].GetLength(0); // getlength determina la cantidad de elementos del arreglo Console.WriteLine("longitud de cada familia {0}", cantidadintegrantes);

for (m = 0; m < cantidadintegrantes;m++ ) { Console.WriteLine("de la familia {0} la edad del integrante {1}", n,edades[n][m]); } } } }}


Los arreglos utilizados como parámetros en funciones.

Hasta el momento, los arreglos fueron utilizados dentro de Main(), pero es posible que tengamos que utilizarlo como parámetro y enviarlo a una función.

Vemos en una estructura simple, de cómo deberemos programar:En Main()

Int[] numeros =new int[10]; // declaramos un arreglo…Muestranumeros(numeros); // invocamos la función

En la función

Static void Muestranumeros(int[] arreglo)// recibe el arreglo

{...}

Hagamos el último problema de esta unidad.

Carguemos 10 valores y luego lo mostraremos en una función.


namespace arreglocomoparametro{ class Program { static void Main(string[] args) {


int n = 0; string valor = ""; // declaramos el arreglo int[] numeros=new int[10];

for (n = 0; n <= 9; n++) { Console.Write("Ingrese un valor: "); numeros[n] = Convert.ToInt32(Console.ReadLine()); } Muestranumeros(numeros); // invoca a la función } // definimos la funcion static void Muestranumeros(int[] arreglo) { int m=0; for (m = 0; m <= 9;m++ ) { Console.WriteLine("Posicion {0} valor del arreglo {1} ", m,arreglo[m]); } } }}



1 . Realizar un programa, donde el usuario pueda cargar en un arreglo o vector, las 20 temperaturas tomadas a orilla de un rio cada una hora. Luego determinar:

a. Temperatura promediob. Temperatura mayorc. A qué hora se determinó la temperatura menor.

2 . Una concesionaria de automóviles carga en una matriz su listado de 10 automóviles, con sus respectivos precios.

Automóvil precio ($)Ford fiesta 25000 $Fiat siena 26500 $… …Renault 19 18000 $

Determinar:

a. Suma total de precios.b. Cuál es el automóvil de mayor precio.c. Hay en existencia un automóvil Citroën 3cv.

3 .Cargar en un arreglo jagged las ventas en pesos realizadas en la semana:

Lunes 20 – 35 – 40 – 100Martes 35 – 90miércoles 100 – 56 – 15 – 25 - 100 - 26 Jueves 200 -15 – 56Viernes 15 – 12 - 50 – 60Sábado 120 – 25 -30 -70

a. Determinar en que día se ha realizado la venta mayor.b. Total de ventas en pesos.c. Cantidad de ventas por día.d. Cuantas ventas superaron los 50$.



1 – la solución al primer problema es:using System;using System.Collections.Generic;using System.Text;

namespace solucion1{ class Program { static void Main(string[] args) { /*Realizar un programa, donde el usuario pueda cargar en un * arreglo o vector, las 20 temperaturas tomadas a orilla de * un rio cada una hora. Luego determinar: * a.Temperatura promedio * b.Temperatura mayor * c.A que hora se determino la temperatura menor. */ // declaracion de variables y arreglos int x = 0; string valor = ""; int temmayor = 0; int temmenor = 0; int horamenor = 0; float promedio=0.0f; int[] tenperaturas= new int[10];

//proceso for(x=0;x<10;x++) { System.Console.Write("\n Ingrese la temperatura de la hora {0} : ",x+1); valor = System.Console.ReadLine(); tenperaturas[x] = System.Convert.ToInt32(valor); }

//determina y muestra las soluciones for (x = 0; x < 10; x++) { promedio = promedio + tenperaturas[x]; if ((x==0)||(tenperaturas[x]>temmayor)) { temmayor=tenperaturas[x]; } if ((x == 0) || (tenperaturas[x] < temmenor)) { temmenor = tenperaturas[x]; horamenor = x+1; } } promedio = promedio / 10; System.Console.WriteLine("El promedio es: {0}",promedio); System.Console.WriteLine("La Temperatura Mayor es: {0}", temmayor);


System.Console.WriteLine("La hora de la temperatura Menor es: {0}", horamenor); } }}

Su visualización es:

2 – la solución al siguiente problema es:using System;using System.Collections.Generic;using System.Text;

namespace solucion2{ class Program { static void Main(string[] args) { /*Una concesionaria de automóviles carga en una matriz * su listado de 10 automóviles, con sus respectivos precios. * Determinar: * a.Suma total de precios. * b.Cual es el automóvil de mayor precio. * c.Hay en existencia un automóvil Citroen 3cv. */ // inicializacion de variables y arreglos int x = 0; string valor = ""; float totalprecios = 0.0f; float preciomayor = 0.0f; string autopreciomayor = ""; bool existe3cv = false;

string[,] autos = new string[20,2]; for (x = 0; x < 10; x++) {


System.Console.Write("Ingrese la marca del Automovil: "); valor = System.Console.ReadLine(); autos[x,0] = valor; System.Console.Write("Ingrese el precio: "); valor = System.Console.ReadLine(); autos[x,1] = valor; }

// procesos para responder las preguntas for (x = 0; x < 10; x++) { totalprecios=totalprecios+System.Convert.ToSingle(autos[x,1]);

if ((x == 0)||(System.Convert.ToSingle( autos[x,1])>preciomayor)) { preciomayor=System.Convert.ToSingle(autos[x,1]); autopreciomayor = autos[x, 0]; } if (autos[x, 0] == "Citroen 3cv") { existe3cv = true; } } System.Console.WriteLine("El total de precio es: {0}",totalprecios); System.Console.WriteLine("El auto de precio mayor es: {0}", autopreciomayor); if (existe3cv == true) { System.Console.WriteLine("Existe el Citroen 3cv"); } else { System.Console.WriteLine("NO Existe el Citroen 3cv"); }

} }}

Por monitor debe mostrarse lo siguiente:

3 – la solución al último problema es:



namespace solucion3{ class Program { static void Main(string[] args) { /*3 Cargar en un arreglo jagged las ventas en pesos realizadas * en la semana * a.Determinar en que día se ha realizado la venta mayor. * b.Total de ventas en pesos. * c.Cantidad de ventas por día. * d.Cuantas ventas superaron los 50$. */ // inicializacion de variables y arreglos int x = 0; int y = 0; int contador = 0; float totalventas = 0.0f; int cantidadventas = 0; int mayorventa = 0; int numerodiamayorventa = 0; string nombredia = "";

int [][] ventas=new int[6][]; ventas[0]=new int[]{20,35,40,100}; ventas[1]=new int[]{35,90}; ventas[2]=new int[]{100,56,15,25,100,26}; ventas[3]=new int[]{200,15,56}; ventas[4]=new int[]{15,12,50,60}; ventas[5] = new int[] { 120, 25, 30, 70 }; // proceso mayorventa=ventas[0][0]; for (x = 0; x <= 5;x++) { cantidadventas = ventas[x].GetLength(0); System.Console.WriteLine("Cantidad de ventas del dia {0}: {1}",x+1,cantidadventas); for (y = 0; y <= cantidadventas-1; y++) { totalventas=totalventas+ventas[x][y]; if (ventas[x][y] > 50) contador = contador + 1; if (ventas[x][y]>mayorventa) { mayorventa=ventas[x][y]; numerodiamayorventa = x; } } }

System.Console.WriteLine("Total de Ventas en ($) {0}", totalventas); System.Console.WriteLine("Cantidad de Ventas que superan los 50$: {0}",contador); switch (numerodiamayorventa) {


case 0: nombredia = "Lunes"; break; case 1: nombredia = "Martes"; break; case 2: nombredia = "Miercoles"; break; case 3: nombredia = "Jueves"; break; case 4: nombredia = "Viernes"; break; case 5: nombredia = "Sabado"; break; } System.Console.WriteLine("el dia de la venta mayor es: {0}",nombredia);

} }}

Por consola vemos:


Unidad 7

Las Colecciones.


Las colecciones son de suma utilidad. Poseen las ventajas de permitirnos guardar datos dinámicos (permite el ingreso y borrado de datos), acceder a una mayor flexibilidad en la gestión de los mismos, se pueden utilizar todos los tipos de datos que hemos visto sin ningún inconveniente (float, int, string, etc.), etc.

El lenguaje C#, dispone de colecciones importantes para el manejo de datos dinámicos, y nosotros aprenderemos a manejar las siguientes:

Arraylist: Es la más parecida a un arreglo, con la posibilidad de cambiar la cantidad de elementos cuando lo necesitemos.

Stack: O pila, es decir que es una estructura de tipo LIFO (lo último que entra es los primero en salir).

Queue: O cola, estructura del tipo FIFO (el primero en entrar, es el primero en salir).

Hashtable: Es una colección indexada, es decir que deberemos tener en todo momento un índice y un valor referenciado a este.

Ampliaré con explicaciones y ejemplos, las colecciones enumeradas recientemente:

Colección Arraylist

El Arraylist guardará la información en forma de lista, y sobre ella podremos realizar diferentes tipos de actividades con los elementos que la conforman.

Para poder gestionar los elementos de esta colección, se poseen propiedades importantes que nos permitirá conocer el tamaño que este ocupa (capacidad), otra llamada conteo, que nos indicará la cantidad de elementos, etc.

Para que nuestra aplicación acepte este nuevo Objeto, al Arraylist deberemos declararlo de la siguiente manera:


Antes de indicarle como se deben declarar las colecciones que he enumerado, deberán asegurarse que estén usando las colecciones del sistema. Por lo tanto, en la parte superior del código, deberá estar indicado de la siguiente manera:

using System.Collections;

Luego ya podemos declarar el ArrayList

ArrayList nombredelarraylist = new ArrayList(3);

En la declaración, ArrayList es el nombre de la clase, luego sigue la denominacion nombredelaarraylist de este colección dado por nosotros, y en la parte derecha realizamos el instanciamiento que se lleva a cabo con New. He instanciado el arreglo con un valor (3); de esta forma indico la cantidad de elementos, pero pueden dejarlo vacia si no saben cuantos elementos voy a tener que ingresar.

Una vez que hemos creado el ArrayList, les mostaré los métodos mas útiles.

Add(). Agregar datos en ArrayList

El método para agregar un nuevo dato a nuestro arreglo es Add(). Este nuevo elemento se incorporará siempre al final de la lista. Necesita de un único parámetro, que es valor del dato que queremos guardar.

Ejemplos:

nombredelarraylist.Add(5); // variable explicitanombredelarraylist.Add(numero); // variable implicitanombredelarraylist.Add(“azul”); // una cadena

El método Add(), también nos da la información del índice donde fue ingresado el elemento. En este código de ejemplo, añado el valor 10 al arreglo y asigno el índice a una variable, para luego mostrarla por consola (dos tareas en un solo paso).

int indice = 0; indice = velocidades.Add(10);

Console.WriteLine("Se ha ingresado el dato en la posicion {0}",indice);

¿Cómo acceder a la información cargada? Será sencillo haciendo uso del nombre y del índice de la posición que el elemento ocupa en el arreglo. Recuerden, que el primer elemento posee la posición 0 (cero).

Para mostrar por consola.Console.WriteLine("Primer elemento {0}", nombredelarraylist[3]);

Utilizar el valor en una expresion aritmetica.


Resultado=nombredelarraylist[5]*0.15f;

Asignar un valor.nombredelarraylist[2]= “amarillo”;

foreach. Un nuevo ciclo.

Antes de continuar, veamos un nuevo ciclo especifico interador, para la colecciones que estamos viendo.

Este ciclo, nos permitirá recorrer el contenido de la colección en forma secuencial, uno por uno hasta que no tenga más elementos.

La estructura del mismo es:

foreach (tipo identificador in expresion){

sentencias;}

El tipo se refiere al tipo de información que se guarda en la colección. Luego una variable que representa al elemento en el arreglo, denominada identificador. El término expresión, se refiere a la colección que recorreremos con el ciclo. Por último; sentencias, es el código de bloque que se ejecutará en cada vuelta.

Les muestro un ejemplo muy sencillo. He cargado 4 valores enteros y los muestro en el ciclo.

using System;using System.Collections;using System.Text;

namespace aplicacionarraylist{ class Program { static void Main(string[] args) { ArrayList nombredelarraylist = new ArrayList(3); nombredelarraylist.Add(15); nombredelarraylist.Add(35); nombredelarraylist.Add(55); nombredelarraylist.Add(99); foreach (int numero in nombredelarraylist) { Console.WriteLine("Elemento {0}", numero); } } }}


Count. Cantidad de elementosVamos a poder determinar con Count, la cantidad de elementos que

posee el ArrayList. Devuelve un valor entero.

int cantidadelementos = 0; cantidadelementos = nombredelarraylist.Count; Console.WriteLine("posee {0} elementos", cantidadelementos);

Insert. Inserta un elemento.También es posible insertar un elemento, es decir agregarlo en el lugar

que nosotros necesitemos que este. No nos debemos preocupar por el tamaño del arreglo, automáticamente el compilador de C# lo administrará. Para esto harán falta dos parámetros, el índice o posición del elemento y el valor del elemento a insertar.

nombredelarraylist.Insert(2, 5); // estamos ingresando el valor 5 en la tercera posicion del arreglo.

Removeat(). Elimina un elemento.Para eliminar un elemento de la lista utilizaremos el método Removeat().

Para esto deberemos conocer el índice del elemento a eliminar.

nombredelarraylist.RemoveAt(3);

Clear(). Elimina Todos los elementos.Con clear(), se eliminará todos los elementos que contenga el ArrayList,

sin previa indicación del usuario, por lo tanto, deberá utilizarse con sumo cuidado.

velocidades.Clear();

Indexof(). Encuentra un elemento.Con el método indexof() podemos determina la posición de un elemento

dentro de la lista. Para eso, lo único que necesitamos, es un parámetro, el valor del elemento a buscar y la función nos devolverá la posición dentro de la colección.


A tener en cuenta: el valor que nos devuelve corresponde a la primera ocurrencia y si el elemento no se encuentra devuelve -1.

int posicion = 0;posicion=nombredelarraylist.IndexOf(99);Console.WriteLine("posicion del elemento buscado {0}",posicion);

Para ver el funcionamiento del ArrayList, crearemos una nueva aplicación:

Crear una aplicación usando ArrayList, que permita al usuario elegir alguna de las opciones del menú, con respecto a datos concernientes a velocidades de automóviles.

Opciones a tener en cuenta:

Ingresar una nueva velocidad y que muestre la posición. Mostrar la totalidad del arreglo. Exponer un valor en función de su posición. Modificación de una velocidad existente. Eliminar un elemento existente. Localizar la posición de un elemento existente. Borrar todo el contenido de la lista.


namespace aplicacionarraylist{ class Program { static void Main(string[] args) { // declaracion de variable int opcion = 0; int dato = 0; int indice = 0; // declaramos el Arraylist ArrayList velocidades = new ArrayList(); do { Console.WriteLine(" **** Menu de Opciones ****"); Console.WriteLine("1 - Ingreso de una nueva velocidad"); Console.WriteLine("2 - Muestra las velocidades."); Console.WriteLine("3 - Expone una velocidad en funcion de su posicion."); Console.WriteLine("4 - Modificación de una velocidad.");


Console.WriteLine("5 - Insertar una velocidad en una posicion."); Console.WriteLine("6 - Eliminar una Velocidad."); Console.WriteLine("7 - Localiza la posicion de una velocidad."); Console.WriteLine("8 - Borra el contenido de la lista."); Console.WriteLine("9 - Sale de la Aplicacion.");

Console.Write("ingrese la opcion deseada .... "); opcion = Convert.ToInt32(Console.ReadLine()); // uso del Add - ingreso de datos if (opcion == 1) { Console.Write("ingrese una velocidad: "); dato= Convert.ToInt32(Console.ReadLine()); //velocidades.Add(dato); indice = velocidades.Add(dato); Console.WriteLine("Se ha ingresado el dato en la posicion {0}",indice); }

// invoca una funcion para mostra los valores if (opcion == 2) { Muestra(velocidades); }

// Expone un dato en funcion del indice if (opcion == 3) { Console.Write("ingrese la posicion en el Listado: "); indice = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("La velocidad ubicada en la posicion {0} es {1}", indice, velocidades[indice]); } // modifica un valor existente if (opcion == 4) { Console.Write("ingrese la posicion de la Velocidad a Modificar: "); indice = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("La velocidad ubicada en la posicion {0} es {1}", indice, velocidades[indice]); Console.WriteLine("Ingrese el nuevo valor de la velocidad: "); dato = Convert.ToInt32(Console.ReadLine()); velocidades[indice] = dato; } // modifica un valor existente if (opcion == 5) { Console.Write("Ingrese la posicion de la Velocidad a Insertar: "); indice = Convert.ToInt32(Console.ReadLine());


Console.Write("Ingrese el valor de la Velocidad a Insertar: "); dato = Convert.ToInt32(Console.ReadLine()); velocidades.Insert(indice, dato); }

// Elimina un valor existente if (opcion == 6) { Console.Write("Ingrese la posicion de la Velocidad a Eliminar: "); indice = Convert.ToInt32(Console.ReadLine()); velocidades.RemoveAt(indice); } // localiza la posicion de un valor existente if (opcion == 7) { Console.Write("Ingrese la Velocidad a Localizar: "); dato = Convert.ToInt32(Console.ReadLine()); indice = velocidades.IndexOf(dato); Console.WriteLine("La velocidad {1} esta ubicada en la posicion {0} es {1}", indice, dato); }

// Borra el contenido de la lista if (opcion == 8) { velocidades.Clear(); Console.WriteLine("Se eliminaron todos las velocidades"); } } while (opcion != 9); // sale de la aplicacion

} static void Muestra(ArrayList arreglo) { Console.WriteLine(" **** Listado de Velocidades ****"); foreach(int auxvelocidad in arreglo) { Console.WriteLine("Velocidades: {0}",auxvelocidad ); } Console.WriteLine(" **** Fin del Listado de Velocidades ****"); } }}


Colección Stack.Otro tipo de colección conocida es la Stack o Pila, al igual que la lista nos

va a permitir operar dinámicamente, pero con la salvedad que esta colección trabaja en forma diferente.

El Stack es una estructura de tipo LIFO (last in first out), es decir que el primer elemento que entra es el último en salir. Los datos ingresados se irán apilando uno arriba de otro.

Para crear un Stack, deberemos instanciarlo al igual que hicimos con otros objetos. Y dentro de la clase Stack, encontraremos varios métodos para el manejo de los elementos que lo compongan.

Stack arreglopila = new Stack();

Push(). Ingreso de datos.El método para colocar un nuevo dato se denomina Push(). Este método

colocará al nuevo dato en la parte superior de la pila. Solo necesita un parámetro que es el valor del dato que se quiere ingresar.

Por ejemplo:

arreglopila.Push(5);

Pop(). Toma un valor.El método Pop(), lo utilizaremos para tomar un dato (el que se encuentra

en la parte superior). Luego de la operación, se elimina el dato de la lista.


posee el Stack. Devuelve un valor entero.

int cantidad = 0; cantidad = arreglopila.Count;

Clear(). Elimina Todos los elementos.Con clear() se eliminara todos los elementos que contenga el Stack. arreglopila.Clear();

Contains(). Indica la existencia de un elemento.Con el método Contains(), podremos determina si existe un elemento

dentro de la pila. Para eso, lo único que necesitamos es un parámetro; el valor del elemento a buscar, y la función nos devuelve un valor de tipo booleano (true o false).


bool esta = false; esta = arreglopila.Contains(9);

Console.WriteLine("la existencia es {0}", esta);

foreach. Utilizaremos este ciclo para ver los elementos de las colecciones que

estamos desarrollando.

Haremos un pequeño programa que nos muestre lo aprendido con respecto a la colección Stack.

Esta aplicación, añade 5 valores a una pila y aplica los métodos recién vistos.


namespace aplicacionstack{ class Program { static void Main(string[] args) { // declaracion de variable int cantidad = 0; bool esta = false;

// declaracion del Stack Stack arreglopila = new Stack(); arreglopila.Push(1); arreglopila.Push(3); arreglopila.Push(5); arreglopila.Push(7); arreglopila.Push(9); Mostrar(arreglopila); // muestra la pila esta = arreglopila.Contains(9); Console.WriteLine("la existencia es {0}",esta); arreglopila.Pop(); // elimina el primer valor Console.WriteLine("luego del Pop()."); Mostrar(arreglopila); cantidad = arreglopila.Count; Console.WriteLine("Cantidad de elementos: {0}",cantidad); arreglopila.Clear(); Console.WriteLine("luego del Clear()."); cantidad = arreglopila.Count; Console.WriteLine("Cantidad de elementos: {0}", cantidad);

} static void Mostrar(Stack pila) { foreach(int elemento in pila) {


Console.WriteLine("el elemento de la pila es {0}",elemento); } } }}

Colección Queue.La colección siguiente se conoce con el nombre Queue o cola. La

manera en que trabaja es la siguiente, va acumulando los valores en una cola es decir uno tras el otro.

Para declarar un Queue(), lo haremos de la siguiente manera:

Queue arreglocola = new Queue();

Una vez que esta instanciado, podremos hacer uso de los métodos que nos provee la clase.

Enqueue(). Ingresa nuevo valorPara ingresar un nuevo elemento a la cola, utilizaremos este método,

Enqueue(). Lo dispondrá al final y solo requiere un parámetro el valor que deseamos incorporar a la cola.

Ejemplo:arreglocola.Enqueue(109);

Dequeue(). Extrae un valorPara extraer un elemento de la cola utilizaremos el método Dequeue().

Tomará el primer valor ingresado, o el que se encuentra en la parte superior o al inicio.

arreglocola.Dequeue();

Contains(). Indica la existencia de un elemento.


Con el método Contains(), podemos determinar si existe o no, un elemento dentro de la cola. Para eso, lo único que necesitamos es un parámetro que es el valor del elemento a buscar y la función nos devolverá un valor booleano (true o false).

bool esta = false;esta = arreglocola.Contains(5);


posee el Queue. Devuelve un valor entero.

int cantidad = 0; cantidad = arreglocola.Count;

Clear(). Elimina Todos los elementos.Con Clear() se eliminara todos los elementos que contenga el Queue.

arreglocola.Clear();

foreach. Una vez más, utilizaremos este ciclo para ver los elementos de las

colecciones que estamos desarrollando.

Probaremos los métodos vistos en una colección del tipo Queue.

Una vez ingresados 5 valores, probar los métodos enunciados.


namespace aplicacionqueue{ class Program { static void Main(string[] args) { // definicion de variables bool esta = false; int cantidad = 0;

// definicion del Queue Queue arreglocola = new Queue(); arreglocola.Enqueue(1); arreglocola.Enqueue(3); arreglocola.Enqueue(5); arreglocola.Enqueue(7);


arreglocola.Enqueue(9); Mostrar(arreglocola); arreglocola.Dequeue(); Console.WriteLine("luego de Dequeue"); // luego de dequeue Mostrar(arreglocola); //indica si esta el valor 5 esta = arreglocola.Contains(5); if (esta) { Console.WriteLine("el valor 5 esta en la cola"); } else { Console.WriteLine("el valor 5 no esta en la cola"); } arreglocola.Clear(); cantidad = arreglocola.Count; Console.WriteLine("Existen {0} valores en el Queue.",cantidad); } static void Mostrar(Queue arreglo) { foreach(int elemento in arreglo) { Console.WriteLine("el elemento es: {0}", elemento); } } }}

Colección HashtableEsta última colección de datos que veremos en este texto, es la más

compleja, su nombre es Hashtable. Es una colección indexada, es decir, que deberemos tener en todo momento un índice (Key o llave) y un valor (value) referenciado a este.

La declaración del Hashtable es la siguiente:

Hashtable arregloindexado = new Hashtable();

Add(). Agrega un elemento.


Podemos agregar cualquier cantidad de elementos a la colección solo bastará utilizar el método Add(). Aquí vamos a necesitar 2 parámetros, el primero es el Key o índice que será usado para indexar el elemento (puede ser de cualquier tipo) y el segundo será el valor a insertar.

Ejemplo:

arregloindexado.Add("carlos", 18);

foreach. Una vez más, utilizaremos este ciclo para ver los elementos de las

colecciones que estamos desarrollando. Pero, deberemos hacer uso de una clase denominada DictionaryEntry pues deberemos guardar pareja de datos (key - value);

El formato es el siguiente:

foreach(DictionaryEntry datos in arreglo) { Console.WriteLine("indice {0} elemento {1}",datos.Key, datos.Value);

}

Clear(). Elimina Todos los elementos.Con Clear(), se eliminará todos los elementos que contenga la colección

Hashtable. arregloindexado.Clear();

Contains(). Indica la existencia de un elemento.Con el método Contains(), podremos determinar si existe o no un

elemento dentro de esta colección indexada. Para eso, lo único que necesitamos, es un parámetro el valor del elemento a buscar y la función nos devuelve un valor booleano (true o false).

bool esta = false;esta = arregloindexado.Contains(“carlos”);


posee el Hashtable. Devuelve un valor entero.

int cantidad = 0; cantidad = arregloindexado.Count;

Remove(). Elimina un elemento.


Para eliminar un elemento del arreglo indexado utilizaremos el método Remove(). Para llevar poder eliminar necesitamos conocer el índice, que será utilizado como parámetro.

arregloindexado.Remove(3);

Realicemos un ejemplo para ver este caso de colección.

Una vez ingresados 5 valores, probemos los métodos enunciados en el siguiente ejemplo.


namespace aplicacionhashtable{ class Program { static void Main(string[] args) { // declaracion de variables bool existe = false; int cantidad = 0; //declaracion de la coleccion Hashtable Hashtable arregloindexado = new Hashtable(); arregloindexado.Add("carlos", 18); arregloindexado.Add("martin", 17); arregloindexado.Add("daniela",15); arregloindexado.Add("mariano",10); arregloindexado.Add("silvina",16); Mostrar(arregloindexado); // invocacion de la funcion para mostrar

existe = arregloindexado.Contains("carlos"); Console.WriteLine("El señor Carlos su existencia es {0}", existe);

arregloindexado.Remove("carlos"); Mostrar(arregloindexado); cantidad = arregloindexado.Count; Console.WriteLine("Hay {0} elementos", cantidad);

arregloindexado.Clear();// borro todos los elementos cantidad = arregloindexado.Count; Console.WriteLine("luego de Clear() Hay {0} elementos", cantidad);

} static void Mostrar(Hashtable arreglo) { foreach(DictionaryEntry datos in arreglo) {


Console.WriteLine("indice {0} elemento {1}",datos.Key, datos.Value); } } }}

Hemos visto en esta unidad que las colecciones nos permiten guardar elementos, y a diferencia a los arreglos lo podemos hacer en forma dinámica.

Vimos también diferentes colecciones, y cada una de ellas posee diferentes métodos para llevar a cabo las diferentes operaciones según la necesidad del desarrollo a realizar.

El tema no está agotado, pues existen más tipo de colecciones y métodos. Es tarea de ustedes profundizar sobre ellos, en la actualidad, existen gran cantidad de bibliografía y páginas web sobre este tema.



A. Realizar un programa que calcule el promedio, el valor máximo, y el valor mínimo de las medidas de varillas ingresadas por el usuario. Realizarlo con ArrayList.

B. Realizar un programa que pueda ser utilizado como un diccionario (palabra - definición). Utilizar Hashtable.


Unidad 8

Las Cadenas.

Las cadenas nos permiten manipular y guardar la información en formatos adecuados para nuestra aplicación. C# no provee una clase con diversos métodos denominado String, en su interior la cadena se comporta como una colección y cada elemento que conforma la cadena es un elemento.

Para declarar una cadena, creamos una nueva instancia de la clase String y le asignamos el valor que va contener entre comillas. Ejemplo:

string nuestracadena = "seguimos programando en c#";

ToString()

El método ToString() lo usaremos para convertir el tipo de dato en cadena, para luego desplegarlo para que el usuario.

La cadena de un valor entero la podemos convertir a cadena de la siguiente manera:

int valor = 890; string cadena = valor.ToString();

Console.WriteLine("nueva cadena {0}",cadena);

Un uso bastante común es con la clase DateTime, que nos provee hora, día, mes, etc.

DateTime ahora = DateTime.Now;

Now es una propiedad que nos provee la hora y día del sistema, el paso a seguir es otorgarle un formato, para eso de la clase String usaremos el método Format() y los especificadores de formato.

Especificador Descripciónd Día del mes.dd Día del mes con 2 dígitos. ddd Presenta el nombre del día abreviado.dddd Nombre del día completo.h Hora en el rango 1 a 12.hh Hora en el rango 01 a 12.H Hora en el rango 0 a 23.HH Hora en el rango de 0 ,01 a 23.m Minutos 1 a 60.mm Minutos 01 a 60.M Meses 1 a 12.MM Meses de 01 a 12.MMM Nombre del mes pero abreviado.MMMM Nombre del mes completo.s Segundos 1 a 60.ss Segundos 01 a 60.


t Despliega A o P según corresponda Am o PM.tt Despliega AM o PM, según correspondayyyy Muestra el año.

Si deseamos tener una cadena que muestre la fecha y hora actual, la podemos mostrar de la siguiente manera.

string formatofecha = ""; formatofecha = String.Format("la fecha de hoy es: {0:dddd dd MMMM yyyy}",DateTime.Now);

Console.WriteLine("{0}",formatofecha);

También tenemos especificadores de formato para los valores numéricos, ellos son:

Especificador Descripción# Digito.. Punto decimal., Separé miles. % Porcentaje.EO Notación científica. ; Separador de secciones si el valor es positivo,

negativo o cero. Dos secciones, una para positivo y el cero y la otra para los negativos.3 secciones positivos, negativos y cero.

Veamos un ejemplo:

float valor = 0.0f; string formatovalor= string.Format("{0: $#,###0.00;Neg $#,###0.00;Cero}",valor); Console.WriteLine("El valor es: {0}", formatovalor); valor = 12155.25f; formatovalor = string.Format("{0: $#,###0.00;Neg $#,###0.00;Cero}", valor); Console.WriteLine("El valor es: {0}", formatovalor); valor = -4562.125f; formatovalor = string.Format("{0: $#,###0.00;Neg $#,###0.00;Cero}", valor);

Console.WriteLine("El valor es: {0}", formatovalor);


Concatenación.

Otra manipulación muy útil con las cadenas es la concatenación, es decir unir dos o más cadenas, para eso podemos utilizar:

El símbolo +.

String minombre = "gustavo"; String miapellido = "romay"; String minombrecompleto = minombre + " " + miapellido; Console.WriteLine("Mi nombre y Apellido es {0}", minombrecompleto);

El método Concat().

Pertenece a la clase String y solo requiere de 2 parámetros que son las cadenas que deseamos concatenar. Este regresa una cadena.

minombrecompleto = String.Concat(minombre, miapellido);

Permite realizar una concatenación múltiple.

minombrecompleto = String.Concat(minombre,String.Concat(" ",miapellido));

StringBuilder.

Otra clase que provee C# es StringBuilder. Esta nos permite construir cadenas eficientes, utilizarla en concatenaciones, posee propiedades útiles, etc.

Propiedades del StringBuilder.

Length

Obtiene la longitud.

int cantidad=0; StringBuilder cadena = new StringBuilder("buen dia para programar"); cantidad = cadena.Length; Console.WriteLine("Cantidad de caracteres: {0}", cantidad);

Append()

Lleva a cabo una concatenación.

StringBuilder cadena = new StringBuilder("buen dia para programar");


cadena.Append(" y nos acompañamos con un rico cafe."); Console.WriteLine("Cadena concatenada: {0}", cadena);

Appendformat()

Permite concatenar y formatear una salida al igual que los hace writeline(). Para eso primero colocamos la cadena de forma y en el segundo lugar la lista de variables a utilizar.

StringBuilder nuevacadena = new StringBuilder("producto mas vendido");int precio = 45;string producto = "dvd";nuevacadena.AppendFormat("fue el {0} a un precio de {1}", producto, precio);Console.WriteLine("Cadena concatenada: {0}", nuevacadena);

ToString()

Es uno de los métodos más importante de esta clase, nos permite convertir un StringBuilder en una cadena. Para usarlo solo debemos hacer una sencilla asignación nueva cadena y luego de aplicar el método en la nuevacadena tendrá en su interior la cadena creada.

StringBuilder cadenafinal = new StringBuilder("cadena declarada StringBuilder");string nuevacadena = "";nuevacadena = cadenafinal.ToString();Console.WriteLine("Cadena final: {0}", nuevacadena);

Compare()

Para realizar comparaciones entre cadenas, podemos utilizar el método Compare(). Este método necesita 2 parámetros, que son las cadenas a comparar y regresa un valor entero indicando el grado de relación que existen


entre las cadenas (0 cadenas iguales, negativo cadena1 menor que cadena2 y si es positivo cadena 1 mayor que cadena 2).

int auxcomparacion = 0;string cadena1 = "buen dia para programar";auxcomparacion = string.Compare("unidad 8", cadena1);if (auxcomparacion == 0) Console.WriteLine("son dos cadenas iguales");else Console.WriteLine("NO son dos cadenas iguales");

En este método no hizo falta declarar un objeto de tipo String.

Equals()

También podemos realizar comparaciones entre 2 cadenas, utilizando el método Equals(). Este método necesita 2 parámetros, que son las cadenas a comparar y regresa un valor booleano indicando el grado de relación que existen entre las dos cadenas (true cadenas iguales y false cadenas distintas).

bool auxcomparacion = false; string cadena1 = "buen dia"; auxcomparacion = string.Equals("buen dia", cadena1); if (auxcomparacion == true) Console.WriteLine("son dos cadenas iguales"); else

Console.WriteLine("NO son dos cadenas iguales");

Contains()

Si deseamos saber si una subcadena esta dentro de otra cadena principal, utilizaremos el método Contains(). Este método debe ser invocado desde la cadena a la que se realizara la búsqueda, por o tanto solo va a necesitar un parámetro (la subcadena a buscar). El método regresa un bool, si encontró la cadena regresara true en caso contrario false. Tengan en cuenta que es sensible a mayúsculas y minúsculas. Un ejemplo:

bool auxcomparacion = false;string cadenacompleta = "radio tv dvd video";string abuscar = "dvd";auxcomparacion = cadenacompleta.Contains(abuscar);if (auxcomparacion == true) Console.WriteLine("la ha encontrado");else Console.WriteLine("NO la ha encontrado");

Substring().


Este método el Substring() nos va permitir extraer una subcadena, de una cadena principal. Harán falta 2 parámetros de tipo enteros, el primero indica el índice adentro de la cadena principal, y el segundo es la cantidad de caracteres que tiene la subcadena. Por lo tanto el método regresa una cadena que contiene la subcadena obtenida.

string cadenaprincipal = "esta es una cadena de prueba";string resultado = "";resultado = cadenaprincipal.Substring(22,6);Console.WriteLine("subcadena : {0}", resultado);

EndsWith()

También es posible saber si una cadena finaliza en una subcadena en particular (termina con una palabra determinada, punto y aparte, etc.), para eso hacemos uso del método EndsWith(). Solo necesitará un parámetro que es la cadena que debe buscar y devolverá un bool.

string cadenaprincipal = "esta es una cadena de prueba"; bool resultado = false; resultado = cadenaprincipal.EndsWith("prueba"); if(resultado==true) Console.WriteLine("La cadena termina con prueba"); else

Console.WriteLine("La cadena NO termina con prueba");

CopyTo()

En algunas aplicaciones va ser necesario obtener una copia de una parte en particular de una cadena, para eso usaremos el método CopyTo(). Este método necesita 4 parámetros y no devuelve ningún valor. Si extrae una cadena y se coloca en un arreglo de tipo Char.

El primer parámetro indica en la cadena principal a partir donde se empezara a copiar.

El segundo parámetros es la cadena tipo Char, donde se va alojar la cadena que se extrae.

Con el tercer parámetro, es el índice que indica a partir de donde se copiara la cadena en el arreglo (podemos empezar en cualquier parte del arreglo no solo del inicio).


En cuarto y último parámetro indica la cantidad de caracteres que se copiaran.

Veamos un ejemplo:

int n=0; char[] arreglo = new Char[10]; string cadena = "seguimos programando en C#"; cadena.CopyTo(9,arreglo,0,8); for (n=0; n<=9;n++) { Console.Write("{0}",arreglo[n]);

}

Insert()

Va ser posible insertar una cadena en otra cadena existente. Esta tarea nos va ser útil cuando necesitemos agregar nueva información a un string y no nos baste con la concatenación o el formato.

Para eso usaremos el método Insert(), que para su uso necesita dos parámetros, uno indicando el índice donde a partir de que posición se insertara la cadena y el otro parámetro es la cadena a insertar que podrá ser insertada en forma explicita o por medio de una variable de tipo String.

Insert() regresa un valor tipo String, que seria la instancia de la nueva cadena con la inserción.

string cadenaprincipal = "Cuenta de ahorro Nro del Banco Nacion"; string cadenaainsertar = " 45-5623-1 "; string resultado = ""; resultado=cadenaprincipal.Insert(21,cadenaainsertar); Console.WriteLine("La cadena final queda: {0}",resultado);

LastIndexof()


El método LastIndexof() nos ayudara a encontrar determina subcadena dentro de otra cadena base, nos devolverá un valor entero correspondiente al índice de la ultima posición encontrada (). Presten atención, porque si la cadena posee varias ocurrencias solo tiene en cuenta la última.

int indice = 0;string cadenaprincipal = "Cuenta de ahorro Nro del Banco Nacion";indice = cadenaprincipal.LastIndexOf("Banco");Console.WriteLine("Banco esta en la posicion {0}.",indice);

PadLeft(). Justifica a la derecha

En caso de querer justificar el texto hacia la derecha, el método a utilizar es PadLeft(). Es decir insertaría espacios en blanco a la izquierda de la cadena original. Requiere un parámetro, que debe ser un valor entero correspondiente a la longitud de la cadena luego de insertar a la izquierda los espacios en blanco.

string cadenaprincipal = "Banco Nacion";string resultado = "";resultado = cadenaprincipal.PadLeft(20);Console.WriteLine("Cadena final ajustada a la derecha {0}.",resultado);

PadRight(). Justifica a la izquierda

Si queremos justificar el texto hacia la izquierda, el método a utilizar es PadRight(). Inserta espacios en blanco a la derecha de la cadena original. También va a requerir un parámetro, que debe ser un valor entero correspondiente a la longitud de la cadena luego de insertar a la derecha los espacios en blanco.

string cadenaprincipal = "Banco Nacion";string resultado = "";resultado = cadenaprincipal.PadRight(20);Console.WriteLine("Cadena final ajustada a la derecha {0} .", resultado);


Remove(). Elimina caracteres.

Para eliminar caracteres dentro de una cadena, C# utiliza el método Remove(). Para borrar parte de la cadena tendremos que utilizar 2 parámetros, uno indicando el índice a partir de cual van a empezar a eliminar los caracteres y el otro es la cantidad de caracteres que se intentara borrar. El método regresa una nueva cadena resultante luego de la eliminación.

string cadenaprincipal = "Banco Nacion";string resultado = "";resultado = cadenaprincipal.Remove(5,7);Console.WriteLine("Cadena final con los caracteres eliminados: {0}", resultado);

Replace(). Reemplaza en una cadena.

Para reemplazar una parte de la cadena principal por otra cadena, podemos utilizar el método Replace(). La gestión de este método, es compleja, pues deberá en primera instancia encontrar la cadena a reemplazar, luego eliminarla, y por ultimo insertar la nueva cadena. Se debe tener en cuenta que se realizará el reemplazo en las coincidencias que la cadena original tuviese.

Este método utiliza 2 parámetros, el primero es la cadena que se desea reemplazar, y el segundo es la cadena con que reemplazaremos. El método regresa una cadena resultante con el reemplaza llevado a cabo.

Un ejemplo va a aclarar este método.

string cadenaprincipal = "Banco Nacion"; string resultado = ""; resultado = cadenaprincipal.Replace("Nacion","Ciudad"); Console.WriteLine("Cadena final luego del reemplazo: {0}", resultado);


ToLower() convierte a minúscula.

Con este método convertimos a la cadena original con todos sus caracteres en minúscula. Esto nos va ayudar en las búsquedas al tener todos los caracteres en forma homogénea. Esta función no necesita ningún parámetro y devuelve la cadena convertida.

string cadenaprincipal = "Banco Nacion";string resultado = "";resultado = cadenaprincipal.ToLower();Console.WriteLine("Cadena final luego de la conversion: {0}", resultado);

ToUpper() convierte a mayúscula.

Con este método convertimos a la cadena original con todos sus caracteres en mayúscula.

string cadenaprincipal = "Banco Nacion"; string resultado = ""; resultado = cadenaprincipal.ToUpper(); Console.WriteLine("Cadena final luego de la conversion: {0}", resultado);

Trim() elimina espacios en blanco.

Con este método nos va permitir eliminar los espacios en blanco que se encuentre tanto al inicio como al final de la cadena. No necesita ningún parámetro y regresa una nueva cadena con los espacios suprimidos.

Para ver como se utiliza veamos un ejemplo:

string cadenaprincipal = " Banco Nacion "; string resultado = ""; Console.WriteLine("Cadena original: {0}", cadenaprincipal); resultado = cadenaprincipal.Trim(); Console.WriteLine("Cadena final luego de supresion de los espacios: {0}", resultado);


TrimStart() elimina espacios en blanco al inicio.

Con este método nos va permitir eliminar los espacios en blanco que se encuentre tanto al inicio de la cadena. Necesita un único parámetro, formado por un arreglo de caracteres que indica los caracteres que deseamos eliminar.

string cadenaprincipal = "XX Banco Nacion ";string resultado = "";Console.WriteLine("Cadena original: {0}", cadenaprincipal);resultado = cadenaprincipal.TrimStart(' ','X'); Console.WriteLine("Cadena final luego de supresion de los espacios: {0}", resultado);

TrimEnd() elimina espacios en blanco al final.

Con este método nos va permitir eliminar los espacios en blanco que se encuentre tanto al final de la cadena. Su funcionamiento es similar a TrimStart().

string cadenaprincipal = " Banco Nacion XX";string resultado = "";Console.WriteLine("Cadena original: {0}", cadenaprincipal);resultado = cadenaprincipal.TrimEnd(' ','X'); Console.WriteLine("Cadena final luego de supresion de los espacios: {0}", resultado);

En esta unidad hemos aprendido unas clases y métodos sobre la posibilidad que tiene C# para el manejo de cadenas. Sin duda que esto solo


una muestras de lo que provee este poderos lenguaje. Será de suma utilidad cuando empiecen a hacer aplicaciones reales, sobre todo en el manejo de base de datos.



A. Realizar un programa que permita al usuario ingresar una cadena y desde el menú pueda este seleccionar el formato que lo deberá mostrar (todo mayúscula, sin espacios, etc.)



Unidad 9

Estructuras y Enumeraciones.

Las estructuras son tipos de datos, definidos por el programador. Al crear una estructura de datos, estamos definiendo un nuevo tipo y dentro de el podremos colocar datos. Estos datos se conocen con el nombre de campo, que se representa por una variable con su respectivo tipo.

Una estructura conocido por todos es el de una agenda personal.

AgendaNombre StringDirección StringTeléfono StringEdad Edad

Para definir una estructura deberemos llevar los siguientes pasos:

Acceso struct nombre{Acceso tipo campo1;Acceso tipo campo1;…Acceso tipo campo n;}

El acceso indica en la estructura puede verse por afuera del ámbito en cual se ha definido, puede ser publica o privada (public o private). Si el tipo de acceso es publico, estaremos indicando que puedo ingresar a la estructura fuera del ámbito de donde fue creada, en caso contrario lo declararemos como privada.

La palabra struct indica que va ser una estructura, luego va seguido del nombre que va ser la identificación de la estructura. Y entre llaves estará dispuesto un bloque de código con la definición de los campos. De nuestro ejemplo, agenda se desprende la siguiente estructura.

El código de la estructura debe ir ubicado por encima de Main().


// declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public string direccion; public int edad; public string telefono;

}

Luego que hemos definido la estructura, se deberá definir sus variables para guardar información. Para definir una variable (amigos) solo nos basta saber el tipo, y en este caso el tipo lo acabamos de definir (Agenda), por lo tanto lo haremos de la siguiente manera:

Agenda.amigos;

A partir de ahora en la variable amigos se encuentran los campos nombre, dirección, edad y teléfonos.

Ahora tenemos que ver como hacemos para acceder a los campos para ingresar información, mostrar sus datos, etc.

Empecemos explicando como vamos a mostrar la información, pues teneos la complicación de posee campos de diferentes tipos. Por lo tanto haremos uso del método ToString(). Este debe estar: dentro del bloque código de la estructura, con acceso publico para ser invocado del exterior, regresar un String y no necesita ningún parámetro.

Dispongo del código – al menos como va quedando -

// declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public string direccion; public int edad; public string telefono; public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } }

Con override, le indicamos al compilador una nueva implementación que usará nuestra estructura creada por nosotros en lugar de la versión base.


También deberemos crear un arreglo de la estructura para ir colocar los datos que vamos a ingresar.

// declaracion de un arreglo Agenda[] amigos=new Agenda[15];

Ahora ya si podemos ingresar información, y lo haremos de la siguiente manera:

amigos[0].nombre = "GARCIA JUAN ALBERTO"; amigos[0].direccion = "BOEDO 789"; amigos[0].edad = 25;

amigos[0].telefono = "495-5623";

Y para mostrarlo, solo basta:

Console.WriteLine(amigos[0].ToString());

Ahora veamos el ejemplo dispuesto en forma completa:


namespace estructuraagenda{ class Program { // declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public string direccion; public int edad; public string telefono; public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } } static void Main(string[] args) { // declaracion de un arreglo Agenda[] amigos=new Agenda[15]; amigos[0].nombre = "GARCIA JUAN ALBERTO"; amigos[0].direccion = "BOEDO 789"; amigos[0].edad = 25; amigos[0].telefono = "4495-5623"; // muestra la informacion ingresada en la posicion 1era Console.WriteLine(amigos[0].ToString()); amigos[1].nombre = "PEREZ MARIO"; amigos[1].direccion = "COLOMBRES 485 DEPTO 3"; amigos[1].edad = 36;


amigos[1].telefono = "4602-8956"; // muestra la informacion ingresada en la posicion 2DA Console.WriteLine(amigos[1].ToString());

} }}

Los Constructores.

Una utilidad realmente importante, es la de poder crear un constructor para la estructura del ejemplo que estamos desarrollando.

Un constructor, es un método con características especiales, pues nos va permitir inicializar las variables, llevará el nombre de la estructura a la cual pertenece, se invoca automáticamente cuando llevamos a cabo el instanciamiento de la variable de la estructura, no posee tipo, debe contener al menos un parámetro, y tampoco regresa nada. Veamos un ejemplo:

public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; telefono = auxtelefono; }

Destaco que el acceso es público, pues lo vamos a invocar fuera de este ámbito donde fue declarado. El nombre Agenda, es igual a la estructura y luego sigue la lista de parámetros.

La declaración de la variable la podremos usar de la siguiente manera:

Agenda amigos = new Agenda("RODRIGUEZ MARIA", "MAZA 467", 29, "4896-

4523");

El código completo es el siguiente:


namespace estructuraagenda{ class Program {


// declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public string direccion; public int edad; public string telefono;

// constructor public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; telefono = auxtelefono; }

public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } } static void Main(string[] args) { Agenda amigos = new Agenda("RODRIGUEZ MARIA", "MAZA 467", 29, "4896-4523"); Console.WriteLine(amigos.ToString()); } }}

Y se visualiza de la siguiente manera:

Otra ventaja del constructor es la de poder validar la información que se ira ingresando. Sin duda que algunos de los campos de nuestra estructura, necesita de datos validados, ya sea un rango numérico para la edad, algún mensaje al no ingresar el domicilio, etc.

Para todo esto deberemos programar el constructor.

Empecemos verificando la longitud del campo teléfono, Este no pude ser mayor a 9 caracteres, si esto ocurriese ingresar un mensaje “Teléfono no valido”.

// constructor


public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono){ // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; if (auxtelefono.Length<=9) telefono = auxtelefono; else telefono = "Telefono no válido";}

Les muestro el código y he creado 2 nuevas variables de tipo Agenda.


namespace estructuraagenda{ class Program { // declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public string direccion; public int edad; public string telefono;

// constructor public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; if (auxtelefono.Length<=9) telefono = auxtelefono; else telefono = "Telefono no válido"; }

public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } } static void Main(string[] args) { // creamos una variable amigos tipo Agenda Agenda amigos = new Agenda("RODRIGUEZ MARIA", "MAZA 467", 29, "4896-4523"); Console.WriteLine(amigos.ToString()); // creamos una variable clientes tipo Agenda


Agenda clientes = new Agenda("COCA COLA S.A.", "CORRIENTES 126", 36, "5620-84520"); Console.WriteLine(clientes.ToString());

} }}

Luego de ejecutar, veríamos lo siguiente:

Sobrecarga del Constructor.

Los constructores poseen pueden ser sobrecargados, brindándonos de esta manera mayor flexibilidad. Por ejemplo si tuviésemos amigos que no tengan teléfono, no tendrían sentido hacer un nuevo constructor para estos casos, deberemos crear una sobrecarga. Pasemos a realizarla la sobrecarga modificando nuestro constructor original:



// constructor public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; if (auxtelefono.Length<=9) telefono = auxtelefono; else telefono = "Telefono no válido"; } // sobrecarga del constructor


public Agenda(string auxnombre, string auxdireccion, int auxedad) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; telefono = "Sin telefono"; } public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } } static void Main(string[] args) { // creamos una variable amigos tipo Agenda Agenda amigos = new Agenda("RODRIGUEZ MARIA", "MAZA 467", 29, "4896-4523"); // creamos una variable clientes tipo Agenda Agenda clientes = new Agenda("COCA COLA S.A.", "CORRIENTES 126", 36, "5620-84520"); // creamos una variable parientes tipo Agenda Agenda parientes = new Agenda("TIO JORGE", "BELGRANO 4562", 50);

Console.WriteLine(amigos.ToString()); Console.WriteLine(clientes.ToString()); Console.WriteLine(parientes.ToString());

} }}

Compilamos la aplicación y vemos lo siguiente:

Podemos hacer una sobrecarga, donde el usuario pueda ingresar la información de algunos de los campos.

Una vez que definamos la variable con el tipo Agenda, el compilar detecta la cantidad de parámetros y lo relaciona con el constructor con igual de parámetros correspondiente, en este caso solo enviaremos un parámetro.

Agenda empresas = new Agenda("ADIDAS");


El código de este ejemplo, es el siguiente:



// constructor public Agenda(string auxnombre, string auxdireccion, int auxedad, string auxtelefono) { // llevamos a cabo la asgnacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; if (auxtelefono.Length<=9) telefono = auxtelefono; else telefono = "Telefono no válido"; } // Sobrecarga del constructor - Sin telefono public Agenda(string auxnombre, string auxdireccion, int auxedad) { // llevamos a cabo la asignacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; telefono = "Sin telefono"; }

// Sobrecarga del constructor // Solicta direccion,edad y telefono public Agenda(string auxnombre) { // llevamos a cabo la asignacion del nombre nombre = auxnombre; // pedimos la direccion Console.Write("ingrese la direccion:"); direccion = Console.ReadLine(); // pedimos la edad Console.Write("ingrese la edad:"); edad = Convert.ToInt32(Console.ReadLine()); // pedimos el Telefono Console.Write("ingrese el Telefono:"); telefono = Console.ReadLine(); if (telefono.Length > 9) telefono = "Telefono no válido"; }


public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0}, Direccion: {1}, Edad: {2}, Telefono: {3}",nombre,direccion,edad,telefono); return (sb.ToString()); } } static void Main(string[] args) { // creamos una variable amigos tipo Agenda Agenda amigos = new Agenda("RODRIGUEZ MARIA", "MAZA 467", 29, "4896-4523"); // creamos una variable clientes tipo Agenda Agenda clientes = new Agenda("COCA COLA S.A.", "CORRIENTES 126", 36, "5620-84520"); // creamos una variable parientes tipo Agenda Agenda parientes = new Agenda("TIO JORGE", "BELGRANO 4562", 50); // creamos una variable empresas tipo agenda Agenda empresas = new Agenda("ADIDAS"); Console.WriteLine(amigos.ToString()); Console.WriteLine(clientes.ToString()); Console.WriteLine(parientes.ToString()); Console.WriteLine(empresas.ToString());

} }}

La consola nos muestra:

Estructuras entrelazadas.Las estructuras también nos dan la posibilidad de poder agrupar

información relacionada dentro de un mismo elemento. En nuestro ejemplo el campo dirección puede desglosarlo en 2 campos nuevos calle y número.

La estructura quedaría de la siguiente forma:

// declaracion de estructura de direccion public struct domicilio {


public string calle; public int numero;

public domicilio(string auxcalle, indexer auxnumero) { calle = auxcalle; numero = auxnumero; } }

Lo he hecho de la misma manera que cuando creamos la estructura de Agenda, además cree el constructor para ayudarnos a colocar la información cuando se instancie una variable de este tipo.

Ahora ya podemos usarlo en la estructura Agenda, pero deberemos hacer algunos cambios.

public struct Agenda { public string nombre; public int edad; public string telefono;

public domicilio direccion;

…

Solo definimos la variable y al tipo que corresponde (public domicilio direccion). Pero nos falta instancia el campo dirección, y eso lo haremos cuando se asignan datos en el constructor.

public Agenda(string auxnombre, string auxdireccion, int auxedad) { // llevamos a cabo la asignacion nombre = auxnombre; direccion = auxdireccion; edad = auxedad; telefono = "Sin telefono"; direccion = new domicilio("Sin direccion", 0); }

No debemos olvidar de modificar la sobrecarga y el método ToString() donde lo utilizamos para visualizar los datos.

Una vez que lo hemos modificado debería verse el código de la siguiente manera:


namespace estructuraagenda{ class Program { // declaracion de estructura de direccion public struct Direccion


{ public string calle; public int numero;

public Direccion(string auxcalle, int auxnumero) { calle = auxcalle; numero = auxnumero; }

public override String ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Direccion: {0} nro {1}", calle, numero); return (sb.ToString()); }

} // declaracion de la estructura de la Agenda public struct Agenda { public string nombre; public int edad; public string telefono; public Direccion domicilio;

// constructor public Agenda(string auxnombre, int auxedad, string auxtelefono, string auxcalle, int auxnumero) { // llevamos a cabo la asignacion nombre = auxnombre; edad = auxedad; if (auxtelefono.Length<=9) telefono = auxtelefono; else telefono = "Telefono no válido"; domicilio = new Direccion(auxcalle,auxnumero);

} // Sobrecarga del constructor - Sin telefono public Agenda(string auxnombre,int auxedad) { // llevamos a cabo la asignacion nombre = auxnombre; edad = auxedad; telefono = "Sin telefono"; domicilio = new Direccion("Sin direccion", 0); }

// Sobrecarga del constructor // Solicita direccion,edad y telefono public Agenda(string auxnombre) { // llevamos a cabo la asignacion del nombre nombre = auxnombre; // pedimos la edad Console.Write("ingrese la edad:"); edad = Convert.ToInt32(Console.ReadLine()); // pedimos el Telefono Console.Write("ingrese el Telefono:");


telefono = Console.ReadLine(); if (telefono.Length > 9) telefono = "Telefono no válido"; // pedimos la calle del domicilio Console.Write("ingrese la calle:"); domicilio.calle= Console.ReadLine(); // pedimos el numero de la calle del domicilio Console.Write("ingrese Numero:"); domicilio.numero = Convert.ToInt32(Console.ReadLine()); domicilio = new Direccion(domicilio.calle, domicilio.numero); }

public override String ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Nombre: {0},Edad: {1}, Telefono: {2}",nombre,edad,telefono); // adicionamo la cadena que viene de direccion sb.Append(domicilio.ToString()); return (sb.ToString());

} } static void Main(string[] args) { // creamos una variable amigos tipo Agenda Agenda amigos = new Agenda("RODRIGUEZ MARIA",29,"4896-4523","Av. INDEPENDENCIA",3565); // creamos una variable clientes tipo Agenda Agenda clientes = new Agenda("COCA COLA S.A.",36,"5620-84520","RIVADAVIA",124); // creamos una variable parientes tipo Agenda Agenda parientes = new Agenda("TIO JORGE", 50); // creamos una variable empresas tipo agenda Agenda empresas = new Agenda("ADIDAS"); Console.WriteLine(amigos.ToString()); Console.WriteLine(clientes.ToString()); Console.WriteLine(parientes.ToString()); Console.WriteLine(empresas.ToString());

} }}

La visualización por consola es:


Enumeraciones.

Existe una tipo de estructura denominada enumeración, esta tiene la característica que es finita (numero determinado de elementos con su respectivo tipo). Tiene el beneficio de reducir la lógica, mejora el desempeño de la aplicación, etc.

Vamos utilizar esta estructura cuando conozcamos los valores y la cantidad de los mismos, por ejemplo, los meses, los días de la semana, etc.

Hagamos un ejemplo donde necesitemos guardar los días de la semana:

Para declararla y asignarle los valores, debemos aplicar el siguiente formato:

enum nombre{valor 1,valor 2,…,valor n};

En primer lugar vemos enum, es la palabra clave para definir las enumeraciones, luego nombre que es la forma de denominar la enumeración y por ultimo cerradas con llaves {}, los valores. Hay que tener en cuenta que el valor de la primera posición es 0.

Ejemplo:

Enum diassemana {lunes, martes, miércoles, jueves, viernes, sábado, domingo};

Si queremos que la enumeración parta de la posición 1, la estructura es la siguiente:

Enum diassemana {lunes=1, martes, miércoles, jueves, viernes, sábado, domingo};

Luego se crea la variable:

diassemana midia;

Declaramos a la variable midia de tipo diassemana.

Y por ultimo la tenemos que inicializar:

midia=diassemana.viernes;

También podemos crear e inicializar la variable en una sola línea:

diassemana midia= diassemana.viernes;

Para pasar de enumeración a valor numérico vamos a utilizar un type cast.

Int valor=0;Valor= (int)midia;


También las enumeraciones las podemos utilizar en expresiones aritméticas y lógicas.

Sueldo=600*((int)midia);

If (midia==diassemana.martes)

If ((int)midia==4)

If (midia==diassemana.martes && (int)midia<4)

Veamos un ejemplo de aplicación, utilizando las enumeraciones.


namespace estructuraenumeracion{ class Program { // declaracion de las enumeraciones enum diassemana {lunes,martes,miercoles,jueves,viernes,sabado,domingo}; enum mesdelaño {enero,febrero,marzo,abril,mayo,junio,julio,agosto,septiembre,octubre,noviembre,diciembre};

static void Main(string[] args) { // declaracion de variables int numerico = 0; string mensaje = "El mes es "; // declaro variable tipo enumeracion diassemana midia; // inicializo midia = diassemana.domingo; numerico = (int)midia; Console.WriteLine("el dia {0} esta ubicado en {1} posicion",midia,numerico);

// declaro e inicializa mesdelaño mimes = mesdelaño.noviembre; numerico = (int)mimes; Console.WriteLine("el mes es {0} con la posicion {1}.",mimes,numerico );

mensaje = mensaje + mimes.ToString(); Console.WriteLine("{0}.", mensaje);

} }}


Las estructuras nos permiten crear un tipo nuevo de dato, que se ajusta a nuestras aplicaciones.

Además, podemos agruparlas frente a las necesidades del diseño de la información que surja para la optimización de los sistemas que debamos desarrollar.



1. Crear una estructura que nos permita guardar la información correspondiente a los productos de un negocio de electrodomésticos.

2. Crear una estructura para el manejo de una cuenta bancaria.

3. Crear una estructura enlazada con la información de las películas de un video club. (desglosar actores en 3 variables actor1,actor2 y actor3)


Unidad 10

Introducción a la programación orientada a objetos.

Las clases.

Tiempo Estimado:

En las unidades desarrolladas, hemos utilizado al C# para la programación estructura, a partir de ahora haremos un cambio de paradigma de programación, la Programación Orientada a Objetos (POO).

la POO posee mayor poder y por ende se obtendrá mayor beneficios, siendo una parte fundamental de esta las clases.

Hasta el momento os hemos majeado bastante bien con la programación estructura, pero tiene sus inconvenientes al desarrollar aplicaciones grandes, pues son difícil de mantener y extender cuando nuestro cliente desea agregar módulos, también es fácil que se corrompa la información al utilizar las variables en diferentes puntos del programa.

No obstante no desechemos la programación estructura porque nos ha servido para llegar a este punto aprendiendo las diferentes sentencias y el indicad para el armado de funciones o pequeños programas.

En este punto daré el punto de partida sobre POO con C#, debiendo luego comenzar un nivel avanzado de programación y profundizar el análisis de sistemas utilizando UML (lenguaje modificado de lenguaje).

Conceptos básicos de POO.En la POO tomamos la idea de resolver el problema observando cuales

son los componentes u objetos que componen el problema y la forma que interactúan. es decir que nosotros programaremos estos objetos y haremos que se comuniquen entre si. Cuando estos objetos se hayan creados, cumplan su función y se comuniquen, el problema estará resuelto.

Las clases.El componente principal de la POO es la clase. Una clase es una

definición abstracta de un Objeto. Siendo un objeto una entidad que puede representar absolutamente cualquier cosa, desde algo físico y tangible como


una persona, una factura o un auto, hasta cosas intangibles como la imaginación, un proceso químico o un algoritmo matemático.

Para aclarar estos conceptos podemos pensar que una clase es como un plano de arquitectura, que por el cual vamos a crear casas los objetos. Es decir que el plano – clase - nos muestra las características y el trabajo concreto que se llevara a cabo en las casas – objetos -.

Si deseamos hacer otra casa, no hará falta hacer otro plano, utilizaremos el mismo cuantas veces lo necesitemos. en caso de querer incluir alguna nueva característica, podemos tomar la clase creada, y agregar los nuevos elementos. Es decir que creamos una nueva clase a partir de una clase existente. Esto se denomina Herencia, definiendo es la posibilidad de crear una nueva clase que hereda las características (datos y métodos) de otra clase, de esta forma podemos reutilizar los código en forma adecuada.

El proceso de crear un objeto a partir de una clase lo vamos a denominar instanciamiento.

Dentro de la clase colocaremos la información y los métodos que trabajarán con esa información.

De lo dicho en el párrafo anterior, se entiende que la información o dato y los métodos que los procesan están contenidos en una misma unidad, a esto lo llamaremos encapsulamiento. Al encapsular los datos y los métodos evitamos la corrupción de la información.

Los objetos se comunican entre si por medio del uso de los mensajes. Un mensaje es el medio por el cual un objeto puede solicitar un dato, pedirle que lo lleve, llevar a cabo un proceso, etc.

Los datos.Ya habrán deducido que los datos son la información con que trabaja las

clases. Deberemos tener en cuenta:Los datos deben ser declarados e indicar el tipo de acceso.Existen tres tipos de acceso publico, privado o protegido. Un dato de

acceso publico, cualquier elemento del exterior de la clase; como la función Main() o algún otro objeto puede acceder al dado para leerlo y modificarlo. El tipo de acceso privado, solo los métodos dentro de la clase pueden acceder a los datos. El acceso protegido supera los límites de esta unidad, utilizando en programación avanzada.

Los datos definidos en la clase son conocidos por todos los métodos de la misma clase, es decir actúan como variables globales.

Los métodos de la clase, pueden acceder a los datos sin necesidad de parámetros.

Si los datos son privados, para acceder desde el exterior no seria posible, para eso deberemos usar una función de interfaz. Una función de interfaz es aquella que puede ser invocada desde el exterior y regresa una copia del valor de algún dato dentro del objeto o coloca un valor determinado en un dato. También permite administrar el acceso de la información colocando un código en C# que verifique o valide la información. Una vez nos permite asegurarnos que no existe corrupción.

Los métodos.Los métodos son funciones que llevan a cabo un proceso. A tener en

cuenta:Los procesos tienen una forma de acceso (publico, privado o protegido)Trabajan sobre los datos definidos en la clase.Todos los métodos de la clase, conocen todos los datos definida en ella.Pueden recibir parámetros u regresar valores.


Un dato definido en la clase, no hace falta pasarlo como parámetro al método, este ya lo conoce.

Es bueno programar los métodos de acceso público solo aquellos que necesitan ser accedidos desde el exterior.

Los métodos es invocado desde el interior deberá declarase como privado. Esto es por un tema se seguridad y utilizar el encapsulamiento en forma correcta.

Declaración de las clases

La declaración de las clases es un proceso sencillo. Tener en cuenta:

Deben declararse dentro de un namespace.

Posee la siguiente estructura.

class nombre { // definicion de datos ... // definicion de metodos ... }

El nombre de la clase puede ser cualquier nombre valido dentro de C#, único dentro del namespace, se llevará a cabo la definición de los elementos por medio de un bloque de código.

Empezaremos a desarrollar un ejemplo, y en base a el, haremos diferentes acotaciones y explicaciones para profundizar el tema de clases.

Creemos una aplicación que nos permita calcular y mostrar el área y el volumen de cubos y prismas rectangulares.

Empecemos con el análisis, los objetos van a ser el cubo y el prisma rectangular. Ahora debemos deducir cuales serán los datos y los métodos, es decir, aquellos procesos que lo involucren.

A continuación dispongo de mi análisis y me he ayudado del UML para hacerlo. He diagramado la clase cubo y la de prisma.

Es un rectángulo dividido en tres áreas donde dispongo el nombre de la clase, los datos y los métodos. Además he agregado un símbolo mas (+) si la información va hacer publica y un signo menos (-) si esta va ser privada. He separa con dos puntos (:), el tipo de dato de cada una de ellas.

Cubo

+ lado:int+ area:int+ volumen:int

+ CalculoArea():void+CalculoVolumen():void


Prisma+ alto: int+ ancho:int+ area:int+ espesor: int+ volumen:int

+ CalculoArea():void+CalculoVolumen():void- AreaRectangulo():void

Y llego la hora de codificar las clases:

Empecemos ingresando los datos, dispuse el código completo para que vean donde se comienza a programar las clases.


namespace clasegeometria{ class cubo { // definicion de datos public int lado; public int area; public int volumen; //definicion de metodos } class prisma { // definicion de datos public int alto; public int ancho; public int area; public int espesor; public int volumen; //definicion de metodos

}


class Program { static void Main(string[] args) { } }}

Notemos que tenemos datos con igual nombre en diferentes clases, esto no será ningún problema, pues cuando se invoque la clase, solo esos datos se activaran.

Dispongamos de los métodos del cubo (luego seguimos con los métodos del prisma – si no lo han notado tengo un método con símbolo menos -).

Muestro la clase Cubo terminada:class cubo { // definicion de datos public int lado; public int area; public int volumen; //definicion de metodos // metodo del calculo del area del cubo public void CalculoArea() { area = (lado * lado) * 6; } // metodo del calculo del volumen del cubo public void CalculoVolumen() { volumen = (lado * lado * lado); }

}

Crear la instancia de mi Clase.Luego de tener la clase hay que construir el objeto micubo para comenzar

a trabajar. Es decir, que el paso que debemos dar es el de, Instanciar el objeto de la clase Cubo.

El código es el siguiente:

Cubo micubo = new Cubo();

Asignar valores al Dato.Luego de realizar la instancia, ya podemos trabajar con la clase. Vamos a

asignarle un valor al dato. El ejemplo es el siguiente: micubo.lado = 4;

Invocar un método.

Desde el exterior de la clase invocaremos a los métodos que son públicos, para eso disponemos del objeto y el método.

Ejemplo:


micubo.CalculoArea();

Mostrar los resultados.

Luego de calcular los datos ya los podemos mostrar, para eso podemos pensar que son variables normales indicando el objeto con el dato (siempre el

operador punto “.”).

Console.WriteLine("Area= {0}", micubo.area);

Hasta este momento el código desarrollado es:


namespace clasegeometria{ class Cubo { // definicion de datos public int lado; public int area; public int volumen; //definicion de metodos // metodo del calculo del area del cubo public void CalculoArea() { area = (lado * lado) * 6; } // metodo del calculo del volumen del cubo public void CalculoVolumen() { volumen = (lado * lado * lado); } } class Prisma { // definicion de datos del cubo public int alto; public int ancho; public int area; public int espesor; public int volumen; //definicion de metodos } class Program { static void Main(string[] args) { Cubo micubo = new Cubo(); micubo.lado = 4; micubo.CalculoArea(); micubo.CalculoVolumen(); Console.WriteLine("Información del Cubo. Valor del Lado= {0} Area= {1} Volumen= {2}",micubo.lado ,micubo.area,micubo.volumen);


} }}

Visualizamos por consola:

La clase Cubo tiene todos sus datos públicos, si quisiéramos proteger los datos para hacerlo privados deberíamos utilizar una función de interfaz. Para eso vamos a practicar sobre la clase Prisma.

Para proteger los datos los pasos a seguir son:

Cambiar el acceso de los datos a privado.

class Prisma { // definicion de datos del prisma private int alto; private int ancho; private int area; private int espesor; private int volumen; //definicion de metodos

}

Las propiedades a incluir son funciones de interfaz, estas nos permitirá acceder a los datos en forma privada de una manera segura y controlada. La propiedad podrá ser de varios tipos:

Lectura – solo nos permite leer el dato y no agregarle información.

Escritura – nos permito solamente agregar información pero no leerla.

Lectura-escritura – permite llevarse a cabo ambas operaciones.

La propiedad tendrá 2 métodos, el relacionado con la lectura (Get) y el relacionado con la escritura (Set). La forma de declararla es la siguiente:

public tipo nombre { get { .... return x; } set { .... x=value; }


}

Las propiedades deben ser publicas `para poder ser llamadas del exterior de la clase.

Tipo – estará referenciado con el tipo de variable en uso.

Return – nos permite sacar el valor

Value – representa el valor que el usuario asigna.

Ahora si, empecemos a crear propiedades para la clase prisma. Para eso analicemos que necesita acceder por el exterior, y que tipo de acceso requiere y se hace falta validar el dato.

Dato Acceso validaciónAncho Lectura-escritura Dato >0, default 1alto Lectura-escritura Dato >0, default 1Espesor Lectura-escritura Dato >0, default 1Area LecturaVolumen lectura

Nuestras propiedades para cada uno de nuestros datos queda del siguiente modo:

//definicion de las propiedades -lectura y ecritura public int palto { get { return alto; } set { if (value <= 0) alto = 1; else alto = value; } }

public int pancho { get { return ancho; } set { if (value <= 0) ancho = 1; else ancho=value; } }

public int pespesor {


get { return espesor; } set { if (value <= 0) espesor = 1; else espesor = value; } } //definicion de las propiedades -lectura public int parea {

get { return area; } }

public int pvolumen { get { return volumen; } }

Para acceder a las propiedades, solo tenemos que colocar el objeto con el

queremos trabajar seguido del operador (.) y el nombre de la propiedad. El

valor que le queremos asignar lo haremos, previo símbolo de asignación (=).miprisma.pancho = 10;Para mostrar el valor de la propiedad:

Console.WriteLine("el Area es : {0}",miprisma.parea);

Me he adelantado a mostrarles, como si ingresa y como se muestra los datos, para ya nos ponemos a crear los métodos de la clase Prisma.

Una vez más analicemos que método será público (invocados desde el exterior) y cual es privado (invocado del interior de la clase), del análisis surge los siguientes:

Método AccesoCalculaVolumen() PublicoCalculaArea() PublicoAreaRectangulo() Privado

Incorporamos los métodos al código y nos queda:

El código es:



namespace clasegeometria{ class Cubo { // definicion de datos public int lado; public int area; public int volumen; //definicion de metodos // metodo del calculo del area del cubo public void CalculoArea() { area = (lado * lado) * 6; } // metodo del calculo del volumen del cubo public void CalculoVolumen() { volumen = (lado * lado * lado); } } class Prisma { // definicion de datos del prisma private int alto; private int ancho; private int area; private int espesor; private int volumen; //definicion de las propiedades -lectura y ecritura public int palto { get { return alto; } set { if (value <= 0) alto = 1; else alto = value; } }

public int pancho { get { return ancho; } set { if (value <= 0) ancho = 1; else ancho=value; } }


public int pespesor { get { return espesor; } set { if (value <= 0) espesor = 1; else espesor = value; } } //definicion de las propiedades -lectura public int parea {

get { return area; } }


// los metodos de la clase Prisma // metodo publico public void CalculaVolumen() { volumen = ancho * espesor * alto; }

public void CalculaArea() { int a1 = 0, a2 = 0, a3 = 0; a1 = 2 * AreaRectangulo(ancho,alto); a2 = 2 * AreaRectangulo(ancho,espesor); a3 = 2 * AreaRectangulo(alto,espesor); area = a1 + a2 + a3; } // metodo privado private int AreaRectangulo(int a, int b) { return (a * b); } } class Program { static void Main(string[] args) { // instanciamiento de la clase Cubo para crear un Objeto micubo


Cubo micubo = new Cubo(); micubo.lado = 4; micubo.CalculoArea(); micubo.CalculoVolumen(); Console.WriteLine("Información del Cubo. Valor del Lado= {0} Area= {1} Volumen= {2}",micubo.lado ,micubo.area,micubo.volumen); // instancimiento de la clase prisma para crear el objeto miprisma Prisma miprisma = new Prisma(); miprisma.pancho = 10; miprisma.palto = 10; miprisma.pespesor = 5; miprisma.CalculaArea(); miprisma.CalculaVolumen(); Console.WriteLine("En el Prisma el Ancho es : {0} el alto {1} el espesor {2}",miprisma.pancho,miprisma.palto,miprisma.pespesor); Console.WriteLine("el volumen del prisma es: {0}", miprisma.pvolumen); Console.WriteLine("el area del prisma es : {0}", miprisma.parea);

} }}

Por consola debemos ver:

Para mostrar la información de un objeto por consola, nos convendría crear un método dentro del objeto utilizando el método ToString(). Esto ya lo hemos usado en la unidad anterior, recordamos que regresa una cadena y no necesita ningún parámetro. Para ver su funcionamiento solo hace invocarlo, por lo tato el método debe tener acceso público. El código del mismo es el siguiente:public override string ToString(){ string mensaje = ""; mensaje += "información del Prisma - Ancho: " + ancho.ToString() + " Alto: " + alto.ToString() + " Espesor: " + espesor.ToString(); mensaje +=" su area: "+area.ToString()+" su volumen: "+volumen.ToString();return mensaje;}

La impresión del resultado se hará con la siguiente sentencia:

Console.WriteLine(miprisma.ToString());


Otro método para mostrar la información seria crear un método específico para eso. También debe ser de acceso público para ser invocado del exterior. Por ejemplo hagamos un método que solo imprima los resultados.

// metodo para mostrar resultadopublic void ImprimeResultado(){ Console.WriteLine("********************************************************************");Console.WriteLine("informacion del Resultado del Prisma es area: {0} y del Volumen {1}",area,volumen); Console.WriteLine("********************************************************************");}

Y para invocar el método, lo haremos de la siguiente forma:

miprisma.ImprimeResultado();

El constructor en las clases.Los constructores también pueden utilizarse dentro de las clases.

Generalmente lo vamos a utilizar para inicializar las valore de los datos con los que va atrabajar el objeto.

Muy importante: los constructores deben poseer el mismo nombre que la clase no posee tipo. No regresa nada. Se invoca en forma automática cuando el objeto es instanciado. Puede tener en su interior cualquier código con sentencias en C#. Puede tener parámetros.

Veamos un ejemplo de un constructor para la clase Prisma.

// constructores public Prisma() { // iniciacion de variables string valor = ""; // solictud de los datos del Prisma Console.WriteLine("ingrese el ancho del prisma:"); valor = Console.ReadLine(); ancho = Convert.ToInt32(valor); Console.WriteLine("ingrese el alto del prisma:"); valor = Console.ReadLine(); alto = Convert.ToInt32(valor); Console.WriteLine("ingrese el espesor del prisma:"); valor = Console.ReadLine(); espesor = Convert.ToInt32(valor); }

Una vez que lo hemos dispuesto dentro de la clase Prisma y luego de ejecutarse, nos va a pedir que el usuario ingrese los datos del prisma para luego mostrarnos el resultado.


Vemos el código que nos ha quedado:


namespace clasegeometria{ class Prisma { // definicion de datos del prisma private int alto; private int ancho; private int area; private int espesor; private int volumen; //definicion de las propiedades -lectura y ecritura public int palto { get { return alto; } set { if (value <= 0) alto = 1; else alto = value; } }

public int pancho { get { return ancho; } set { if (value <= 0) ancho = 1; else ancho = value; } }

public int pespesor { get { return espesor; } set { if (value <= 0) espesor = 1; else espesor = value; } }


//definicion de las propiedades -lectura public int parea {

get { return area; }

}


// constructores public Prisma() { // iniciacion de variables string valor = ""; // solictud de los datos del Prisma Console.WriteLine("ingrese el ancho del prisma:"); valor = Console.ReadLine(); ancho = Convert.ToInt32(valor); Console.WriteLine("ingrese el alto del prisma:"); valor = Console.ReadLine(); alto = Convert.ToInt32(valor); Console.WriteLine("ingrese el espesor del prisma:"); valor = Console.ReadLine(); espesor = Convert.ToInt32(valor); }


public void CalculaArea() { int a1 = 0, a2 = 0, a3 = 0; a1 = 2 * AreaRectangulo(ancho, alto); a2 = 2 * AreaRectangulo(ancho, espesor); a3 = 2 * AreaRectangulo(alto, espesor); area = a1 + a2 + a3;

} // metodo privado private int AreaRectangulo(int a, int b) { return (a * b); } // metodo para la impresion de la informacion del prisma rectangular public override string ToString() {


string mensaje = ""; mensaje += "información del Prisma - Ancho: " + ancho.ToString() + " Alto: " + alto.ToString() + " Espesor: " + espesor.ToString(); mensaje += " su area: " + area.ToString() + " su volumen: " + volumen.ToString(); return mensaje; } // metodo para mostrar resultado public void ImprimeResultado() { Console.WriteLine("********************************************************************"); Console.WriteLine("informacion del Resultado del Prisma es area: {0} y del Volumen {1}", area, volumen); Console.WriteLine("********************************************************************"); } }

class Program { static void Main(string[] args) { // instancimiento de la clase prisma para crear el objeto miprisma Prisma miprisma = new Prisma(); miprisma.CalculaArea(); miprisma.CalculaVolumen(); miprisma.ImprimeResultado();

} }}

La vista de la consola es la siguiente:

Sobrecarga del constructor en las clasesAquí también dentro de la clase el constructor puede sobrecargarse, es de

ir tener más de un aversión del constructor. Una vez más esto es útil para poder seleccionar como se inicializan nuestros datos de la clase. Una vez el compilador seleccionar el constructor a adecuado en función de los tipos y la cantidad de parámetros.


Ya tenemos un constructor que nos pide los tres valores (alto, ancho y el espesor), ahora hagamos un constructor que le podamos pasar los tres valores.

El código para mostrar la sobrecarga es el siguiente:


namespace clasegeometria{ class Prisma { // definicion de datos del prisma private int alto; private int ancho; private int area; private int espesor; private int volumen; //definicion de las propiedades -lectura y ecritura public int palto { get { return alto; } set { if (value <= 0) alto = 1; else alto = value; } }

public int pancho { get { return ancho; } set { if (value <= 0) ancho = 1; else ancho = value; } }

public int pespesor { get { return espesor; } set { if (value <= 0) espesor = 1; else


espesor = value; } }

//definicion de las propiedades -lectura public int parea {

get { return area; }

}


// constructores public Prisma() { // iniciacion de variables string valor = ""; // solictud de los datos del Prisma Console.WriteLine("ingrese el ancho del prisma:"); valor = Console.ReadLine(); ancho = Convert.ToInt32(valor); Console.WriteLine("ingrese el alto del prisma:"); valor = Console.ReadLine(); alto = Convert.ToInt32(valor); Console.WriteLine("ingrese el espesor del prisma:"); valor = Console.ReadLine(); espesor = Convert.ToInt32(valor); } // sobrecarga public Prisma(int auxancho, int auxalto, int auxespesor) { // asignamos los valores ancho=auxancho; alto=auxalto; espesor = auxespesor; }


public void CalculaArea() { int a1 = 0, a2 = 0, a3 = 0; a1 = 2 * AreaRectangulo(ancho, alto); a2 = 2 * AreaRectangulo(ancho, espesor); a3 = 2 * AreaRectangulo(alto, espesor);


area = a1 + a2 + a3;

} // metodo privado private int AreaRectangulo(int a, int b) { return (a * b); } // metodo para la impresion de la informacion del prisma rectangular public override string ToString() { string mensaje = ""; mensaje += "información del Prisma - Ancho: " + ancho.ToString() + " Alto: " + alto.ToString() + " Espesor: " + espesor.ToString(); mensaje += " su area: " + area.ToString() + " su volumen: " + volumen.ToString(); return mensaje; } // metodo para mostrar resultado public void ImprimeResultado() { Console.WriteLine("********************************************************************"); Console.WriteLine("informacion del Resultado del Prisma es area: {0} y del Volumen {1}", area, volumen); Console.WriteLine("********************************************************************"); } }

class Program { static void Main(string[] args) { // instancimiento de la clase prisma para crear el objeto miprisma Prisma miprisma = new Prisma(); miprisma.CalculaArea(); miprisma.CalculaVolumen(); miprisma.ImprimeResultado(); Prisma otroprisma = new Prisma(10,5,9); otroprisma.CalculaArea(); otroprisma.CalculaVolumen(); otroprisma.ImprimeResultado(); Console.WriteLine(otroprisma.ToString());

} }}

Por console debería verse lo siguiente:


Para finalizar esta unidad podemos decir que la programación orientada a objetos es un paradigma de programación realmente efectiva, que perdurar por unos cuantos años más.

Su elemento fundamental es la clase de ellas se instancias los objetos que son los que realmente hacen nuestro trabajo en las aplicaciones que vamos creando.



1. Crea el diseño de una clase para llevar el control de stock en una tienda de venta de instrumentos de música.

2. Crear la clase para optimizar la información de los alumnos de una escuela.

3. Crear una clase para la información de películas. Debe contener sobrecarga.



Unidad 11

Flujos y Archivos.

Tiempo Estimado:

Vamos a tren que hacer aplicaciones donde será importante guardar información y luego poder recuperarla. Para eso haremos uso del Streams.

El Streams es utilizado para mover información de la memoria a otra parte de la memoria, pero generalmente es utilizado para mover información a un dispositivo de almacenamiento como un disco rígido.

Deben saber que la información no es enviada en una sola operación, sino que se envía byte por byte en forma ordenada y secuencial gracias a un apuntador o indicador.

En el flujo de información encontramos tres puntos de referencia: Inicio del flujo. Final del flujo. Posición actual.

Empecemos a trabajar con los streams con las operaciones básicas que podemos realizar con ellos en memoria y luego en disco rígido. Vamos a trabajar con una clase denominada MemoryStream, deben verificar y si no existe agregar en la parte superior el namespace al que pertenece:

using System.IO;

Luego debemos saber que la información es guardada en un sitio en memoria. Para eso utilizaremos un arreglo con un tamaño particular y en bytes.

Lo hacemos de la siguiente manera:

// creamos un stream en memoria con una capacidad de 50 bytesMemoryStream cadenaflujo = new MemoryStream(50);

El objeto que hemos creado se denomina cadenaflujo y posee un tamaño de 50 bytes.

Información sobre el Streams.Vamos a ver la información que podemos obtener de cada Stream.

Información detalle PropiedadCapacidad Indica la cantidad que puede

almacenar. Es de tipo entero su resultado.

Capacity


Longitud Tamaño de la información dentro del Scream actualmente. El resultado e tipo long.

Length

posición Indica donde se encuentra el byte actual. E siguiente para ser procesado. También es de tipo long.

Position

Desarrollemos un ejemplo de cómo se puede obtener y mostrar la información del stream.

using System;using System.Collections.Generic;using System.Text;using System.IO;

namespace streammemoria{ class Program { static void Main(string[] args) { // creamos un stream en memoria con una capacidad de 50 bytes MemoryStream cadenaflujo = new MemoryStream(50); int capacidad = 0; long longitud = 0; long posicion = 0; capacidad = cadenaflujo.Capacity; longitud = cadenaflujo.Length; posicion = cadenaflujo.Position; Console.WriteLine("la capacidad del Stream es {0}",capacidad); Console.WriteLine("la longitud del Stream es {0}", longitud); Console.WriteLine("la posición del Stream es {0}", posicion);

} }}

Muestra por consola, lo siguiente.

Método Seek()

Una actividad importante es la de colocará el puntero en una posición determinada dentro del stream, para eso usaremos el método Seek(). Necesita


dos parámetros, el primero es la distancia desde el punto de referencia, y el segundo parámetro es el punto de referencia a utilizar.

El punto de referencia tiene que ser de tipo SeekOrigin y posee algunos de los tres puntos de referencias que hemos definido con anterioridad.

SeekOriginBegin Referenciado con le origen del Stream.Current Referencia la posición actual.End El punto de referencia es le final del

Stream.

Se usa de la siguiente manera:

////// aplicacion de Seek()cadenaflujo.Seek(0, SeekOrigin.Begin);// estamos a distancia 0 desde el inicio.cadenaflujo.Seek(8, SeekOrigin.Begin);// estamos 8 bytes de distancia del inicio.cadenaflujo.Seek(-5, SeekOrigin.End);// estamos 5 bytes antes del final.cadenaflujo.Seek(5, SeekOrigin.Current);// estamos 5 bytes a la derecha de la posicion actaul.cadenaflujo.Seek(-5, SeekOrigin.Current);// estamos 5 bytes a la izquierda de la posicion actaul.

Si intento ejecutar estas sentencias, a pesar que ya hemos creado el Stream, aun no lo hemos llenado, por lo tanto nos daría un error de excepción. Ya llegamos para llenar al Stream.

Método Read().Una vez que estamos posicionado en el Stream, queremos leer la

información que contiene (recordamos que se lee byte a byte), para eso utilizaremos el método Read(). Este método necesita 3 parámetros, el primer parámetro es un arreglo en bytes necesario para guardar la información leída por el Stream, el segundo nos da la oportunidad de colocar un offset para el arreglo en bytes (generalmente es 0, debido que queremos que la cadena de bytes del stream tomada, se coloque al inicio del arreglo). El tercer parámetro es la cantidad de bytes a leer.

Primero armemos el arreglo, lo he llamado arreglostream y posee una capacidad de 50 bytes.

byte[] arreglostream=new byte[50];

Ahora podemos utilizar el método read().

cadenaflujo.Read(arreglostream,0,5); // graba en el arreglo a partir de la posicion 0 los primero 5 valores bytes del stream.

Método Write() Con este método vamos a poder agregar información al Stream. El

método Write() utiliza tres parámetros, en el primer parámetro va el nombre del arreglo, en el segundo es la posición del stream donde empezamos a escribir (0 para el inicio del scream), y el tercer parámetro es para indicar la cantidad máxima de bytes que se escribirán.

cadenaflujo.Write(arreglostream,0,10);


Método Close()

Es muy importante, que al terminar de trabajar con los stream, deban cerrarse, para eso utilizamos el método Close(), de esta forma se liberan los recurso que se estaban utilizando. No posee ningún parámetro. La estructura es la siguiente:

cadenaflujo.Close();

Un ejemplo sobre Stream, va aclarar los métodos que hemos visto.

Realizar un programa donde el usuario ingrese una cadena, se disponga en un Stream y aplicar los métodos recientemente desarrollados.


namespace streammemoria{ class Program { static void Main(string[] args) { // creamos un stream en memoria con una capacidad de 50 bytes MemoryStream cadenaflujo = new MemoryStream(50); // definicion de variables a utilizar string informacion = ""; int capacidad = 0; long longitud = 0; long posicion = 0;

// armado del arreglo byte[] arreglostream = new byte[50];

// solicitud de informacion al usuario Console.Write("Ingrese la cdena para el Stream: "); informacion = Console.ReadLine(); // pasa la cadena al stream cadenaflujo.Write(ASCIIEncoding.ASCII.GetBytes(informacion),0,informacion.Length); // obtencion de informacion del Stream capacidad = cadenaflujo.Capacity; longitud = cadenaflujo.Length; posicion = cadenaflujo.Position; Console.WriteLine("****************************************"); Console.WriteLine("la capacidad del Stream es {0}",capacidad); Console.WriteLine("la longitud del Stream es {0}", longitud); Console.WriteLine("la posición del Stream es {0}", posicion);


Console.WriteLine("****************************************"); // aplicacion de Seek() cadenaflujo.Seek(0, SeekOrigin.Begin);// estamos a distancia 0 desde el inicio. cadenaflujo.Read(arreglostream, 0, 5); // graba en el arreglo a partir de la posicion 0 los primero 5 valores bytes del stream. // mostramos la cadena Console.WriteLine(ASCIIEncoding.ASCII.GetString(arreglostream));

// otra aplicacion de Seek() y mostramos la cadena cadenaflujo.Seek(12, SeekOrigin.Begin);// estamos 12 bytes de distancia del inicio. cadenaflujo.Read(arreglostream, 0, 5); // graba en el arreglo a partir de la posicion 0 los primero 5 valores bytes del stream. Console.WriteLine(ASCIIEncoding.ASCII.GetString(arreglostream));

// otra aplicacion de Seek() y mostramos la cadena cadenaflujo.Seek(-10, SeekOrigin.End);// estamos 10 bytes antes del final. cadenaflujo.Read(arreglostream, 0, 5); // graba en el arreglo a partir de la posicion 0 los primero 5 valores bytes del stream. Console.WriteLine(ASCIIEncoding.ASCII.GetString(arreglostream));

// obtencion de la posicion actual posicion = cadenaflujo.Position; Console.WriteLine("la posición del Stream es {0}", posicion);

// lestura desde la posicion actual cadenaflujo.Read(arreglostream, 0, 5); // desde donde nos encontramos los primero 5 bytes. Console.WriteLine(ASCIIEncoding.ASCII.GetString(arreglostream)); // cerramos el Stream cadenaflujo.Close(); } }}

Merece una explicación la sentencia dispuesta a continuación.En nuestro ejemplo, la cadena será armada en bytes pero debe ser

codificada en ASCII, para la cual utilizaremos la clase ASCIIEncoding. Para poder obtener los bytes de la cadena debemos hacer uso del método GetBytes() por el que pasa como parámetros la cadena escrita. cadenaflujo.Write(ASCIIEncoding.ASCII.GetBytes(informacion),0,informacion.Length);

Por consola vemos:


Los ArchivosLos streams no solo funciona para la memoria del computador, también

podemos almacenar la información en medios masivos, como un disco rígido. A partir de ahora, podremos crear archivos, escribir y leer sustentados por lo visto en Stream.

Para crear un archivo vamos a utilizar la clase FileStream. El constructor de esta clase necesita de dos parámetros, el primero es una cadena que contenga el nombre de archivo (es conveniente poner la extensión Ej: mitexto.txt), y el segundo parámetro colocaremos el modo del archivo, indicando como funcionara.

Los valores posibles son:

FileMode

Append Abre un archivo existente y dispone la posición actual al final del archivo. Si el archivo no existe lo crea.

Create Crea un archivo. Si ya existe lo sobrescribe.CreateNew Crea un archivo. Si ya existe produce una

excepción.Open Nos permite abrir un archivo. Si esta abierto

se produce una excepción.OpenOrCreate Nos permite abrir un archivo. Si este o existe

se crea.Truncate Abre el archivo y elimina el contenido hasta 0

bytes.

Por ejemplo:

// creacion de un stream para discoFileStream archivo = new FileStream("mitexto.txt",FileMode.Create);

El archivo creado se dispondrá en el directorio o carpeta en el cual estamos trabajando.

Método Write().Para escribir el archivo usaremos el método Write(). Se deben utilizar tres

parámetros, el primero es el arreglo en bytes, el segundo es la posición a partir de donde empezaremos a escribir con respecto a nuestra posición actual, y el último parámetro nos indica la cantidad de bytes que vamos a colocar.

// escribimos el archivo


archivo.Write(ASCIIEncoding.ASCII.GetBytes(informacion), 0, informacion.length);

Nuevamente información será un arreglo o una variable de tipo String, por lo tanto abra que definirlo previamente, etc.

Método Close().Para cerrar el archivo utilizaremos el método Close().archivo.Close();

Vamos a desarrollar un ejemplo para archivos, utilizando los métodos que hemos visto en esta unidad.

Hacer un programa que le permita al usuario ingresar cadenas hasta que ingrese una cadena vacía. Cada una de estas cadenas deberán grabarse en un archivo.



namespace archivos{ class Program { static void Main(string[] args) { // creacion de variables string cadena = ""; // creacion de un stream para disco FileStream archivo = new FileStream("mitexto.txt",FileMode.Create); do { Console.Write("Ingrese una nueva cadena de informacion: "); cadena = Console.ReadLine(); // escribimos en el archivo archivo.Write(ASCIIEncoding.ASCII.GetBytes(cadena), 0, cadena.Length);

} while (cadena != "");

// cerramos el archivo archivo.Close();

} }}

Por consola la visualización es la siguiente:


Para ver – al menos por ahora – la información en el archivo mitexto.txt podemos hacer uso de algún editor como el notepad.

Método Read()

Ya hemos creado el código para escribir un archivo en el disco rígido, ahora seria bueno que dicho código posea la propiedad de poder leer el archivo dispuesto en el medio de almacenamiento masivo.

Recordemos que estamos leyendo bytes por lo tato deberemos convertirlo en un tipo adecuado para nuestro programa. Para eso utilizaremos un arreglo, con una longitud de 100 bytes.

Para mostrara la información debemos colocar los bytes como cadena y esta tendrá formato ASCII, por lo tanto usaremos nuevamente ASCIIEncoding y GetString(), de esta forma pasamos el arreglo de bytes como parámetro.

Antes de empezar deben copiar el archivo mitexto.txt al nuevo proyecto para probar su lectura.



namespace archivolectura{ class Program { static void Main(string[] args) { // creacion de variables byte[] arregloarchivo = new byte[100];

// creacion de la instancia del stream de lectura FileStream archivo = new FileStream("mitexto.txt", FileMode.Open);


// leemos el contenido del archivo archivo.Read(arregloarchivo,0,(int)arregloarchivo.Length); // muestra el contenido leido Console.WriteLine(ASCIIEncoding.ASCII.GetString(arregloarchivo));

// cerramos el archivo archivo.Close();

} }}

Se va ver por consola del siguiente modo:

Los streams nos permite mover la información no solo de un lugar a otro de la memoria sino que también nos permite guardar y leer desde un disco rígido. Al crear un stream existe métodos para poder manipular la información siendo esto de gran ayuda para el programador a la hora de crear aplicaciones.



1. Realizar un programa que genere un Stream, donde el usuario pueda ingresar una cadena y lo muestre en orden inverso (Ej: internet muestra tenretni).

2. Programa una aplicación donde se le pida al usuario la ruta y el nombre de un archivo de texto y lo muestre.

3. Hacer un programa que permita hacer una copia de un archivo de tipo texto.

4. Hacer un programa que permita borrar un archivo.5. Programar una aplicación que permita cambiar el nombre de un

archivo. (tener en cuenta que el nombre del archivo no puede tener menos de cuatro letras).


Unidad 12

La Depuración.

Tiempo Estimado:

Todos los programas necesitan ser depurados, por lo tanto aquí veremos las técnicas básicas de depuración.

La depuración es utiliza para corregir no solo problemas de sintaxis, sino que también problemas lógicos. La depurarlo observamos su comportamiento y detectamos partes del programa que tienen problemas.

Para comenzar el estudio de depuración será importante conocer los tipos de posibles errores, ellos son los errores de Compilación y los de Ejecución.

Los errores de compilación son aquellos que provocan que el programa no pueda compilarse, generalmente son por mal tipeo de sintaxis.

Los errores en tiempo de ejecución, son los que suceden cuando el programa se ejecuta, esto se debe al mal diseño lógico o un mal control de la información (ej.: leer un arreglo más allá de los límites fijados).

Errores de compilación.Crearemos una aplicación, con varios errores para poder identificarlos y

corregirlos.


namespace errorescompilacion{ class Program { static void Main(string[] args) { // declaracion de variables int a = 2 int b=10; int c=0; int resultado=0;

// realizamos la division de b y c resultado = b / c; // lo mostramos Console.WriteLine("la division es: {0}",resultado); Console.WriteLine("***************************"); // mostramos el resultado 4 veces for (int n = 0; n <= 4; n++)


{ Console.WriteLine("la division es: {0}", resultado); } // invocamos una funcion Muestraresultado();

} static void Muestraresultado(int n) { Console.WriteLine("***************************"); Console.WriteLine("la division es: {0}", n); }}

Al haber un error de compilación, inmediatamente aparecerá una ventana en la parte inferior indicándolos en forma de lista.

Es importante la información que provee esta lista de errores. La misma me indica si es un error (rojo) o una advertencia (amarillo), la descripción de error y la línea y columna donde se ha provocado. También en el editor del programa suele aparecer en rojo, los errores provocados por el programado en tiempo de edición.

Ya podemos empezar a corregirlos, recuerden que deben empezar de arriba hacia abajo – puede existir que un error en la parte superior del programa acarreo otros –

En nuestro ejemplo:

Falta un punto y coma. Falta una llave para el cierre de la función. También falta enviar el parámetro al invocar la función.

El código sin errores de compilación es el siguiente:


namespace errorescompilacion{ class Program { static void Main(string[] args) { // declaracion de variables int a = 2; int b=10; int c=0;


int resultado=0;

// realizamos la division de b y c resultado = b / c; // lo mostramos Console.WriteLine("la division es: {0}",resultado); Console.WriteLine("***************************"); // mostramos el resultado 4 veces for (int n = 0; n <= 4; n++) { Console.WriteLine("la division es: {0}", resultado); } // invocamos una funcion Muestraresultado(resultado);

} static void Muestraresultado(int n) { Console.WriteLine("***************************"); Console.WriteLine("la division es: {0}", n); } }}

Ahora ya podemos ejecutar el programa.

¡Sorpresa!

Al ejecutar el programa nos da un error de ejecución.

En nuestro caso el algoritmo es correcto, pero no se puede dividir por 0 en el campo de los números reales, por lo tanto buscaremos la forma para salvar este error. Este tipo de error se denomina excepción y cuando ocurre se dice que se ha levantado.

Active el depurador y nos proveerá un mensaje además de indicar el lugar donde se produce la excepción.

Sin duda que podemos evitar por medio de otra lógica este error, por ejemplo colocando una decisión para el divisor sea distinto de 0 (cero). Pero


nuestro objetivo es aprender a manejar y prever las excepciones que pueden llegar a ocurrir.

Para llevar a cabo la administración correctamente las excepciones, podemos utilizar tres bloques de código denominados try, catch y finally.

El bloque try se dispone en el bloque donde se ha detectado el problema, que da del siguiente modo.

// administración de la excepcion try { resultado = b / c; }

Una vez que hemos dispuesto este código, tenemos las posibilidades, si queremos levantar la excepción colocaremos un bloque de código catch, donde dispondremos el código que se encargue de levantar la excepción. Se dispone luego del try, y puede quedar así:

catch (Exception e) { // codigo que salva la excepcion. Console.WriteLine("no es posible la division por 0."); Resultado = 0; }

Vemos que el bloque cuenta con un parámetro “e”, este nos provee información relacionada con la excepción, podemos disponer de ella mostrándola con la siguiente instrucción.

Console.WriteLine("Descripcion de la excepcion: {0}.",e);

Solo se ejecutar catch si existe una excepción.

Por ultimo el bloque de código finally es opcional, se ejecutara siempre exista o no una excepción. Se dispone luego de catch y generalmente se utiliza para limpiar o liberar los recursos utilizados en try y catch.

Nosotros podemos utilizarlo para entregar el resultado.

finally { // mostramos el resultado Console.WriteLine("la division es: {0}", resultado); Console.WriteLine("***************************"); }

El código completo es:


namespace depuracionejecucion{ class Program { static void Main(string[] args)


{ int b = 10; int c = 0; int resultado = 0; // desarrollo de excepcion try { resultado = b / c; }

catch (Exception e) { // codigo que salva la excepcion. Console.WriteLine("no es posible la division por 0."); resultado = 0; }

finally { // mostramos el resultado Console.WriteLine("la division es: {0}", resultado); Console.WriteLine("***************************"); } } }}

Por consola vemos:

Con la depuración podemos corregir algunos problemas que podría tener nuestro programa. Si tenemos código peligroso, es hasta obligatorio que pongan un código de depuración en nuestras aplicaciones, tranquiliza a nuestros clientes y para nosotros mismos para optimizar el sistema.


1. Utilizar la depuración ante el cálculo de un factorial (los valores deben ser mayores o igual a 1).


2. Investigar las excepciones que tiene WriteLine().



Programación en el Entorno Grafico con

C#.


Unidad 1- entorno grafico

El Visual Studio posee un Entorno de desarrollo integral comúnmente llamado IDE, utilizado para crear, ejecutar y depurar las aplicaciones.

Una vez más ejecutemos el Visual Studio, yendo al botón de inicio, todos los programas, Microsoft Visual Studio y por ultimo Microsoft Visual Studio. Se vera la siguiente ventana.

Esta primera página presenta vínculos a recurso en internet, se destaca el explorador de soluciones, un menú en la parte superior, poder acceder a los proyectos recientes, crear un nuevo proyecto, conectarse con la comunidad de desarrolladores, etc. No se pierda de echar un vistazo antes de continuar.

Para comenzar a trabajar deben abrir un nuevo proyecto, para eso vayan al menú, archivo, nuevo, nuevo proyecto y aparecera una ventana con las diferentes plantillas para los diversos proyecto, elijamos Aplicaciones para Windows.


Una Aplicación para Windows, es un programa que se ejecuta dentro del sistema operativo Windows y tiene una interfaz grafica de usuario (denominada GUI – parte grafica que interactúa con el usuario -).

Retomando el formulario donde seleccionamos la plantilla Aplicaciones para Windows, debemos indicarle un nombre a la aplicacion y una ubicación (de suma utilidad para poder ubicarlo rápidamente por nosotros). Pulse aceptar y aparcera el IDE con la vista de diseños para ya poder empezar a trabajar.

Vemos un rectángulo gris denominado formulario que va ser nuestra ventana principal de la aplicación Windows.

A partir de ahora iremos agregando controles (componentes reutilizables) al mismo, y cambiando las propiedades de estos. Para dispongamos de las herramientas a utilizar, vayamos al menú, ver y cuadro de herramientas (podemos ocultar automáticamente para tener mas espacio al hacer clic sobre la chinche (icono del marcador pasa de horizontal vertical) que se encuentra en la parte superior de esta plantilla).


Notemos que a la derecha en el explorar de soluciones, se van agregando archivos pudiendo de esta manera acceder en forma directa y sencillo por parte del programador.

Vamos con el primer ejemplo:

La idea es poder ingresar algunos objetos, dentro del formulario, para eso empezamos de la siguiente manera:

1 – vamos a cambiar las propiedades del formulario, para eso botón derecho del mouse sobre el formulario, y un clic con el izquierdo en propiedades.

Vamos a cambiar las siguientes propiedades

propiedadesText Mi primer programa


BackColor 255; 224; 192

2 – tomamos de la barra de herramientas el objeto label, para eso vamos al icono ubicado en la barra de herramientas hacemos un clic con el botón izquierdo del mouse, vamos al formulario y hacemos clic en el formulario y se dispone allí el objeto label1.

Vamos a cambiar las siguientes propiedades

propiedadesText Programando en Visual C#Font Microsoft Sans Serif

ForeColor RedAutoSize True

3 – agregar el Objeto PictureBox. Aparece un rectángulo con nombre PictureBox1. A este le agregaremos las siguientes propiedades.

propiedadesImage ejemplo1.Properties.Resources.imagennet

SizeMode StretchImage

Acepta imágenes con formato png, gif, bmp, etc.

4 – Guarde el Proyecto y luego ya lo puedo ejecutar el mismo, debería verse de la siguiente manera:

Termine la ejecución, presionando el botón de cerrar, y volvemos a modo de edición.


Cambie colores e imágenes para probar las diferentes alternativas que tienen estos pocos elementos que hemos vistos.



Conceptos Fundamentales C#

Documents

Transcript of Conceptos Fundamentales C#