8 – Resumen del primer bloque

1. Resolución del ejercicio del capítulo anterior Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5. Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, pero antes recordemos el enunciado: Te piden un formulario que recoja el nombre de una persona y permita escoger es estado civil de ésta persona de un listado predefinido. La lista de estados es la siguiente:

  • Soltero/a
  • Casado/a
  • Divorciado/a
  • Viudo/a

También te piden una opción que permita cambiar el color de:

  • Fondo del formulario
  • Fondo de los controles
  • Texto

Bien, la parte sencilla es la que ya hemos visto en el capítulo anterior y no es otra que usar un textbox para recoger el nombre, le pondremos también un label para que el usuario sepa que le estamos pidiendo: 8.resol.1 Hasta aquí ningún misterio, lo siguiente si es un poco más complicado básicamente porque no lo he explicado, pero seguro que has hecho caso de las pistas y has buscado por internet como se usa el control “ComboBox”. Vamos a empezar añadiendo uno en nuestro formulario: 8.resol.2 Si haces clic en el combo verás que aparece una flechita en su esquina superior derecha que te permite desplegar un menú, desde ahí puedes entrar en “Editar elementos” y añadir los que te pide el enunciado: 8.resol.3 Después de aceptar el mensaje vamos a darle al play y comprobar como se comporta nuestro nuevo y flamante combo: 8.resol.4 ¿Fácil verdad? Los combos están ahí para eso, para que un usuario escoja entre alguna de las opciones prefijadas que se le ofrecen. No tiene sentido preguntar el estado civil en un campo de texto libre como un “textbox” porque no nos interesa que se inventen un estado civil o que lo escriban mal, por ejemplo. Bien, vamos a la última parte del ejercicio: el cambio de color. Hasta ahora el enunciado no nos pedía programar nada de código, simplemente montar el formulario para recoger datos pero me temo que con lo de los colores nos vamos a tener que manchar las manos de barro. Empecemos añadiendo un control “ColorDialog” tal y como nos dicen las pistas: 8.resol.5 Como ves se parece al “Timer” ya que no tiene una representación gráfica en nuestro formulario, pero nos aparece bajo éste para que sepamos que lo tenemos creado y podamos tocar sus propiedades. Bien, si has buscado por Internet verás que para usar éste control necesitamos pedirle que nos muestre su cuadro de colores y esto lo tenemos que hacer por código. Una buena práctica es estudiarse el listado de propiedades, eventos y métodos de un objeto, lo cual ya hemos visto en capítulos anteriores cuando, desde código, escribíamos el nombre de un control y le dábamos al punto, desplegando el listado de opciones. Para no complicarlo vamos a añadir un menú en el formulario y vamos a programar el evento click de sus opciones para que nos muestre el cuadro de diálogo: 8.resol.6 Recuerda que haciendo doble click podemos programar directamente el evento click de la opción: 8.resol.7 A éste cuadro que nos muestra lo que podemos hacer con un objeto se le conoce como “IntelliSense” y hasta nos explica para que sirven los métodos si sus nombres no están del todo claros. Piensa que seguramente seas capaz de aprenderte los métodos y propiedades más importantes de los controles que trae el .NET Framework pero también se pueden instalar componentes de terceros (que suelen ser muy potentes… y también de pago…) y la única forma de saber que coño hacen y como utilizarlos es mirar la documentación donde, precisamente, te explican que propiedades y métodos traen consigo. Como somos personas curiosas vamos a echar un vistazo y… ¡voila! Hay un método que se llama “ShowDialog” que nos viene de perlas: 8.resol.8 Vamos a ver como se comporta ahora nuestro form cuando usamos dicha opción: 8.resol.9 ¡Anda la hostia! Que opción más chula pero… ¿una vez se escoge un color como lo usamos? Pues volvamos a investigar la lista de opciones que tiene el objeto… vaya, tiene una propiedad llamada “Color” y además nos dice que es la que nos da el color seleccionado por el usuario… pues vamos a cogerlo y a ponerlo de color de fondo del formulario: 8.resol.10 Quizás la parte más complicada aquí sea ver como cambiar el color del formulario, pero no es para nada difícil una vez lo ves claro. Si te fijas bien estás programando el código el propio formulario que quieres modificar, lo puedes ver justo después de declarar el namespace, cuando se declara la clase actual (en mi caso línea 13), estamos dentro de la clase Form1 que es de tipo Form por lo que queremos modificar el objeto dentro del cual estamos programando, y la mejor forma de acceder a dicho objeto es mediante la palabra “this”. Una vez visto esto, modificando la propiedad “BackColor” de “this”, es decir, el objeto actual, es decir, el formulario que queremos cambiar, queda todo hecho. ¿Por que no le damos al play para probarlo? 8.resol.11 Si hasta aquí está todo claro solo nos queda repetir todo esto en la otra opción, pero en lugar de cambiar le color del formulario cambiaremos el de los controles: 8.resol.12 Y listos, con esto tenemos el ejercicio completado. Espero que te animes a probar los otros controles y a jugar con ellos, se pueden hacer cosas muy chulas 🙂

2. Contenido del capítulo

Le he estado dando algunas vueltas al tema y creo que antes de continuar explicando cosas nuevas sería conveniente hacer un repaso de todo lo que llevamos visto hasta ahora, aunque he intentado que todos los ejemplos que he ido poniendo sean acumulativos, incluyendo así elementos ya vistos antes, nunca está de mas echar la vista atrás para refrescar conceptos sin detenernos en los detalles.

Éste es el listado de lo que hemos aprendido hasta ahora y, por tanto, vamos a repasar:

  • Tipos de datos básicos
  • Arrays
  • Variables y constantes
  • Operadores lógicos
  • Operadores booleanos
  • Condicionales
  • Programación orientada a objetos
  • Windows Forms

¡Pues no perdamos más tiempo y vamos a repasar un poco!

3. Tipos de datos básicos

Dado que programamos con C# sobre .NET Framework disponemos de un conjunto de tipos de datos que vienen incluidos en el sistema con los que podemos trabajar.

Los tipos que hemos visto hasta ahora son:

  • int: para números enteros
  • float: para números reales
  • bool: almacena el valor de cierto o falso.
  • string: contiene una cadena de texto.
  • object: es el tipo básico, como si fuera un comodín podríamos tratar todos los tipos que hemos visto como si fueran object (cuando hablemos de herencia quedará más claro).

Existen otros tipos de datos pero para lo que vamos a hacer nos podemos bastar de sobras con estos, si tienes curiosidad sobre otros tipos puedes consultar la documentación de Microsoft al respecto.

4. Arrays

Es posible crear colecciones de elementos, por ejemplo, un conjunto de enteros o un conjunto de floats. Los arrays son de tamaño fijo y es necesario indicar que tamaño queremos reservar, por ejemplo:

int[] my_array = new int[10];

De ésta forma estamos declarando un array de de enteros de 10 posiciones, después podemos acceder a dichas posiciones mediante los corchetes y tomar o asignar valores, asi:

my_array[3] = 25;

Esiten otras formas de inicializar arrays, como por ejemplo la siguiente que nos permite establecer sus valores de forma inlne:

object[] my_array = new object[]{1, “hola”, 4.5f, false};

Como puedes ver, todo cabe en un array de objects 😉

5. Variables y constantes

Como hemos visto en multitud de ocasiones, cuando necesitamos trabajar con datos es necesario que los guardemos en campos constantes o variables, dependiendo de si el valor es fijo es modificable respectivamente.

El valor de una constante se declara junto con la misma y no se puede modificar durante la ejecución del programa, es importante identificar las constantes y hacer buen uso de ellas ya que no solo mejora el rendimiento del programa sino que nos indica que estamos entendiendo lo que hacemos.

Las constantes se declaran así:

const int my_const = 25;

En el otro lado tenemos las variables, que son valores que se pueden modificar durante la ejecución de un programa y se declaran asi:

int my_var = 35;

6. Operadores lógicos

Hemos visto distintos tipos de operadores lógicos y seguro que te son muy familiares ya que hablamos de cosas tan típicas como sumar, restar, multiplicar o dividir. Es importante remarcar que los operadores lógicos solamente se pueden utilizar con datos del mismo tipo, es decir, no se puede sumar un entero con un string si antes no se ha hecho algún tipo de conversión.

Suma:
int a = 1;
int b = 2;
int c = a + b;

Resta:
float a = 2.2f;
float b = 1.2f;
float c = a – b;

Multiplicación:
int a = 33;
int b = 4532;
int c = a * b;

División:
float a = 0;
float b = 1.0000012f;
float c = a / b;

Recuerda también que los strings se pueden concatenar sumándolos.

7. Operadores booleanos

Se trata de lógica básica, los operadores booleanos se suelen aplicar a condicionales y consisten en evaluar ciertas propiedades para determinar si son ciertas o falsas.Por tanto el tipo de dato que retorna un operador de éste tipo siempre es booleano.

Mayor que:
int a = 33;
int b = 4532;
bool c = a > b; (falso)

Mayor que:
int a = 33;
int b = 4532;
bool c = a < b; (cierto)

Igual que:
int a = 33;
int b = 4532;
bool c = a == b; (falso)

Distinto que:
int a = 33;
int b = 4532;
bool c = a != b; (cierto)

A estos operadores de comparación se le unen otros de unión o conjunción:

Y:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b && c == 2; (falso)

O:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b || c == 2; (cierto)

8. Condicionales

Los condicionales son una herramienta básica en la programación secuencial (como la nuestra) ya que nos permiten ejecutar piezas de código únicamente si se cumplen ciertas condiciones:

if(low_battery){
ModoReposo();
}
else{
ModoNormal();
}

9. Programación orientada a objetos

Esta es, en mi humilde opinión, la parte más divertida y quizás la más compleja.

Como hemos visto los tipos de datos se representan con objetos, donde un objeto es una entidad que contiene uno o varios valores y un conjunto de métodos. Los integers, booleans, strings y floats que hemos visto tienen un conjunto de métodos predefinidos pero solamente toman un valor dependiendo del tipo que hayamos declarado. Lo divertido del asunto es que nosotros somos capaces de crear nuestros propios objetos mediante clases, donde podemos meter lo que nos dé la gana.

Por ejemplo:

8.clases.1

Lo que tenemos aquí es una clase que se llama Persona u que describe, de una forma muy resumida, los datos de una persona. Tiene 3 atributos privados, un método constructor, 3 propiedades y un método.

El constructor toma como datos de entrada el nombre de la persona y su edad y los almacena en los atributos privados. Si te fijas aparece la palabra reservada “this”, en éste punto es necesaria porque si te fijas los atributos de la clase se llaman igual que los parámetros de entrada del constructos, usando “this” le estamos diciendo al programa a cual de los dos nos referimos. Además como se trata de atributos privados no se pueden acceder desde fuera de la clase, es decir, quien use Persona no podrá ver estos atributos ni modificarlos por lo que los tenemos bien protegidos.

Lo sieguiente son las propiedades, una propiedad es un método especial que solo se encarga de entregar un valor o modificarlo. En nuestro caso, como los atributos son privadas necesitamos propiedades que permitan acceder a los valores pero si te fijas, las dos primeras solo permiten consultarlo por lo que una persona siempre tendrá el mismo nombre de creación (algo similar a la vida real suponiendo que nadie se cambiara el nombre) y tampoco se nos permite modificar libremente la edad.

La última propiedad si que permite modificar los datos a parte de consultarlos, lo hemos permitido porque es normal que una persona cambie de domicilio.

Lo último es un método que representa el día del cumpleaños, incrementando en uno la edad de esa persona.

Es importante que se entienda que tenemos el control absoluto de nuestra clase y, lo que es más importante, somos libres de dejar nuestra clase más abierta o más cerrada a cambios desde el exterior, en mi caso no he dejado que un programador le pueda quitar años a una persona ni le pueda cambiar el nombre una vez creada, pero si que le dejo consultar esos datos o hacerle cumplir años.

10. Windows Forms

Es la parte más gráfica ya que nos permite montar una interfaz para que el usuario interactue con nuestra aplicación de forma más amigable, los formularios se componen de controles que. a su vez, tienen atributos, métodos y eventos. Recuerda que los eventos son métodos programables que se disparan en una situación concreta como, por ejemplo, un clic.

Los controles más comunes son:

  • TextBox: permite recoger texto libre.
  • ComboBox: permite escoger una opción de una lista predefinida.
  • CheckBox: permite marcar una o varias opciones.
  • RadioButton: permite seleccionar una única opción.
  • Button: permite insertar un botón y programar su comportamiento.
  • MenuStrip: permite construir un menú.

Existen multitud de controles nativos y de terceros, todos hacen cosas distintas pero todos tienen cosas en común. Que no te de miedo jugar con ellos, investigar sus métodos, propiedades y eventos, muchas veces descubres una mejor forma de resolver un problema cuando estás haciendo experimentos.

11. Resumen

Y hasta aquí el resumen, porque no pienso hacer un resumen de un capítulo que ya es un resumen. Tampoco se me ocurre un ejercicio que aporte nada porque siempre hemos hecho ejercicios acumulativos, es decir, hemos aprovechado lo aprendido en capítulos anteriores y lo hemos ampliado con lo aprendido en el actual… así que prefiero no ser redundante y dejarte descansar y coger fuerzas.

En el próximo capítulo nos meteremos de lleno en el camino de la iteración (o bucles) y más adelante hablaremos de recursividad, si entretanto te aburres te invito a que crees una clase basándote en algo de la vida real (una persona, una nevera, un armario…), programes sus métodos y atributos y busques la manera de representarlo con WinForms, a tu rollo, sin prisas ni reglas, esa es la mejor forma de aprender.

Mucha suerte y nos vemos en la próxima entrada.
¡Gracias por seguir mi blog!

Anuncios

7 – Introducción a los Windows Forms (Continuación)

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, que consistía en implementar (o programar) el comportamiento de la calculadora de Windows según el siguiente esquema:

actual = 0
resultado = 0

pulso el número 1

actual = 1
resultado = 0

pulso el símbolo +

actual = 0
resultado = 1

pulso el número 3

actual = 3
resultado = 1

pulso el símbolo +

actual = 0
resultado = (3 + 1) = 4

pulso el número 7

actual = 7
resultado = 4

pulso el símbolo –

actual = 0
resultado = (7 + 4) = 11

pulso el número 2

actual = 2
resultado = 11

pulso el símbolo +

actual = 0
resultado = (11 – 2) = 9

Solución:

Para empezar veo bastante claro (espero que tu también lo hayas visto) que hacen falta dos variables, una para el valor actual y otra para el resultado. Tal y como sugerí en el enunciado voy a hacer uso de la clase Calculadora que creamos en capítulos anteriores.

Si recuerdas bien, a dicha clase le podíamos pedir operaciones y que nos dijera el resultado por lo que la podemos usar para almacenar nuestro resultado.

Voy a aprovechar todo el código del capítulo anterior pues estamos ante la continuación del mismo. La cosa empezaría así:

7.res.1

Vale, no era mi intención que se me complicara la cosa nada más empezar pero ya nos viene bien para hablar de los “namespaces”.

1.1. Namespaces

Empecemos primero con un ejemplo sencillo:

Tú has programado tu calculadora (la del capítulo 5) en un proyecto que se llama “C5” y nuestra amiga Carola lo ha hecho en un proyecto que se llama “Cap5”. Tu clase se habría creado en un namespace llamado “C5” de esta forma:

7.res.3

Y la de nuestra amiga Carola sería de la siguiente forma:

7.res.4

Las dos están bien construidas (falta código, solo he puesto el inicio) pero en namespaces diferentes., esto es así porque cuando creas un proyecto Visual Studio te mete las clases en un namespace que se llama igual que el proyecto.

El namespace es como si fuera una caja con un nombre, si sabes el nombre de la caja puedes ir a buscar lo que sea que haya dentro. Si dos cajas se llaman igual… pues tenemos un problema.

Si te fijas, en éste ejemplo tanto tú como Carola tenéis una clase que se llama igual (Calculadora) pero en namespaces diferentes, así que podrías usar las dos clases en el mismo proyecto sin problemas así:

7.res.5

¿Lo ves? Con decirle a C# en que namespace debe buscar la clase la cosa funciona y eso es lo mismo que he hecho yo, solo que mi namespace se llama “Capitulo_5”.

Además si te fijas mi proyecto también se llama “Calculadora” (línea 11 de la imagen superior) por lo que estoy obligado a decirle que quiero usar la calculadora de “Capitulo_5” si quiero hacer las cosas bien.

Espero que se haya entendido, si no siempre tienes los comentarios 😉

1.2. Programando la solución

Recuerda que ya teníamos programados los métodos de los botones numéricos, al pulsarlos se ponía el valor del número en “_current” y se mostraba el número en el display de nuestra calculadora.

Si te fijas, según el enunciado, cuando se pulsa un número se guarda en “_current” y eso ya lo tenemos hecho. Nos falta hacer la parte de pulsar un botón de opración por lo que tenemos que programar los botones de “suma”, “resta”, “multiplicación” y “división”.

Según el enunciado, al pulsar uno de estos botones se realiza la operación entre “_current” y lo que haya en el total para, después, dejar “_current” a cero. Vamos a ello:

7.res.6

Si miras el primer método (corresponde a la suma) verás que lo único que hace es decirle a la calculadora que sume el número que hay en “_current” y acto seguido invoca al método ActualizarTotal. Esto método (el último de la imagen) resetea “_current” a cero y muestra el total de la calculadora en el display.

El método ActualizarTotal nos lo podemos ahorrar pero tendríamos dos líneas repetidas en los 4 métodos de las operaciones lo cual no es aconsejable. Te recomiendo que todo el código repetido lo metas en un método porque te será más fácil hacer cambios después (imagina que no queremos resetear “_current”, tendrías que hacer 4 cambios en lugar de uno).

Y con esto tan tonto ya hemos hecho lo que se nos pedía.

2. Contenido del capítulo

Bueno, lo cierto es que éste capítulo es una ampliación del anterior así que la temática va a ser muy similar.

Me encantaría que pudiéramos ver todos los controles y hacer ejemplos con cada uno de ellos pero eso nos llevaría demasiado tiempo así que me voy a centrar en algunos controles que considero más interesantes que otros. No obstante te invito a que crees un nuevo proyecto con Visual Studio y te pongas a jugar con los controles que ofrece, esa es la mejor manera de aprender 🙂

El temario de hoy es:

  • Controles
    • CheckBox
    • RadioButton
    • DateTimePicker
    • PictureBox
    • MenuStrip
    • Timer
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Lamentablemente no podemos aplicar estos controles en nuestra calculadora (excepto el menú) por lo que la vamos a dejar aquí, si más adelante surge la oportunidad de continuarla para hacer algún ejemplo la volveremos a tocar pero por ahora la dejamos en pausa. Eso sí, te animo encarecidamente a que la termines por tu cuenta, con lo que te he enseñado tienes más que suficiente para terminarla con la ayuda del Sr. Google y, si por lo que sea te quedas encallado/a en algún punto no dudes en enviarme un mensaje vía comentarios.

Si además, por petición popular queréis que continuemos con la calculadora, también lo podemos hacer 🙂

3. Controles

Pues al turrón, recordemos que hemos visto los “Buttons”, los “TextBoxes” y los formulario pero nos quedan unos cuantos controles interesantes por ver. Como he dicho antes me voy a centrar en los más útiles y/o comunes.

Te recomiendo que crees un nuevo proyecto limpio para que no te líes con lo que tenemos hecho hasta ahora.

3.1. CheckBox

El “CheckBox” es el típico recuadro que se marca con un “tick” y se suele utilizar para selecciones de respuesta múltiple, crea un CheckBox en el formulario (de la misma forma que hicimos con los botones) y échale un vistazo a sus propiedades:

7.check.1

Verás que sus propiedades son muy similares a las de un “Button” o un “TextBox”, pero el valor que más te interesa es la propiedad “Checked” que será la que te permitirá saber si una persona ha hecho clic o no. Además, como puedes observar si tocas el botón del rayo, tienes multitud de eventos que puedes programar como “Click” o “CheckedChanged”.

Su uso es tan simple que vamos a reservarnos los ejemplos para el final, donde los vamos a ver todos de golpe.

3.2. RadioButton

El “RadioButton” es el hermano del “CheckBox” (checks para los amigos) pues la función es la misma (seleccionar) pero en éste caso de forma única. Haz una prueba y pon un par de radios (“RadioButtons”) en el formulario, cuando le des al play verás que solo puedes seleccionar uno de ellos, cosa que no ocurre con los checks.

7.radio.1

3.3. DateTimePicker

El “DateTimePicker” permite que un usuario pueda seleccionar una fecha desde un calendario desplegable de forma cómoda y sencilla. Además, el valor que podemos recoger (en la propiedad “Value”) nos viene en forma de objeto “DateTime”, dicho objeto contiene una fecha y la podemos transformar con total comodidad.

Unas de las ventajas de éstos componentes es que nos ahorra el molesto problema de “escribe la fecha con dos dígitos para el día, dos para el mes y cuatro para el año. ¡Ah! No escribas letras que sino revienta todo el puto programa”. Además el objeto “DateTime” lo podemos mostrar al usuario en forma de texto con el ya conocido “ToString” y podemos decidir en que formato (dd-mm-aaaa, dd/mm/aaaa, etc), por no hablar de sumar días, horas, etc.

7.date.8

3.4. PictureBox

El picture box es uno de los controles más sencillos de utilizar, cuando lo crees verás que aparece una flechita que te despliega un asistente. La gracia de éste control es que se puede manipular en tiempo de ejecución mediante código para, por ejemplo, cambiar la imagen. Una posible aplicación sería mostrar un led que se enciende cuando movemos el ratón y parpadea cuando se queda quieto.

7.pic.7

3.5. MenuStrip

Éste control te permitirá montar menús tan clásicos como “Archivo”, “Ayuda / Acerca de…” o el favorito de todos “Edición / Copiar”. Cuando lo crees verás que puedes ir añadiendo otros elementos o ir escribiendo los nombres de las secciones. No tiene demasiado misterio.

Además, al igual que los botones, puedes hacer doble click para crear eventos en caso que quieras programar alguno.

7.menu.9

3.6. Timer

El timer es un objeto muy interesante, ya que nos permite decirle cada cuanto tiempo se ha de disparar un evento que nosotros podemos programar. Simple, sencillo y sin misterio. Además, es el único control que hemos visto que no es gráfico (no aparece en el formulario cuando le das al play).

4. Resolución de un ejercicio de ejemplo

Nos piden un formulario de Windows que recoja el nombre, apellido, fecha de nacimiento, sexo y aficiones de una persona. Debe incluir dos botones: uno para resetear el formulario y otro para aceptar. Cuando se acepta se debe mostrar un mensaje con un resumen de las opciones seleccionadas. También ha de aparecer de forma automática, cada 30 segundos, un mensaje que diga “Programar mola y saltar a la comba también.”

Además, como guinda del pastel, se pide una opción en un menú para cerrar la aplicación.

4.1. Primera parte: el botón “Aceptar”

Pues vamos al turrón, la parte más fácil es montar el formulario con los elementos que nos piden. Vamos a usar “Labels” para las etiquetas, “TextBoxes” para el nombre y apellido, “DateTimePicker” para la fecha de nacimiento, como el sexo es de opción única vamos a usar “RadioButtons” y para las aficiones “CheckBoxes”. La cosa quedaría más o menos así:

7.ejemplo.1

Vale, le damos doble click al botón aceptar y programamos su evento clic. Lo que vamos a hacer es recorrer los controles (yo les he puesto un nombre que me sea fácil de recordar), coger su valor, montar un string y mostrarlo en un “MessageBox” (que ya los hemos visto antes). Allá vamos:

7.ejemplo.2

Espero que se entienda todo lo que he hecho, a estas alturas debería ser así. Si no es el caso siéntete libre de preguntar en los comentarios pues soy consciente que en ocasiones me puedo explicar como el puto culo.

Si se ejecuta esto, se rellena el formulario y se le da al botón de aceptar nos encontramos con el siguiente mensaje:

7.ejemplo.3

¿Feo de cojones verdad? Normal, no hemos puesto ningún salto de línea. Vamos a retocar nuestro mensaje:

7.ejemplo.4

Ahora el mensaje mola mucho más porque he puesto saltos de línea después de cada línea:

7.ejemplo.5

¿Lo ves? Todo más clarito.

Antes de seguir con el ejercicio me gustaría hacer algunas optimizaciones en el código para que quede más bonito (ya sabes que me encantan estas cosas), las hago y las comentamos:

7.ejemplo.6

Bien, la primera optimización la tenemos en la línea 26. Los checks “sexoSi” y “sexoNo” son complementarios por lo que para saber que se ha marcado me basta con mirar uno de los dos… siempre y cuando active uno como predeterminado (sino podría ser que ninguno estuviera marcado que es el estado inicial del formulario). Activar uno por defecto es tan fácil como poner a “true” la propiedad “Checked” desde la vista del formulario.

Lo segundo que he hecho está en la línea 27, he inicializado el array de forma inline, algo que ya habíamos visto en capítulos anteriores.

Lo último es un poco más extraño, está en la línea 29 y es una forma curiosa, potente y eficiente de construir strings. Consiste en utilizar el método “Format” del objeto “string”, en el primer parámetro metemos el texto y dejamos huecos en blanco con llaves numeradas (“{0}, {1}, {2}, etc.”). El resto de parámetros son los valores de esos huecos, como nosotros hemos usado dos huecos hemos de poner dos parámetros y ahora viene lo mejor: ¡da igual el tipo de objeto! Puedes poner un string, un int, un bool… lo que quieras.

Por último fíjate en la línea 31, el método “ToString” de “fNaci” tiene un parámetro de tipo string con el valor “dd/MM/yyyy”. Eso es así para que la fecha aparezca en ese formato, es decir, dos dígitos para los días, dos para los meses (la m es mayúscula porque las minúsculas hacen referencia a los minutos) y cuatro para la hora. Tienes más información sobre como formatear fechas aquí.

4.2. Segunda parte: el botón “Reset”

Esto va a ser más fácil, lo único que hay que hacer es dejar los controles como estaban cuando se carga el formulario. Doble click al botón “Reset” y a programar:

7.ejemplo.7

De aquí lo único que quiero comentar es la tercera línea, “DateTime.Today” accede a la propiedad “Today” del objeto “DateTime” (que no hace falta declarar) que es la fecha con la que arranca por defecto nuestro “DateTimePicker”.

Seguramente volvamos sobre éste ejemplo en el siguiente capítulo cuando hablemos de la iteratividad… no te asustes que mola más que asusta 😉

4.3. Tercera parte: el menú

Voy a crear un control “MenuStrip” con una opción llamada “Archivo” y dentro otra llamada “Salir” al igual que en la mayoría de aplicaciones:

7.ejemplo.8

Ahora doble click sobre “Salir” y programamos el cierre de la aplicación:

7.ejemplo.9

¿Fácil verdad? El objeto “Application” nos permite controlar nuestra propia aplicación y uno de sus múltiples métodos es “Exit”. Te animo a que juegues con éste objeto para que veas su potencial.

4.4. Cuarta y última parte: el temporizador

Esta es la más diver-chachi, vamos a crear un control de tipo “Timer” y lo vamos a programar a 30 segundos:

7.ejemplo.10

El “Timer”, a diferencia del “MenuStrip” no aparece dibujado en el formulario pero si vemos el componente en esa zona etérea de debajo del mismo donde lo podemos seleccionar como un control más y acceder a sus propiedades. Fíjate que lo he marcado como “Enabled” para que funcione desde el principio y que el intervalo es de 30.000 milisegundos, es decir, 30 segundos.

Ahora le hacemos doble click al timer y empezamos a programar lo que hará cada vez que se active, que será mostrar un mensaje tal y como nos han pedido:

7.ejemplo.11

Otra vez nuestro amigo “MessageBox” nos hace el trabajo, si ahora arrancas la aplicación y esperas 30 segundos verás como aparece el mensaje.

5. Resumen

Hoy hemos ampliado nuestros horizontes con los controles de Windows Forms y, aunque no están todos los que són, si que son todos los que están… o algo así… osea que todo lo que hemos visto son controles, pero no los hemos visto todos… es igual, que me voy por las ramas…

Ya hemos visto y jugado con los siguientes controles:

  • Label
  • TextBox
  • Button
  • DateTimePicker
  • RadioButton
  • CheckBox
  • MenuStrip
  • Timer

Me gustaría enseñártelos todos pero acabaríamos en dos años y tampoco es el objetivo de éste curso, yo solo pretendo enseñarte las bases y quitarte el miedo a probar y descubrir las cosas por ti mismo, y para ello nada mejor que un ejercicio para la entrada que viene:

6. Enunciado del ejercicio para la próxima entrada.

Te piden un formulario que recoja el nombre de una persona y permita escoger es estado civil de ésta persona de un listado predefinido. La lista de estados es la siguiente:

  • Soltero/a
  • Casado/a
  • Divorciado/a
  • Viudo/a

También te piden una opción que permita cambiar el color de:

  • Fondo del formulario
  • Fondo de los controles
  • Texto

Pistas

Para el estado civil puedes usar el control “ComboBox”.
Para los colores el control “ColorDialog”.
Como mostrar el “ColorDialog” queda a tu elección (botón, menú…)

Mucha suerte y nos vemos en la próxima entrada.
¡Gracias por seguir mi blog!

6 – Introducción a los Windows Forms

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Solución:

Muy bien, vamos a empezar haciendo el truco que te enseñé en el capítulo anterior y vamos a determinar que clases necesitamos, con que atributos y que métodos. Empecemos con las clases, recuerda que para ello hemos de buscar sustantivos:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Empecemos por “sistema”, el sistema de seguridad es lo que nos piden montar, aquí podemos hacer dos cosas: desarrollar el sistema como una clase, o obviarlo y meter toda nuestra lógica directamente en el formulario… Había pensando en obviarla pero la voy a tener en cuenta para que veas que esto puede ser tan flexible como tu quieras. Seguimos por “ascensor”, que es el elemento principal de éste ejercicio. Si te fijas todo gira en torno al ascensor (es por ello que decía que podíamos obviar la clase “sistema”) por lo que podemos decir que “ascensor” es la clase fuerte o dominante.

Nos queda la clase “pasajeros”, nos la apuntamos también.

Vamos a buscar ahora atributos, recuerda que es todo aquello que denote algún tipo de propiedad o descripción ya sean adjetivos o pequeños sintagmas:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Bien, sencillo hace referencia al sistema de seguridad y nos indica que el problema es fácil, no hace falta comerse mucho la cabeza para ver que nos lo podemos pasar por el forro. Lo siguiente tiene más chicha, “número máximo de pasajeros” no es un adjetivo pero sí que define una propiedad del ascensor, nos está dando información detallada del mismo así que podríamos tomarlo como un parámetro.

Esto no siempre es infalible ni tampoco claro, ante la duda te recomiendo que lo tengas en cuenta y sobre la marcha te darás cuenta que sobra… siempre es mejor que sobre que no que falte 😉

Fíjate que he marcado “el límite de pasajeros permitido”, “la cuenta de pasajeros que entran” y “la cuenta de los pasajeros que salen”. El primero ya lo hemos tenido en cuenta, pero los otros dos nos dan una pista de que vamos a necesitar un contador de pasajeros, por tanto necesitamos otro atributo.

Por último los métodos, suelen ser verbos o acciones:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

¿Bastante fácil esta parte no? Lo cierto es que intenté que el enunciado fuera sencillo y fácilmente analizable, si no lo he conseguido me lo tengo que hacer mirar :p

¿Que tenemos hasta ahora? Agarra papel y lápiz (tus dos mejores amigos) y hagamos recunto:

  • Tres clases: “sistema”, “ascensor” y “pasajero”.
  • Dos atributo de “ascensor”: el “número máximo de pasajeros” y “los pasajero que hay montados”
  • 4 métodos para el sistema de seguridad:
  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Si te fijas, la clase “pasajero” se nos ha quedado sin atributos ni métodos, de hecho lo único que vamos a hacer es contar pasajeros, por lo que son más bien un atributo y no una clase así que no la tendremos en cuenta.

Te recomiendo siempre que vayas de dentro hacia afuera, como el sistema de seguridad es el que maneja ascensores vamos a empezar por ascensor, programemos:

6.1.solucion1

Aquí tienes mi clase Ascensor, que he creado en un fichero nuevo llamado “Ascensor.cs” y tiene los dos atributos que hemos visto antes.

Vamos ahora con la clase Sistema:

6.2.solucion2

El constructor de Sistema crea el ascensor. El resto de métodos nos permiten hacer lo que nos pide el enunciado: establecer el número máximo de pasajeros, llevar la cuenta de los que entran y salen (es decir, poner y quitar) y mirar si el límite está sobrepasado.

El atributo “_ascensor” lo que puesto como private para que no sea visible desde fuera de “Sistema”, lo del guión delante es una manía mía que me ayuda a identificar rápidamente que atributos son públicos y cuales privados… no es esencial pero a mi me resulta útil.

Con esto habríamos resuelto el ejercicio pero creo que es una oportunidad perfecta para enseñarte la importancia de los atributos y métodos privados.

2. La importancia de los atributos y métodos privados.

Imagina que le entregamos a un cliente esta clase tal cual la tenemos programada y la empieza a usar en sus sistema de seguridad para ascensores. Nos dice que gracias a nuestro trabajo ha desarrollado un sistema de alarma que le avisa si el ascensor está en peligro de sobrecarga.

Como gracias a nuestro trabajo no ha de preocuparse de que el ascensor se caiga nos va a pagar un pastizal, pero también nos advierte de que si algo sale mal nos va a tirar a sus abogados para que nos quiten hasta los dientes.

Si código es el que sigue:

6.3.solucion3

Como puedes ver el tío tiene razón, ha usado nuestra clase Sistema para montar un sistema de alarma, su méetodo PasajeroEntra le retorna un booleano que le dice si se ha sobrepasado el límite de ocupación o no (que está inicialmente establecido en 4).

¿Te das cuenta de lo que ha hecho este pedazo de imbécil? ¡El tío incrementa el número máximo de pasajeros cuando se supera el límite y se queda tan tranquilo! ¡¡Esta alarma nunca va a sonar!! ¡¡¡Nos va a echar la culpa a nosotros!!!

Vale, es un ejemplo un poco bestia pero toda esa gente va a morir porque nosotros le hemos dejado usar nuestro sistema de seguridad como le ha dado la gana y eso, precisamente, no es seguro… Vamos a hacer un par de cambios:

6.4.mejora1

Ahora nuestro método SetMaxPasajeros es privado y no se puede llamar desde fuera, en cambio el máximo de pasajeros se le pasa a la constructora que sí puede llamar al viejo método SetMaxPasajeros.

¿Que hemos conseguido ahora? Justamente esto:

6.5.mejora2

El tío ya no puede hacer lo que hacía, porque los métodos que quiere tocar ya no son accesibles y por ello se ve obligado a cambiar el código de la siguiente forma:

6.6.mejora3

Se ve obligado a establecer el máximo desde un inicio y ya no lo puede cambiar dentro de nuestro “Sistema” aunque el muy burro lo cambie fuera. Con éste sencillo cambio nuestro sistema ha dado la alarma cuando debía sin sufrir manipulaciones externas… siempre y cuando sea verdad que el ascensor aguanta a 4 personas…

3. Contenido del capítulo

Ya sé que siempre pongo esto en el punto 2 pero esta vez se me ha ido al 3…

  • Introducción a Windows Forms
    • Controles
    • Propiedes
    • Eventos
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Como puedes ver lo prometido es deuda y hoy vamos a hablar de ventanitas, botoncicos 🙂

4. Introducción a Windows Forms

Windows Forms es el nombre que reciben las aplicaciones desarrolladas con Visual Studio que muestran ventanas con botones, menús, campos de texto, etc. Hasta la fecha hemos estado creando aplicaciones de éste tipo pero solamente hemos visto el código, hasta hoy.

Ha llegado el momento de echar un vistazo al fichero “Form1.cs” en su vista de diseño, puedes usar el mismo proyecto que usamos para la calculadora porque nos va a ir de lujo para lo que te quiero enseñar. Si lo abres deberías ver algo como esto:

6.7.forms1

Seguro que lo recuerdas de sesiones anteriores, era esa ventana donde no podíamos tocar nada excepto hacerla más grande. Pues ese es nuestro formulario y es donde vamos a aprender a usar éstos elementos.

4.1. Controles

Lo primero que vamos a hacer es poner un cuadro de texto en éste formulario, para ello desplegamos el “cuadro de herramientas” (a la izquierda) y, dentro de “Controles comunes”,  escogemos “TextBox” haciendo clic. 6.8.forms2

Lo siguiente que has de hacer es dibujar el cuadro de texto sobre el formulario, verás que el cursor ha cambiado de forma al escoger el TextBox así que lo único que tienes que hacer eshacer clic sobre el formulario. Esto hará que aparezca una hermosa y flamante caja de texto vacía.

6.9.form3

 

Verás que la puedes hacer más grande si arrastras los cuadritos blancos de los laterales (aparecen al hacer clic sobre la caja), que la puedes mover si la arrastras, etc. Hasta aparecerán unas guías que te ayudarán a colocarla de forma más cómoda dentro del formulario. Por ahora vamos a hacer que quede de una forma parecida a ésta:

6.10.forms4

4.2. Propiedades

Ahora haz clic sobre la caja para seleccionarla y fíjate en el panel de propiedades abajo a la derecha:

6.11.form5

¿Chulo eh? Esas son todas las propiedades de nuestro TextBox y la mitad no las vamos a tocar en nuestra puta vida. En el listado puedes ver que su nombre es “textBox1”, que su posición es la “12;12” (al menos en mi caso, si en el tuyo es diferente no pasa absolutamente nada) o que sus modificadores son privados (¿te suena?). Vamos a hacer una cosa, vamos a buscar una propiedad que se llama “Text” y vamos a escribir “Hoy estoy chichinabesco” y ni se te ocurra escribir algo diferente o mataré a un gatito.

6.12.form6

Y ahora mira de nuevo tu formulario para contemplar asombrado como ha aparecido ese texto dentro del TextBox.

6.13.form7

Ahora dale al play, verás que aparece esta misma ventana y que podemos jugar con ella y, por supuesto, también podemos modificar el texto que hemos escrito. ¿Por que ocurre esto? ¿Que está pasando? Es muy fácil:

El TextBox que has dibujado, aunque el Visual Studio te lo muestra así en realidad no es más que un objeto, una clase de tipo “TextBox” muy parecida a nuestra clase “Calculadora” pero bastante más compleja. Esta clase “TextBox” tiene sus propios métodos y atributos y uno de ellos es precisamente “Text” que se encarga de almacenar el texto que se ha de mostrar.

 Ahora vamos a añadir un botón a nuestro formulario, repetimos los pasos anteriores pero escogemos “Button” y lo ponemos más o menos así:

6.14.form8

Si haces clic sobre el botón y miras el panel de propiedades verás algo muy parecido a antes, vamos a cambiar la propiedad “Text” y pondremos un texto cualquiera… me siento tán generoso que te dejo elegir XD. Como podrás ver ocurre lo mismo, el texto que sale en el botón ha cambiado.

4.3. Eventos

Ahora quiero que te fijes en el panel de propiedades y busques el símbolo de un rayo, si le haces clic pasarás a ver los eventos del botón (la hojita de la izquierda son las propiedades que veíamos antes, el rayo son los eventos):

6.15.fomr9

Aún no hemos hablado de eventos pero son muy sencillos de entender. Un evento es una especie de método que se ejecuta cuando se produce una situación concreta. Por ejemplo, el evento “Click” de éste botón se ejecuta cuando el usuario le hace clic.

 Vamos a hacer doble clic sobre el texto “Click” y veremos que por automagia se nos ha creado un método click listo para programar:

6.16.form10

Sea lo que sea lo que programes aquí dentro se ejecutará cuando el usuario haga click en el botón. Para demostrarlo vamos a cambiar el texto de la caja de texto que hemos usado antes.

6.17.fomr11

Si recuerdas bien, el TextBox que hemos creado se llamaba “textBox1” (porque no le hemos cambiado el nombre), si lo escribes y le das al punto Visual Studio te muestra sus atributos y métodos. Lo único que hacemos es acceder a su propiedad “Text” y cambiarla por un string a nuestro gusto.

Ahora prueba de darle al play y haz clic en el botón… ¡¡¡sorpresa!!!

6.18.form12

Exacto, ha pasado exactamente lo que hemos programado, al hacer clic se ha ejecutado nuestro código y el texto ha cambiado. Si quieres verlo más en detalle te recomiendo que pongas un breakpoint por ahí e investigues.

Existen infinidad de controles (botones, cajas de texto, tablas, etiquetas…) y obviamente no los vamos a ver todos, pero ya tienes las herramientas necesarias para ir investigando y, como te digo siempre, recuerda que Google es tu amigo y que yo respondo todas las dudas que me encuentro en los comentarios 🙂

5. Resolución de un ejercicio de ejemplo

Para que todo esto quede más claro, vamos a hacer un ejercicio de ejemplo basado en la calculadora que hicimos en el capítulo anterior. Y el ejercicio es… ¡hacer una calculadora!

No te asustes, que la calculadora ya la hemos hecho, es la clase “Calculadora.cs” que hicimos en la sesión anterior pero ahora le vamos a dar una interfaz para que una persona que no sabe programar la pueda usar y, así de paso, ves la diferencia entre el código de una aplicación y el código que controla su interfaz.

Lo primero que vamos a hacer, para que te familiarices con los controles y Visual Studio es imitar la interfaz de la calculadora de Windows en su vista estándar. Usando el mismo proyecto que tenemos creado, vamos a aprovechar el TextBox y el Button que hay en el formulario y vamos a añadir el resto de botones. A continuación te dejo una imagen de la calculadora de Windows (izquierda) y la que he hecho yo (derecha).

  6.19.calc1             6.20.calc2

Antes de liarte a dibujar botones déjame darte dos consejos:

  1. Los botones se pueden copiar y pegar, lo cual es cómodo y útil.
  2. Si quieres poner varios controles iguales, haz clic en el control (del cuadro de herramientas), apreta y deja apretado el control, y a cada clic en el formulario tantas veces como controles del mismo tipo quieras.

Por ahora las calculadoras se parecen como un huevo a una castaña pero ya lo iremos perfilando. Los símbolos de raíz, la flecha, etc. los he cogido del Word (Insertar/Símbolo) pero si no tienes licencia de Word (aquí no animamos a la piratería a no ser que no implique llevar un loro en el hombro) te recomiendo probar con Libre Office (un editor de texto libre y gratuito muy parecido al Word de Microsoft) o, simplemente, copiar y pegar los que te dejo a continuación:

  • Flecha: ←
  • Mas menos: ±
  • Raíz: √

Vale, por ahora no vamos a dejar más bonita la interfaz pero si vamos a tocar un par de detalles de nuestro TextBox. La propiedad Text la vamos a dejar vacía para que no salga nada, y a la propiedad Name le vamos a poner “txtResultado” porque “textBox1” no me gusta… piensa que ahora solo hay un TextBox pero si tuvieras muchos te resultaría muy difícil saber cual es cual si se llaman “textBox1”, “textBox2”, etc.

Vamos a hacer lo mismo con los botones, te dejo escoger el nombre pero te hago dos recomendaciones: que sea un nombre lógico y que empiece por “btn”, como por ejemplo “btnSuma”… ya verás por qué 😉

Vamos al código del formulario principal, re recuerdo que puedes llegar haciendo clic con el botón derecho sobre “Form1.cs” en el “Explorador de soluciones” y escogiendo la opción “Ver código” o pulsando la tecla “F7”.

Asegúrate que todo el código está limpio, deberías ver algo muy parecido a esto:

6.21.clacl3

Vale, antes de empezar a programar una calculadora hay que entender como funciona una calculadora. Como nuestra intención es imitar la calculadora de Windows vamos a ir probando que hace exactamente a fin de irla imitando poco a poco.

Si te fijas, nada más abrirse nos muestra en el resultado un 0, pero si le das al play verás que en tu campo de resultados no aparece nada… No te preocupes que lo solucionaremos.

Empecemos con la suma. Si te fijas, para que la calculadora de Windows haga una suma has de apretar un número, darle al +, después a otro número y acto seguido darle al =. Vamos a empezar programando esto y, para ello hay que entender como funciona por dentro.

Cada vez que pulsas un número aparece en el display de la calculadora, por tanto necesitamos una variable que lo recuerde. Empecemos por ahí. Vamos de nuevo al formulario (si no lo tienes abierto haz doble click en “Form1.cs” en el “Explorador de soluciones” y pulsa sobre el botón “7”. En las propiedades le damos al botón de eventos (el rayo) y hacemos doble click en “click”, lo cual nos lleva de nuevo a la vista de código pero dentro del método click de éste botón.

Como hemos comentado antes, queremos que la calculadora recuerde que hemos pulsado el 7, por lo tanto vamos a definir una variable global, o lo que es lo mismo, un atributo de nuestra clase “Form1”:

6.22.clalc4

Ahora vamos a hacer dos cosas, vamos a decirle a nuestra nueva variable global “_current” que su valor es 7 y vamos a mostrar dicho valor en nuestro TextBox al igual que hace la de Windows:

6.23.calc5

¿Facil verdad? ¿Ves que he puesto un “ToString” detrás de “_current”? El atributo “Text” de “txtResultado” es de tipo string, pero “_current” es un int, el método “ToString” de “_current” permite transformar ese int a string para que lo podamos poner en “Text”.

Si ahora ejecutas la aplicación y le das al botón 7 verás que pasa exactamente esto que decimos aunque no quede igual de bonito que en la calculadora de Windows. Vamos a hacer lo mismo para el resto de números pero primero ahí va otro truco: si haces doble clic a un botón en el formulario crearás automáticamente un evento clic 😉

6.24.calc6

No me han cabido todos en la imagen pero tengo todos los números programados. Volvamos a la calculadora de Windows, y vamos a ver exactamente que pasos sigue a la hora de calcular.

Empieza en 0, si pulsamos el 1 lo muestra en pantalla, si pulsamos el + no hace nada, si pulsamos el 6 lo saca por pantalla, si pulsamos otra vez el + nos saca la suma de 6+1… De esto podemos deducir que la calculadora tiene dos valores principales: el número actual y el resultado.

El primer valor introducido lo usa como resultado. A partir de ahí cada vez que se pulsa un símbolo de operación toma el valor introducido y hace la operación con el resultado… me explico:

actual = 0
resultado = 0

pulso el número 1

actual = 1
resultado = 0

pulso el símbolo +

actual = 0
resultado = 1

pulso el número 3

actual = 3
resultado = 1

pulso el símbolo +

actual = 0
resultado = (3 + 1) = 4

pulso el número 7

actual = 7
resultado = 4

pulso el símbolo –

actual = 0
resultado = (7 + 4) = 11

pulso el número 2

actual = 2
resultado = 11

pulso el símbolo +

actual = 0
resultado = (11 – 2) = 9

Y así hasta el infinito. A esto de deducir como está programada una aplicación estudiando su uso se le llama “Ingeniería Inversa” y en según que cosas (como descubrir como piratear la Play) puede ser hasta ilegal… Microsoft, si estás leyendo esto no te enfades, nuestra calculadora será mucho mejor que la tuya así que tranquila que no estamos copiando nada :p

Bien, soy consciente que programar esto no es trivial, y es posible que tengas la cabeza hecha un lío. No te preocupes, es totalmente normal. Estas cosas se sacan con muchas horas de práctica y muchas más horas de Google.

Si te pongo el código de como programar esto seguramente te limites a leerlo, copiarlo y entenderlo pero lo realmente difícil es sacarlo cuando tienes una pantalla en blanco. Es así como realmente se aprende y se automatizan estas cosas, cuando tienes un lienzo en blanco, te estrujas los sesos y das con una solución que funciona, luego la mejoras, y la vuelves a mejorar… te aseguro que eso no se olvida y proporciona una sensación de satisfacción increíble. Es por ello que no te voy a decir como continuar… ¡hasta el próximo capítulo!

6. Resumen

En realidad no hemos visto muchas cosas en éste capítulo pero si que tienen bastante calado, hemos visto los controles de Windows Forms y solamente hemos usado “Buttons” y “TextBoxes”. También hemos visto que tienen propiedades, métodos e incluso hemos programado alguno de sus eventos como el “Click”.

Por último hemos visto algún ejemplillo y hemos empezado a hacer una calculadora que el muy cabrón de yo no ha querido terminar con la excusa de que esto es bueno para ti.

7. Enunciado del ejercicio para la próxima entrada.

Te dejo para el próximo capítulo la tarea de programar el funcionamiento básico de la calculadora, es decir, eso que hemos explicado con Ingeniería Inversa. Ni más, ni menos.

Creo sinceramente que con todo lo que se ha explicado tienes las herramientas necesarias para hacerlo con éxito. No te pongas límites, no te ofusques, no te preocupes si el código es bonito o eficiente. Usa tantas variables como quieras, públicas o privadas. Haz todo lo que se te ocurra pero haz que funcione. Si consigues hacer que funcione aunque hayas necesitado 2000 líneas de código significa que eres el/la puto amo/a y que estás siguiendo el curso a un ritmo excelente. En serio, para hacer las cosas bonitas siempre se está a tiempo, lo que me interesa ahora es que des con una solución funcional que salga directamente de tu cabeza y a tu manera.

Pista:

¿Recuerdas la clase “Calculadora” del capítulo anterior? Te puede ser de utilidad aunque si no la usas no pasa absolutamente nada.
Usa tantas variables globales como creas que necesitas.
No hay límites de ningún tipo, ¡¡¡desata tu creatividad!!!

5 – Programación orientada a objetos

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

Aunque eres muy feliz están harto de tu aburrido trabajo, necesitas mayores retos y por fin ha llegado tu oportunidad. Tus jefes te han dado el ascenso que tanto te merecías y ahora tienes tres magníficas palancas para ti mismo. ¡¡¡TRES!!! Oh Dios mío, es un sueño hecho realidad. Dos palancas era una mierda pero TRES lo cambia todo… que maravilla… en fin, que me voy por las ramas…. la palanca de la derecha crea un billete de 500, la de la izquierda (al igual que antes) convierte un billete de 500 en dos de 200 y uno de 50. La misteriosa palanca del centro convierte un billete de 200 en uno de 100, y uno de 50… ya sabemos a donde va la pasta que sobra ¿no?

Puedes usar el mismo array que en el ejercicio de ejemplo. De hecho has de hacer lo mismo, pero para 3 palancas.

Solución:

¿Lo has conseguido? Sea de la forma que sea, usando Google, sin ayuda y dándole al coco, sea como sea… si lo has conseguido mis más sinceras felicitaciones, significa que lo estás pillando todo al vuelo. Si no lo has conseguido no pasa, estamos aquí para aprender.

Eso sí, si has mirado la solución sin haberle dedicado como mínimo una hora a darle al tarro haz una cosa: date unos cuantos azotes en el culete y repite conmigo “soy un niño/a muy travieso”. Ahora en serio, no pasa nada siempre y cuando te sirva para aprender, pero como se aprende de verdad es resolviendo las cosas por ti mismo, seré muy pesado con esto porque creo que es el mejor consejo que te puedo dar 🙂

Vale, vamos allá.

Vamos a empezar haciendo caso al enunciado y vamos a hacer un copy/paste del ejemplo del capítulo anterior:

17.ejemplo5

No lo he dicho antes (mea culpa, lo siento) pero habrás notado a la hora de debugar que C# es un lenguaje secuencial, eso quiere decir que las instrucciones se ejecutan en orden una después de otra, en nuestro caso línea a línea de arriba a abajo. Lo que estamos haciendo con los condicionales es abrir caminos, es decir, indicarle al código que unas cosas se ejecutan solo bajo unas condiciones… algo así como las señales de prohibido aparcar a un lado de la acera los días impares.

En el ejemplo anterior iremos ejecutando el código línea a línea y entraremos en el primer condicional. Si cambias el valor de palancaDerecha a false verás que no entras en el primero sino en el segundo.

Vale, copiando esto tenemos medio ejercicio resuelto ya que tenemos programado el comportamiento de dos de las tres palancas. Primero vamos a entender bien que estamos haciendo, nos vamos a alejar mucho, tanto que no vamos a ver el código sino solo la idea que refleja de una forma sencilla y abstracta. Vamos a dibujar el diagrama de flujo:

5.2.solucion2

Aquí se ve muy clara la idea que sigue nuestro programa, el rombo representa la decisión de tirar de la palanca derecha, el SI nos lleva una acción y el NO a otra acción diferente por lo que estamos haciendo algo como “Si estiro la derecha hago lo que hace la palanca derecha, sino hago lo que hace la palanca izquierda”.

Esto lo podemos extender fácilmente haciendo: “Si estiro de la palanca de la derecha, hago lo que hace la palanca derecha, sino hago otra cosa“. ¿Ves por donde voy?

5.3.solucion3

Esto en código sería algo muy parecido a lo de antes… de hecho es lo mismo pero borrando el código que aún no hemos programado:

5.1.solucion1

Si te fijas, esa “otra cosa diferente” puede ser otra decisión, nada te lo prohíbe 😉

5.4.solucion4

A mi me resulta muy útil hacer éste tipo de dibujos, sobretodo con casuísticas muy complicadas ya que se puede ver de un simple vistazo cual es el razonamiento detrás de tu código y, es más, no importa en que lenguaje lo vayas a programar porque el razonamiento será el mismo.

Siempre que tengas dudas, te recomiendo que cojas pepel y boli (y a tu amigo Google) y te pongas a pensar en “Que tengo que hacer” y una vez claro “Como lo hago”. Si el esquema que dibujas tiene sentido entonces, y sólo entonces, estás listo para empezar a programar.

Veamos el código final:

5.5.solucion5

Como puedes ver he incrementado el array en un posición para que pueda usar billetes de 100 pues en el ejercicio de ejemplo no habían.

Espero haberme sabido explicar, si te baila algún concepto dame un toque en los comentarios que te aclaro lo que haga falta.

Bien, ¿hemos terminado? ¡¡¡NO!!! Porque como siempre voy a aprovechar para dejarlo todo un poco más bonito 🙂

2. Contenido del capítulo

Déjame dar un pequeño vistazo al contenido de éste capítulo antes de seguir, vamos a ver lo siguiente:

  • Operadores lógicos con otros tipos de datos
    • =
    • !=
    • >
    • <
  • Introducción a la programación orientada a objetos
    • ¿Que es un objeto?
    • Atributos
    • Métodos
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

La verdad es que en éste capítulo quería dejar el “aburrido” mundo del código y empezar a ver cosicas más curiosas como ventanitas, botones y otras cosas gráficas pero creo que aún no estamos preparados. Bueno, sí lo estamos pero lo veríamos muy a medias y no quiero liaros, creo que me sabréis perdonar si os prometo si o sí que en la próxima sesión tocaremos el tema de los Windows Forms que son más divertidos.

En serio, si te estás cansando de ésto solo te pido un pequeño esfuerzo más, seguro que la próxima sesión te parece mucho más divertida… casi casi como Breaking Bad, que el primer capítulo es raro, el segundo te planteas dejar la serie pero después del tercero te tragas las 5 temporadas y te masturbas pensando en Brian Cranson, la meta azul y la bendita madre que parió a los guionistas. Un 10 para ellos.

Lo dicho, si dejas de lado éste curso que por lo menos sea para ver Breaking Bad :p

3. Operadores lógicos con otros tipos de datos

Te he enseñado lo que son los números booleanos, como se opera con ellos, etc. Lo cierto es que también se puede operar con otros tipos de datos mediante operadores lógicos. Ya hemos visto algunos de ellos que nos son más conocidos en nuestro día a día como la suma y la resta, pero los que vamos a ver ahora entran en el campo de las comparaciones.

3.1 =

Éste es el operador de igualdad, que devuelve cierto o falso. Por ejemplo:

5.6.comparador1

En C# una operación de igualdad se hace con dos signos de igual seguidos (los paréntesis son opcionales, los he puesto para que quede más claro) y como se puede ver “no_son_iguales” valdrá falso mientras que “son_iguales” valdrá cierto. ¿Por que? Porque los operadores de comparación retornan booleanos, ese es el motivo por el que los podemos usar en los condicionales.

3.2 !=

A éste operador se le conoce como desigualdad, y viene a ser el contrario que el anterior. Básicamente sirve para mirar si algo es diferente a otra cosa.

5.8.comparador3

Aquí se puede ver que los dos booleanos son ciertos.

3.3 >

El operador de “mayor que” se representa con éste tipo de símbolo, si te fijas la parte más abierta apunta al elemento que queremos ver si es mayor. En C# se usa así:

5.7.comparador2

En nuestro caso, numero1 no es mayor que numero2, pero numero2 si es mayor que numero3. Como bonus remarcar que numero1 no es mayor que numero3, son iguales, que no es lo mismo 😉

3.4 <

El operador “menor que” funciona a la inversa que el anterior, me ahorro el ejemplo porque es exactamente lo mismo pero dándole la vuelta.

¡Ah! Y funciona también con floats, strings, etc…

Vale, visto esto, ¿como lo podemos usar para mejorar nuestro ejercicio anterior? Pues si te fijas, en el primer ejercicio un booleano nos iba bien porque teníamos 2 palancas, ya que un booleano solo tiene 2 valores: cierto o falso.

Ahora que tenemos 3 palancas, parece que nos iría mejor usar otro tipo de elemento como por ejemplo un número entero. Podríamos hacerlo así:

5.9.mejora_ejercicio1

¿Ves? Usando un entero conseguimos lo mismo y nos ahorramos el segundo booleano. En éste caso uso el valor del entero para determinar que camino seguirá la ejecución del código.

Aún se puede mejorar más, pero antes fíjate en una cosa: el diagrama de flujo no ha cambiado, pero sí el código. Eso significa que existen muchas maneras de llevar a cabo una idea, y también existen diferentes ideas para llevar a cabo una tarea.

Para mejorar esto un poco más necesito explicarte otra cosa sobre los condicionales. Hemos visto el “SI” y el “SINO”, es decir, el “if” y el “else”, pero también existe el “SINO SI” o “else if” lo cual nos permite comprimir un poco el código, veamos:

5.10.mejora_ejercicio2

De ésta forma nos ahorramos un condicional dentro de otro condicional, cosa que os recomiendo evitar porque puede resultar en un puto lío de cojones, sobretodo cuando sobrepasa los dos niveles.

No creo que haga falta explicar mucho más el código, básicamente hacemos “SI es la palanca derecha ENTONCES hacemos la derecha. SINO SI es la palanca izquierda ENTONCES hacemos la palanca izquierda. SINO hacemos la palanca central” (pongo mayúsculas para que se noten bien los condicionales).

Y aún se podría hacer alguna cosilla más, pero lo vamos a dejar aquí que no te quiero liar más la cabeza.

4. Introducción a la programación orientada a objetos

C# es un leguaje de programación orientado a objetos, lo cual dicho de una forma sencilla significa que podemos crear nuestros propios componentes, usar los de otros, extenderlos, etc. facilitando mucho la comprensión del código y dotándolo de gran potencia y versatilidad.

4.1. ¿Que es un objeto?

Un objeto no es más que la encapsulación de un conjunto de elementos, dicho de otro modo, es coger un grupo de variables y meterlas dentro de una caja. Lo vas a ver super claro si recuperamos el ejemplo de las palancas.

En el ejemplo de las palancas tenemos un array que hemos usado para guardar nuestro dinerito, y un código que determina que tipo de acción se ejecuta en función de las palancas de las que se estira. Esto que nosotros hemos programado directamente sobre el código del formulario lo podemos encapsular en un objeto, al que podemos llamar, por ejemplo, “Fabrica”. En C# los objetos se definen mediante “clases” y siguien la siguiente nomenclatura:

5.11.clases1

Esto le dice a C# que vamos a crear un nuevo objeto que se llamará fábrica.

Vamos a crear nuestro primer objeto y para ello vamos a crear un nuevo fichero. No es obligatorio meter las clases en ficheros separados pero si muy recomendable ya que facilita su mantenimiento. Veamos como se hace:

5.12.clases2

Se hace clic con el botón derecho sobre el proyecto, se selecciona “agregar” y se escoge la “clase”.

5.12.clases3

Donde pone nombre le vamos a poner “Fabrica.cs”, donde “Fabrica” es el nombre y  “cs” la extensión de una clase C#. Cuando le des a agregar verás que te abre tu nueva y flamante clase:

5.13.clase4

Vale, ahora tenemos nuestra clase vacía, aún no hace nada pero oye, por lo menos hemos visto como se crean. Es fácil ¿no?.

4.1. Atributos

Los atributos son los campos que tiene nuestra clase, por ejemplo si nuestra clase fuera un Coche, los atributos podrían ser “color”, “caballos”, “velocidad máxima”, etc. Si nuestra clase fuera “Persona” los atributos podrían ser “edad”, “sexo”, “altura”, etc.

Como nuestra clase es la “Fabrica” del ejercicio anterior lo que vamos a poner como atributos son los dineritos que genera, que en lugar de meterlos en un array los vamos a poner en sus propios campos:

5.14.clase5

Vamos a fijarnos en varias cosas. Para empezar el nombre de la clase está en mayúsculas, eso no es estrictamente obligatorio pero se ha adoptado por convenio que es mejor hacerlo así. Si te preguntas por que verás que los atributos de la clase “billete50”, “billete100”, “billete200”, “billete500” empiezan por minúsculas, también va por convenio y es precisamente para distinguirlos rápidamente de las clases. Si empieza por mayúscula: clase; si empieza por minúscula: atributo o variable.

Vale, yo he creado 4 atributos y usaré cada uno de ellos para almacenar el número de billetes que voy generando, la palabra “public” que aparece delante de cada atributo sirve para indicar que éste atributo es público y se puede ver desde fuera de la clase… es un concepto que veremos más adelante así que no le des más vueltas por ahora que no quiero que te me pierdas.

4.2. Métodos

Esta parte es un poco más complicada así que voy a intentar simplificarla al máximo.

Los métodos son las acciones que puede realizar un objeto, por usar los mismos ejemplos de antes con una clase “Coche” un método podría ser “Acelerar”, “Frenar”, “Girar”, etc. Con una “Persona” los métodos podrían ser “Correr”, “Hablar”, “Cagar”, etc.

En el ejemplo que nos ocupa los métodos podrían ser simplemente “PalancaDerecha”, “PalancaIzquierda”, “PalancaCentral”, veamos:

5.15.clase6

4.2.1. Acciones

Como puedes ver, un método se declara con un indicador de “public” (más adelante veremos que quiere decir y que otros tipos existen), “void” (que también veremos más adelante que quiere decir), el nombre del método que también empieza por mayúsculas por convenio, unos paréntesis y unas llaves que marcan el inicio y el final del método.

¿Y para que sirven los métodos? Pues para definir comportamientos. Vamos a meter el código de las palancas del ejercicio anterior dentro de cada método y los vamos a adaptar a los atributos que tenemos definidos:

5.16.clase7

Lo que hemos hecho es encapsular el comportamiento de las palancas dentro de un objeto llamado “Fábrica” que tiene 3 métodos, uno por palanca. Además cada palanca realiza su función modificando apropiadamente los atributos de “Fabrica”.

El “void” que vemos por ahí indica que nuestro método no retorna ningún valor, simplemente realiza una acción y por ello se le conoce como “acción”. Las “funciones” en cambio son algo diferentes y enseguida verás la diferencia.

4.2.2. Funciones

Voy a crear un nuevo método que calcule el total de pasta que tiene Fabrica.

5.17.clase8

Fíjate que ya no aparece el “void” sino el tipo de dato “int”, esto quiere decir que el método devuelve un dato de tipo entero. Si te fijas lo que he hecho es calcular el total de dinero que tiene la fabrica y retornalo, la cláusula return es la que envía el resultado de la función hacia fuera.

Como el valor que he calculado es un número entero lo puedo devolver mediante “return”, si hubiera sido de otro tipo tendría que haber cambiado el tipo de retorno o el Visual Studio me lo habría subrayado en rojo.

4.2.3 Contructor

Existen excepciones, pero normalmente los objetos necesitan instanciarse para poderse usar. Cuando un objeto se instancia se le dice al programa que lo queremos crear y que debe reservar espacio en memoria para poder usarlo, es como decirle a la familia en navidades que haga sitio en la mesa porque vamos a sacar el trivial.

Para que una clase se pueda instanciar necesita un constructor, un contructor es un método un poco especial:

5.18.clase9

Se parece mucho a los métodos pero no tiene tipo de retorno, ni “void”, ni “int”, ni “string” ni nada de nada. Además el nombre del método es el nombre de la clase.

Lo que se suele hacer dentro de los constructores es dar un valor iniciar a sus atributos, como nosotros tenemos atributos de tipo “int” los vamos a poner a cero que es como estaría la fábrica el primer día de apertura:

5.19.clase10

Seguro que ahora te parece un mundo, pero te aseguro que cuando hayas hecho un par lo verás super fácil. Tú tranquilo que voy a poner algunos ejemplos muy fáciles de pillar que te ayudarán a atar cabos, si no los ves claro aún no te preocupes y sigue leyendo 🙂

Vale, ya hemos visto como se crea la clase, sus atributos y sus métodos. Ahora nos queda ver como se usa.

Lo primer que tenemos que hacer es instanciar nuestro nuevo y flamante objeto “Fabrica”, nos vamos a ir al código fuente de “Form1.cs” (si lo has cerrado recuerda que puedes entrar haciendo clic con el botón derecho sobre “Form1.cs” en el “Explorador de soluciones” y seleccionar código fuente. Si también has cerrado el “Explorador de soluciones” recuerda que lo puedes abrir fácilmente desde el menú “Ver” y después “Explorador de soluciones” o pulsando “Ctrl + Alt + L”.

Ahora que estamos en “Form1.cs” vamos a instanciar nuestra clase de la siguiente manera:

5.20.clase11

Con “Fabrica f” hemos creado una nueva variable llamada “f” y que es de tipo “Fabrica”, de la misma forma que hemos hecho tantas veces con enteros y booleanos. Con “= new Fabrica()”  le hemos dicho a nuestro programa que debe reservar espacio en memoria para ella.

Vamos a ver como se comporta esto, vamos a poner un breakpoint sobre ésta línea y otra dentro del contrustor de Fabrica:

5.21.clase12    5.22.clase13

Ahora vamos a ejecutar nuestro programa línea a línea y verás como, cuando llegue el momento de crear el nuevo objeto se mete dentro de la constructora e inicializa los atributos a cero.

Vamos ahora a realizar una llamada a cada uno de sus métodos de la siguiente manera:

5.23.clase14

Cuando lo estés programando verás que, cuando escribes la variable “f” y le das al punto te despliega todo el listado de métodos y atributos de la clase que has definido. Esto se conoce como “Intellisense” y es la ayuda que nos proporciona Visual Studio para trabajar con objetos, es muy útil para saber que hace un objeto que no has hecho tú ya que puedes mirar que propiedades y métodos tiene y te puede dar una muy buena idea de por donde van los tiros.

Lo que hemos hecho es invocar a sus métodos palanca e ir grabando el valor en total, si debugas te será fácil ver como la cosa funciona como una seda. De hecho te invito a que inspecciones el objeto Fabrica y veas sus tripas en plena ejecución. Para hacerlo por un breakpoint allá donde quieras parar e inicia la ejecución:

5.24.clase15

Si haces clic con el botón derecho sobre la variable f y seleccionas “Insepcción rápida” abrirás el inspector de objetos con el que podrás ver cómodamente cuanto valen los atributos de nuestra clase “Fabrica”:

5.25.clase16

Te invito a que juguetees un rato con esto y vayas viendo los cambios que se producen, también puedes seleccionar “Agregar inspección” en lugar de abrir la “Inspección rápida” si quieres ir viendo como cambian los valores en tiempo real (acuérdate de tocar el pin al lado de la X cuando se abra el panel de inspección, sino se esconderá solo).

5.25.clase17

5. Resolución de un ejercicio de ejemplo

¡Buf! ¿Cuanta información de golpe verdad? Tranquilo que esto es más fácil de lo que parece y para demostrarlo te voy a poner un ejemplo muy sencillo. Después de todo quieres ver ventanas en la próxima sesión… ¿o no? Pues si quieres ver ventanas me temo que primero te has de comer todo este rollo 😉

Empecemos por el enunciado:

Haz una puta calculadora

Jajajaja, perdona, no lo he podido evitar. Creo que hacía rato que no soltaba algún taco y me quemaba la boca… en fin, que vamos a hacer una calculadora muy muy simple. Lo que tiene que hacer nuestra calculadora es lo siguiente:

  • Tener un campo donde se almacena el total, inicialmente vale cero.
  • Sumar un número decimal al total.
  • Restar un número decimal al total.
  • Multiplicar un número decimal al total.
  • Dividir el total por un número decimal.
  • Pedir el total acumulado.
  • Resetear el total a cero.

Vale, como he prometido es una calculadora muy sencillita. Vamos a comenzar creando una nueva clase a la que llamaremos “Calculadora.cs”.

5.26.calc.1

 

Existen una serie de trucos para deducir la forma de montar un objeto. Seguramente llegado a éste punto estés un poco perdido sobre como continuar y es totalmente normal, no te preocupes que el tito Fher te va a contar un secreto y es que existe una forma de, dado un enunciado, deducir por donde van los tiros.

El primero es el más simple: los sustantivos equivalen a objetos, es decir, los nombres son clases. Por ejemplo: el enunciado habla de una calculadora, así que ahí tenemos una clase.
El segundo es muy sencillo también, las acciones o verbos son métodos. En el ejemplo aparecen Sumar, restas, multiplicar, dividir, pedir el total y resetearlo que serán los métodos a implementar.
Por último, los adjetivos siempre hacen referencia a una propiedad, por ejemplo: “una persona es alta” nos daría dos pistas, necesitamos una clase “persona” con un atributo “altura”.  En éste ejemplo no se ve muy claro pero creo que es bastante evidente que el “total” es un campo de la calculadora y por tanto un atributo.

Obviamente esto no es una regla a seguir a pies juntillas, pero si la tienes en mente y la adornas con un poco de sentido común creo que te puede ser de gran utilidad. Y no te preocupes si alguna cosa no te queda del todo atada, recuerda que existen muchas formas de resolver los problemas y muchas veces la mejor solución se presenta sobre la marcha. Coge papel y boli, empieza a hacer esquemas y, cuando tengas clara la idea tírate a programar que los detallitos ya los irás puliendo.

Dicho esto vamos a definir las propiedades y métodos de nuestra calculadora:

5.27.calc.2

Fíjate que el atributo “total” lo he declarado como privado, no te preocupes que más adelante te explicaré la diferencia. Además todos los métodos toman de entrada parámetros float que nos permite el uso de decimales tal y como exige el enunciado. Por último date cuenta que el atributo “total” y el método “Total” no son iguales porque C# es “case-sensitive”, es decir, distingue mayúsculas de minúsculas. Por cierto, “Total” aparece marcado en rojo porque debe retornar un “float” y ahora mismo no lo hace porque no la he programado.

Date cuenta que Sumar, Restar, Multiplicar, Dividir y Reset son acciones. No retornan ningún valor y lo único que hacen es realizar acciones matemáicas sobre “total”. El método “Total” en cambio es una función que no toma parámetros de entrada pero si que nos da un float como salida.

Ahora vamos a programar los métodos tal y como nos pide el enunciado, creo que con lo que hemos visto hasta ahora te será fácil entender lo que hago. Como siempre, si no es así déjame un comentario y te aclaro cualquier duda sobre el tema.


5.28.calc.3

Tenemos el constructor (el primer método que se llama como la clase) que setea el atributo”total” a cero y el resto de métodos que hacen lo que nos pide el enunciado. Ya hemos terminado el ejercicio, ¿fácil no?.

Vamos a probar un poco nuestra nueva clase volviendo al código de “Form1”, instanciando nuestra clase y usando sus métodos a ver que hace. Yo te propongo el siguiente código pero puedes hacer lo que te de la gana, al fin y al cabo en tu ordenador la has programado tu 🙂

5.29.calc.4

Si lo debugas podrás ir viendo como va cambiando el valor que guarda nuestra calculadora, te invito a jugar con el código un rato para acabar de pillarle el truco… por cierto, ¿recuerdas aquello que nos decían en clase de mates sobre dividir un número entre cero? Te invito a probarlo pero no explicaré como controlar ese tipo de situaciones hasta más adelante 😉

Por cierto, ¿has mirado detenidamente el listado de métodos y atributos de “Calculadora” que nos lanza intellisense cuando escribimos “calc” y le damos al punto?

5.30.intellisense

Hay métodos que nosotros no hemos programado como Equals, GetHashCode o GetType que aparecen porque son heredados de Object. Todas las clases que programes heredarán automáticamente de un objeto de .NET llamado Object… no te preocupes por la herencia que la veremos más adelante. Lo que quiero que busques es el atributo “total”… no sale, ¿a que no? Eso es porque es privado.

Los métodos y atributos privados se pueden usar dentro de la clase pero no se pueden ver desde fuera. Por eso cuando programas en “Calculadora” puedes ver a “total” pero cuando usas el objeto “Calculadora” desde “Form1” no lo ves. Es una forma de proteger las partes sensibles del código que un programador manazas no debería tocar.

Por ejemplo, a nuestra amiga Cloe le gusta nuestra calculadora y la quiere usar, con los métodos públicos le estás dando una forma segura de usar la calculadora porque le das métodos que has probado y sabes que funcionan. En cambio no le das acceso al atributo total porque lo podría tocar sin quierer y cambiar los resultados de las operaciones, en cuyo caso no podrías garantizar el correcto funcionamiento de la calculadora.

6. Resumen

Bueno bueno bueno, hoy hemos visto muchas cosas nuevas. Unas más bonitas, otras más difíciles pero todas ellas igual de importantes.

Tenemos por un lado los objetos, que programamos mediante clases y nos permiten agrupar funcionalidades. Los objetos a su vez tienen atributos (públicos y privados) y métodos (acciones y funciones públicas o privadas).

La idea de usar objetos es organizar nuestro código por “temáticas”, creando piezas del puzzle que después podemos usar cómodamente para resolver un problema mayor.

7. Enunciado del ejercicio para la próxima entrada

“Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máxima de pasajeros permitido y tu sistema debe permitir lo siguiente:”

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Pistas:

Se parece mucho a la calculadora pero más sencillo. Trata de identificar las clases (aunque solo necesitas programar una), los atributos (hay uno) y los métodos necesarios (5 si contamos el constructor, pero se puede hacer con 4).

4 – Booleanos y condicionales

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

Una persona te dice que tiene un huerto con cinco parcelas, en la primera cultiva lechugas, en la segunda cultiva zanahorias, en la tercera planta cebollas, la cuarta la tiene vacía y en la quinta tiene puerros.

Un día viene una chica a comprarle unas hortalizas, y en la lista de la compra tiene apuntado comprar 3 zanahorias, 1 cebolla y 2 lechugas.

Escribe el código necesario para calcular el número de hortalizas totales (un número entero) que le quedarán al payés una vez haya realizado la venta. Utiliza como mínimo un array.

Solución:

Bueno, si has seguido el último capítulo habrás visto que es prácticamente una copia del ejemplo de las monedas pero con hortalizas y lo habrás resulto con relativa facilidad. Si no es así no seas tímido y déjame en los comentarios todas tus dudas y preguntas que estaré encantado de contestar 🙂

El enunciado nos habla de 5 parcelas, lo cual ya es una pista de que necesitaremos un array de 5 elementos. La primera posición (la cero) la usaremos para las lechugas, en la segunda zanahorias, después cebollas, en la cuarta no pondremos nada y en la quinta los puerros.

Aquí he sido un poco cabrón y he hecho una pequeña trampa, no te he dicho cuantas hortalizas tiene el payés. Si te fijas bien el enunciado te pide el código para calcular el número final de hortalizas por lo que cuantas tenemos al principio es un dato que no nos hace falta y lo podemos obviar, por tanto la declaración de nuestro array quedaría así:

1.resol.array

Lo que sí que nos dice el enunciado es el número de hortalizas que compra una chica, por lo que podemos realizas las restas en las casillas correspondientes.

2.resol.array

Y éste es el código completo que, dado un array de 5 elementos (que representa al huerto) calcula el número final de hortalizas que quedarán. Ahora te puede parecer raro, pero ya verás que eso de trabajar con cosas que no sabes que valor tienen va a ser nuestro pan de cada día, de hecho si has estudiado algo de matemáticas te sonará de algo… lo llaman incógnitas y suele representarse con una letra X.

2. Contenido del capítulo

Llevamos solo 3 cápitulos (4 con éste) y ya hemos aprendido un montón de cosas, en ésta sesión vamos a ver lo siguiente:

  • Booleanos
    • Números booleanos
    • Operadores lógicos
    • Condicionales
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Como siempre, voy a dar por sentado que los conceptos del capítulo anterior están claros. Si no es así te animo a pegarle un repaso o a dejarme tus consultas en los comentarios.

De hecho me está dando miedo ir demasiado rápido o dar cosas de más por supuestas. Si te cuesta seguirme el ritmo, si crees que me dejo cosas o que necesitas más detalles no seas tímido y déjame tus sugerencias en los comentarios, te prometo que no muerdo. Prefiero que me digas “Eh tio, no me entero de una mierda” a que dejes el curso, dame un toque y te explico lo que necesites saber.

3. Booleanos

Si recuerdas bien hemos visto tres tipos básicos de datos: enteros o int (1, 2, -35, 20190320101, …), decimales o float (1.3, 34.231234, -0.33329099999, …) y texto o string (“hola”, “adios”). Pues bien, ahora vamos a hacer un nuevo amigo, quizás el amigo más importante de todos: el booleano.

¡¡¡ALERTA CULTURAL!!!

Por si no te acuerdas, lo bloques de alerta cultural te los puedes saltar si te aburren o simplemente te da palo leerlo. Creo que son interesantes y que te pueden ser de utilidad pero en serio, si estas cosas te aburren busca el final y sigue con el capítulo desde ahí que no pasa absolutamente nada.

El álgebra de Boole es un campo de las mátemáticas que define un conjunto de estructuras y operaciones básicas. Toda la computación que tenemos hoy en día se basa en eso… casi nada ¿eh?

Los ordenadores, por dentro, si pillas in microscopio y lo incrustas en el microprocesador, a nivel físico hacen esto, álgebra de Boole. Es como decir que tu pisas el acelerador y el coche se mueve y el paisaje avanza, eso es gracias a un motor que hace su magia por dentro… pues aquí algo parecido. Tu mueves el ratón y el cursor responde gracias al álgebra de Boole (entre otras cosas).

Por hacer un resumen y ponerlo fácil el álgebra de Boole se compone (entre otros) de los siguientes operadores: AND, OR, NOT e IF. Eso son los operadores, y los operandos son lo que conocemos como números booleanos.

El número booleano es la estructura más simple de todas, el bit. El bit es la base de todo el sistema binario con el que trabajan los ordenadores y su valor puede ser 1 o 0… sí sí, en serio, un “uno” o un “cero”.

¡¡¡FIN DE LA ALERTA CULTURAL!!!

3.1. Declaración

Para simplificar y no aburriros diremos que un booleano solo puede valer “cierto” o “falso” y en C# se declara así:

3.bools

Hemos instanciado dos booleanos llamados “b_si” y “b_no” donde el primero es cierto y el segundo es falso.

Ahora toca operar con ellos, con los enteros y los floats operábamos matemáticamente con sumas, restas, etc… Con los floats se opera lógicamente. No te me asustes que es muy fácil.

3.2. Operaciónes lógicas

Vamos a ver 4 tipos de operaciones lógicas: AND, OR, NOT e IF.

3.2.1. AND

El AND es un operador de conjunción y en castellano lo podríamos leer como Y, como por ejemplo “x Y z”. Con los operadores lógicos se trabaja a nivel de cierto o falso y el resultado de una operación con AND requiere que todos sus operandos sean cierto para que el resultado sea cierto. Como esto que acabo de decir apenas se entiende veamos el siguiente ejemplo:

4.and

 ¿Lo ves? La única manera de que el resultado de x Y z sea cierto es que tanto x como z sean ciertos. Esto en C# lo escribiríamos así:

5.and_csharp

¿Que resultado tendrá un AND? Solo con que un elemento sea falso ya sabremos que es falso.

3.2.2. OR

Tenemos por otro lado el OR, la disjunción, que se puede leer como “Ó” y que hace justo lo contrario, solo conque uno de los operandos sea cierto el resultado es cierto:

6.or

Que en C# sería así:

7.or_csharp

¿Que resultado tendrá el OR? Solo conque uno de sus elementos sea cierto ya sabremos que será cierto.

3.2.3. NOT

El NOT es la negación, es tan tonto como invertir el resultado. NOT Cierto es Falso y NOT Falso es cierto. En C# sería así:

8.not_csharp

Y si NOT Cierto = Falso y NOT Falso = Cierto… que es ¿NOT NOT Cierto? Pues si lo haces por partes te queda que NOT NOT Cierto = NOT Falso = Cierto… no te preocupes que no suele ser tan complicado… de hecho si te aparece alguna cosa así seguramente has metido la pata por alguna parte o simplemente se puede simplificar.

3.2.4. IF

El IF es la forma que tienen los operadores lógicos de manejar cláusulas condicionales y pueden leerse en castellano como un SI condicional, por ejemplo:
SI b es cierto ENTONCES haces esto, SINO haces lo otro.

Esto en C# sería de la siguiente forma:

9. if

Vamos a darle la vuelta, para que veas que esta cosa tan tonta se puede hacer “del revés”.

10.if2

¿Lo ves? Es fácil ver que es lo mismo pero dado la vuelta. En multitud de ocasiones te preguntarás si hacerlo de una forma o de otra y la verdad es que no existe respuesta, hazlo como te salga de los huevos / ovarios. Mientras lo veas claro y te sientas cómodo yo ya me doy por satisfecho, de hecho muchas veces te preguntarás cual es la forma correcta y, a no ser que el impacto en el rendimiento sea crítico, la respuesta suele ser siempre la misma: tu comodidad como programador manda, sobretodo si no tienes un jefe al que rendir cuentas de tus decisiones 😉

Ya que estamos, voy a enseñarte un pequeño truco:

11.if3

¡Hostias! Esto es la pereza absoluta hecha condicional. Preguntar a un condicional si una cosa “es cierta” es lo mismo que preguntarle simplemente si una cosa “es”, ya irás viendo que me gusta ir reduciendo las cosas a la mínima expresión, a menos líneas y menos letras más limpio y fácil de mantener. Recuerda siempre que el número de errores de un programa es directamente proporcional (yo diría que exponencialmente) a su número de líneas por lo que te recomiendo que abraces la pereza de escribir lo mínimo posible.

Y ya que estamos perezosos… ¿como se le da la vuelta a esto? Veamos:

12.if4

Ale, se le casca una exclamación delante y listos. Recuerda que la exclamación es la forma que tiene C# de hacer un NOT, así que lo que estamos preguntando es si una cosa “no es”, lo cual es lo mismo que preguntar si “es falsa” o si una cosa “no es cierta”.

5. Resolución de un ejercicio de ejemplo

Bueno, llegados a éste punto quiero poner en práctica lo que hemos aprendido, porque la teoría sin práctica no sirve de una puta mierda y, seamos sinceros, si es la primera vez que ves algo parecido a ésto te estarás haciendo un cacao mental de la hostia. Empecemos con un enunciado muy fácil.

Tienes el trabajo más aburrido del mundo pero eres muy feliz… aunque eso no quita que sea tremendamente, enromemente, insufriblemente aburrido.
Tu trabajo consiste en estirar de dos palancas, cuando estiras de la palanca de la derecha creas billetes de 500€, cuando estiras de la palanca de la izquierda conviertes el billete de 500€ en dos billetes de 200€, un billete de 50€ y los 50€ restantes se desvían a las tarjetas black de los hijos de puta de Caja Madrid y aquí no ha pasado nada.

Teniendo en cuenta que un array de enteros de 3 posiciones (donde cada posición es para un tipo de billete diferente), escribe el código que realiza las operaciones en función de la palanca que estiras.

Bueno, tranquilo que es más fácil de lo que parece. Vamos a empezar declarando ese array que sale por ahí.

13.ejemplo1

Vale, tenemos un array de 3 posiciones como nos sugiere el enunciado y vamos a usar la posición 0 para los billetes de 50, la 1 para los de 200 y la 3 para los de 500… en realidad lo puedes hacer en el orden que os de la gana pero ésta me ha parecido la más lógico.

Ahora toca definir las palancas, lo único que necesitamos saber es si es derecha o es izquierda. Vamos a usar un booleano, lo vamos a llamar palancaDerecha y… ¡exacto! si es cierto es la palanca derecha y si es falso será la izquierda porque es la única que queda.

14.ejemplo2

Ahora nos toca montar el condicional, lo voy a hacer como en los ejemplos anteriores:

15.ejemplo3

 

He puesto el booleano a cierto para que no se me queje el compilador, obviamente sabemos que parte del código se va a ejecutar pero ya veremos más adelante que no suele ser así.
Voy a llenar los huecos con lo que pide el enunciado.

16.ejemplo4

 

Ésta parte se parece mucho a los ejercicios de capítulos anteriores así que me ahorro el explicarla, si tienes dudas pégale un vistazo al capítulo anterior o déjame un comentario y te echo una mano.
Aunque no lo pide el enunciado voy a añadir una línea que calcule la pasta final y voy a mostrarte el código completo.

17.ejemplo5

Te acuerdas de como se debuga ¿verdad? Pues dale caña al mono, pon un breakpoint sobre la delcaración del array, pulsa el play verde y ves pulsando la tecla F10. Verás como la ejecución avanza punto por punto, como entra en el primer condicional y como el resultado de “total” es 500.

18.ejemplo6

6. Resmuen.

Llegados a éste punto y si la cabeza no te ha estallado debería quedarte claro lo que es un booleano y como se utiliza.

Hemos visto que existen 4 operadores: AND, OR, NOT y IF. El AND mira que todos sean ciertos, el OR que solo uno lo sea, el NOT le da la vuelta y el IF nos permite tomar decisiones.
Dicho de carrerilla parece rápido y fácil, si te lo ha parecido bien por ti, si no tranquilo, a mi me costó mucho tiempo pillarlo pero con práctica todo se consigue.

7. Ejercicio

Vale, antes de poner el enunciado te pido perdón porque voy a ser un poco cabroncete. Quiero que le des al coco y pienses por ti mismo una forma de solucionarlo, con lo que hemos visto hasta ahora deberías ser capaz de hacerlo mirando solamente éste blog, pero te recomiendo encarecidamente que tires de “San Google” si te quedas bloqueado, en mi trabajo de cada día me encuentro constantemente con cosas que no tengo claro como resolver y el Sr. Google es mi mejor aliado.

Bien, allá vamos:

Aunque eres muy feliz están harto de tu aburrido trabajo, necesitas mayores retos y por fin ha llegado tu oportunidad. Tus jefes te han dado el ascenso que tanto te merecías y ahora tienes tres magníficas palancas para ti mismo. ¡¡¡TRES!!! Oh Dios mío, es un sueño hecho realidad. Dos palancas era una mierda pero TRES lo cambia todo… que maravilla… en fin, que me voy por las ramas…. la palanca de la derecha crea un billete de 500, la de la izquierda (al igual que antes) convierte un billete de 500 en dos de 200 y uno de 50. La misteriosa palanca del centro convierte un billete de 200 en uno de 100, y uno de 50… ya sabemos a donde va la pasta que sobra ¿no?

Puedes usar el mismo array que en el ejercicio de ejemplo. De hecho has de hacer lo mismo, pero para 3 palancas.

Pista:
Puedes basarte en la solución del ejercicio de ejemplo.
Busca la manera de poder tomar 3 decisiones, puedes crear tantas variables como necesites.
Puedes usar tantos condicionales como necesites.

Como siempre la respuesta en el próximo post.
Saludos y gracias por llegar hasta aquí.

¡Hasta la próxima!

3 – Tipos de datos

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

“El mismo señor que te había pedido que sumaras dos número cualesquiera te pide ahora que le hagas lo mismo con una resta, una multiplicación y una división y guardes los resultados en cuatro variables diferentes.”

Solución:

Lo cierto es que el ejercicio no tenía mucho misterio y estoy seguro que, después de haber hecho una suma en el capítulo dos no os ha resultado muy difícil hacer el resto de operaciones.

El código quedaría de la siguiente manera:

result_ejer

Como siempre, existen multitud de formas de resolver los ejercicios, tus variables (en mi caso numero1, numero2, resultado_suma, etc.) seguramente se llamen diferente pero el resto debe ser muy parecido.

2. Contenido del capítulo

En base a lo que hemos aprendido en el capítulo anterior, hoy vamos a ampliar horizontes aprendiendo lo siguiente:

  • Constantes
  • Nuevos tipos de datos
  • Arrays
  • Resolución de un ejercicio de ejemplo
  • Enunciado del ejercicio para la próxima entrada.

Como siempre, voy a dar por sentado que los conceptos del capítulo anterior están claros. Si no es así te animo a pegarle un repaso o a dejarme tus consultas en los comentarios.

3. Constantes

En el capítulo anterior y en la resolución del ejercicio hemos hecho uso de variables, recuerda que una variable es como una caja de zapatos: un día puede contener bambas, al día siguiente zapatillas y dentro de un mes quizás libros viejos o herramientas. Es un recipiente donde poner cosas, en los casos que nosotros hemos visto números enteros, pero números que pueden ir cambiando.

Siguiendo el ejemplo del ejercicio anterior, si el enunciado no nos hubieran exigido usar variables nuevas las podríamos haber aprovechado, por ejemplo así:

reapro

Como puedes ver, en lugar de declarar nuevas variables para guardar el resultado he reaprovechado la que ya teníamos, si debugas el programa paso a paso verás como el valor de “resultado” va cambiando.

Si te fijas bien, verás que hemos usado variables para numero1 y numero2, y si te fijas mejor verás que esos números nunca cambian, nos son variables sino que son constantes.

Podemos definirlos como constantes de la siguiente forma:

constantes

Ahora numero1 y numero2 son constantes y su valor no se puede modificar durante la ejecución.

Nuestro programa es tan pequeño que apenas se nota pero hemos mejorado su eficiencia, al reaprovechar variables es como si en lugar de comprar una nevera nueva cada vez que se llena, la vaciáramos para llenarla con otras cosas. Con las constantes se mejora la velocidad de acceso a datos, es como si te aprendes de memoria tu DNI en lugar de sacarlo de la cartera y consultarlo cada vez que te lo piden.

Como he dicho todos estos cambios apenas se notan en un pequeño programa pero si éste crece cada día hasta transformarse en una gran aplicación habrás agradecido tener estas cosas en mente desde el principio.

¡Ah! Un último detalle, ¿te has fijado en la línea verde debajo de resultado? Se parece a la línea roja que vimos en el capítulo anterior y se llama “warning”. A diferencia de los errores, los warnings son sólo avisos y, en éste caso, nos está diciendo esto:

warning

Básicamente nos está diciendo: “Has creado resultado, le estás poniendo valores, pero nadie los usa por lo que te la puedes ahorrar”. Pero VS no sabe que las estamos usando para consultar el valor de las operaciones mientras debugamos.

4. Otros tipos de datos

Bueno, llegados a este punto hemos aprendido a declarar variables y constante de tipo entero y a realizar diferentes operaciones matemáticas. Ahora me gustaría enseñarte otros tipos diferentes.

4.1. float

El float es el tipo de dato que representa un número decimal, al igual que los int se les pueden realizar operaciones matemáticas como sumar, restar, etc.

floats

En este código hemos definido dos constantes de tipo float y las hemos sumado poniendo el resultado en una variable float. Si te fijas hay una “f” al final del número decimal que da valor a las constantes, es necesario para indicarle a VS que es un valor float válido.

4.2. string

El string es el tipo de dato que representa una cadena de texto.

stringsAquí hemos repetido el ejemplo del float pero usando strings.

Si te fijas el valor del string va siempre entre comillas, y si, los strings se pueden sumar aunque lo que realmente se hace es concatenarlos, por lo que en nuestro caso resultado valdría “holaadios”. Como el string no es un valor numérico no se los puede restar ni multiplicar ni dividir.

Ahora me gustaría que probaras de primera mano lo que te he enseñado en éste apartado, vamos a picar un poco de código hasta obtener lo siguiente:

ejemplo simple

Bueno, en el capítulo anterior vimos como se podía debugar para comprobar el valor de las variables, pero quiero enseñarte un pequeño truco: podemos hacer que aparezca un mensaje en pantalla con los valores que queremos ver. Vamos a hacer un par de cambios:

ejemplo mshbox

Hemos añadido un par de líneas donde hacemos uso de MessageBox.Show, MessageBox es el objeto y Show el método. Más adelante explicaremos que es un objeto y que es un método, por ahora me conformo con que os suenen esas palabrejas.

MessageBox.Show acepta un string, que es lo que le ponemos entre paréntesis. Si te fijas con resultado_string no hay problema, porque es un string, pero con resultado_float hay que hacer una cosa llamada .ToString(). Más adelante lo explicaré, no te preocupes.

Vamos a darle al play, recuerda que es el botón verde donde pone Iniciar.

msgbox_float  msgbox_string

Y ahí lo tienes, te aparece un mensaje (un MessageBox) con un número 2, que es el contenido de resultado_float (0.5 + 1.5). Si pulsas aceptar te sale el siguiente mensaje, que no es más que el contenido de resultado_string.

5. Arrays

Bueno, llegados a éste punto ya has visto cómo se declaran variables y constantes de distintos tipos (ints, strings y floats) y como se puede operar con ellos. Vamos a darle una vuelta de tuerca y nos vamos a introducir en el mundo de los arrays.

Un array no es más que un grupo de variables del mismo tipo, nosotros hemos estado usadando cajones (las variables) y un array es como un armario que tiene cajones dentro. Te voy a poner un ejemplo sencillo para que veas como funciona:

Te viene una señora y te pide que le calcules cuanto dinero tiene en la cartera si:
Empieza con 2 monedas de 2 euros, 3 de un euro, 15 monedas de 5 céntimos y una de dos céntimos.
Después paga con una moneda de 2 euros, una de uno y una de 5 céntimos.
Y le dan de cambio una de un céntimo.

Como nosotros somos gente muy apañada vamos a ordenar todo este lío de números:

tabla 1

Si pagamos con esto nos queda:

tabla 2

Y al darle el cambio nos queda:

tabla 3

Ahora sumamos el dinero y nos da que tenemos 4.73€. ¿Fácil no?

¡Pues a programar se ha dicho! Abramos Visual Studio y busquemos una manera de realizar éste cálculo con nuestro querido C#.

Una posible solución sería la siguiente:


array 1

Como puedes ver es una solución muy tonta, hay tantas variables como tipos de moneda, se realizan las operaciones, se calcula el total y se muestra el resultado.

Seguro que te has fijado en que hay una línea partida, lo he hecho a posta para que ocupara menos en pantalla. Si una línea te parece demasiado larga la puedes partir con un intro que no pasa nada… ¿mola eh?

Pues existe una forma igual de válida pero más elegante de hacer y es mediante arrays, como hemos dicho un array es una colección de elementos y nos viene perfecto porque todas las variables que hemos usado (menos el resultado) son de tipo entero.

El array de enteros se declara así:arrayç

Se parece mucho a declarar una variable normal, ¿verdad?

Lo primero como siempre es el tipo, en éste caso int, y va seguido de corchetes para decirle a C# que es un array. Luego como siempre viene el nombre (en éste caso monedero) y por último viene una cosa un poco especial: le estamos diciendo a C# que nuestro array tiene 8 posiciones.

Lo que acabamos de hacer es decirle al ordenador que queremos una tabla como la que hemos visto arriba con 8 posiciones vacías y que se llama monedero.

tabla 4

Aquí hay una cosa curiosa a tener en mente, y es que en C# la primera posición de nuestro array es la número cero, y la última la número siete.

Si nos imaginamos que las posiciones corresponden a la tabla que habíamos usado en el ejemplo nos quedaría una cosa así:

array 2

Poner valores en el array es muy parecido a ponerlos en una variable y que ya hemos visto tantas veces. Para hacerlo con un array hay que poner el nombre de la variable, la posición a la que queremos acceder entre corchetes y el valor a asignar.

En la primera línea estamos diciendo: “a monedero, en la posición cero, le pones un dos”.

En la segunda línea estamos diciendo: “a monedero, en la posición uno, le pones un tres”.

En cada una de las líneas estamos accediendo a una posición del array y poniéndole un valor, desde la primera (la cero) hasta la última (la siete) lo cual en nuestro dibujo equivaldría a tener esto:

tabla 5

Aunque parezca una tontería te recomiendo que siempre que tengas que pensar en una solución tengas papel y boli al lado. Ojo que no he dicho siquiera programar, los dibujos, esquemas y anotaciones es recomendables hacerlos siempre antes para tener bien claro cómo se va a ir desarrollando el código. Si te fijas, lo que estoy programando es exactamente y paso por paso lo que he explicado antes de programar nada cuando he estado dibujando las tablas con los euros.

Bien, ya tenemos nuestro array montado y solo queda calcular el resultado:

array 3

La lectura es un poco más confusa pero el resultado es el mismo, lo he partido en varias líneas para que se viera mejor en éste blog pero lo puedes poner en una si te resulta más cómodo.

Vale, tenemos la nueva versión casi acabada así que vamos a hacer un poco de limpieza.

Cuando se declara una variable de tipo entero, su valor inicial siempre es cero. En el caso de los arrays de int pasa lo mismo, las posiciones iniciales siempre valen cero por lo que podemos limpiar unas cuantas líneas:

array 4

¿Fácil verdad? Pues se puede dejar un poco más bonito todavía… aunque supongo que esto va por gustos:

array 5

Como puedes ver he declarado el array de una forma diferente y un poco más clara.

Consiste en no decir el número de posiciones y acto segudio poner entre llaves el listado de valores iniciales de todas las posiciones. De esta forma se tiene una visión mucho más clara del valor inicial de nuestro array aunque, como he dicho, es una cuestión de gustos y quizás a ti te mola más hacerlo de otra forma.

Bien, para acabar del todo nos queda hacer las operaciones del enunciado, es prácticamente igual que el ejemplo sin array pero accediendo a las posiciones con lo que el resultado final queda así:

array 6

6. Resmuen.

La verdad es que tenía pensado explicar más cosas en éste capítulo pero me da miedo que sea demasiada información de golpe y me interesa más que vayamos poco a poco y dejando bien claras las cosas.

Recapitulando hemos visto variables de distintos tipos que se declaran así:

tipos

Siempre de la misma forma: tipo -> nombre -> valor inicial -> punto y coma.

Recordemos también que, si sabemos que una variable no va a cambiar nunca de valor entonces no es una variable sino una constante:

tipos const

Basta con poner const delante para que no tengamos una variable sino una constante, esto siempre es bueno hacerlo para ayudar a nuestro programa a ir más rápido.

También hemos visto como realizar operaciones matemáticas simpes (suma, resta, multiplicación y división) con los tipos int y float así como concatenar strings sumándolos.

Y para terminar hemos visto como se crear arrays y como se accede a sus posiciones:

tipo array

7. Ejercicio

Una persona te dice que tiene un huerto con cinco parcelas, en la primera cultiva lechugas, en la segunda cultiva zanahorias, en la tercera planta cebollas, la cuarta la tiene vacía y en la quinta tiene puerros.

Un día viene una chica a comprarle unas hortalizas, y en la lista de la compra tiene apuntado comprar 3 zanahorias, 1 cebolla y 2 lechugas.

Escribe el código necesario para calcular el número de hortalizas totales (un número entero) que le quedarán al payés una vez haya realizado la venta. Utiliza como mínimo un array.

Pista:
Puedes montar una solución parecida a la que se ha usado de ejemplo en éste capítulo usando arrays.

Como siempre la respuesta en el próximo post.
Saludos y gracias por llegar hasta aquí.

¡Hasta la próxima!

2 – Introducción a la programación

1. Contenido del capítulo

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Si has leído el capítulo anterior ya debes tener instalado y correctamente configurado tu Visual Studio así que en éste capítulo vamos a hacer lo siguiente:

  1. Pequeña y breve introducción a los elementos fundamentales de VS.
  2. Creación de un nuevo proyecto Windows Forms.
  3. Diseñador de formularios y herramientas.
  4. Vista de código.
  5. Compilación en modo debug.
  6. Introducción a los tipos de datos.
  7. Declaración de variables.
  8. Operaciones básicas con variables.
  9. Depuración punto por punto.
  10. Ser elegante no cuesta nada.
  11. Presentación del primer problema del curso.

Antes de continuar voy a dar por sentado que los conceptos del capítulo anterior están claros (de hecho será así en cada capítulo) por lo que me voy a ahorrar los enlaces a la Wikipedia de la terminología que ya se ha visto anteriormente (irlos poniendo es un coñazo) pero si tienes dudas puedes dejar un comentario o consultar el capítulo anterior, lo que te sea más cómodo 🙂

2. Introducción a Visual Studio

Visual Studio es la herramienta con la que vamos a programar, probar y generar nuestros programas. Es una herramienta muy potente y tiene millones de opciones de las cuales no tengo ni puta idea de la mitad, pero si de las que nos van a hacer falta para el curso así que iré al grano.

Tan pronto como hayas abierto VS verás algo similar a esto:

inicio

Propaganda, anuncios y mierdas varias a las que nunca he prestado atención. Lo que vamos a hacer es crear nuestro primer proyecto, para ello vamos a Archivo/Nuevo proyecto.

3. Creación de un proyecto

Como vamos a usar C#, nos vamos a su opción correspondiente y seleccionamos Aplicación de Windows Forms. Ahora hay que ponerle un nombre a la aplicación y escoger (si no te gusta la que viene por defecto) una ubicación. En la imagen tienes un ejemplo:

proyecto nuevo

Si te fijas, verás que puedes escoger la versión del .NET Framework que por defecto viene marcada la 4.5.1. Si por algún motivo estás usando una versión anterior de Visual Studio (por ejemplo la 2010) no podrás ir más allá del Framework 4.0 pero no te preocupes, para el contenido de éste curso no debería haber ningún problema en trabajar con un Framework más antiguo.

Acepta y crearás tu proyecto viendo algo parecido a esto:

proyecto

4. Diseñador de formularios y herramientas

formSobretodo no te asustes y no entres en pánico, son muchas cosas nuevas pero son muy sencillas de usar cuando le pillas el truco.

Lo que tienes en el centro es el formulario, que viene a ser como se ve tu aplicación. No puedes moverla, minimizarla ni cerrarla así que no lo intentes… vale, seguro que lo has intentado pero no va, no es más que una imagen. Lo que sí puedes hacer es jugar con su tamaño arrastrando los cuadritos blancos que la rodean.

explorador y propsSi te fijas en el lado izquierdo, verás que si haces clic donde pone Cuadro de herramientas se despliega una pestaña con muchas opciones, desplegando la primera opción puedes ver todos los componentes que Visual Studio nos permite insertar en nuestro formulario. Todos estos componentes son nativos del .NET Framework 4.5 (lo cual quiere decir que cualquier persona que lo tenga instalado debería ser capaz de hacer funcionar nuestro programa), muchos de ellos no los vamos a usar y algunos otros nos hartaremos de verlos, pero lo dejaremos para más adelante.

Ahora quiero que te fijes en el panel de la derecha, en la parte de arriba tienes el Explorador de soluciones que te permite ver todos los elementos que contiene tu programa, algunos de esos elementos son archivos que se han creado en tu disco duro al generar el proyecto, otros son solamente configuraciones del proyecto… como antes ya lo veremos sobre la marcha porque sino esto puede ser un puto lío que te cagas, ahora solamente nos interesa que nos suenen las cosas y que sepamos que están ahi y que hacen “cosas”.

Justo debajo tienes el panel de propiedades, donde se definen las propiedades de los distintos elementos que componen el formulario (éste incluido). Ahí se puede cambiar el color de fondo, el nombre, etc.

5. Vista de código

Bien, lo que hemos visto es la parte visual del proyecto, lo que sirve, entre otras cosas, para tocar lo que se llama Interfaz Gráfica de la aplicación. Pero la parte que más nos interesa es otra, donde de verdad está la chicha: EL CÓDIGO FUENTE.

Bien, para acceder a tan oscuro y hermoso lugar hacemos clic con el botón derecho del ratón sobre el formulario en el explorador de soluciones (Form1.cs) y seleccionamos ver código como se puede ver en la imagen.

opcion codigo

Deberías ver algo parecido a esto:

codigo

Seguramente tu veas todo el texto un poco más pequeño, yo tengo el zoom aumentado para no quedarme ciego (que ya lo estoy bastante) pero por si te interesa puedes cambiarlo dejando apretada la tecla Ctrl + Rueda del ratón.

Bien, lo que estamos viendo es el Mátrix de nuestro formulario, lo que realmente trabaja, lo que si no está aquí no funciona. Recuerda que independientemente de los asistentes, las ventanas de configuración que hemos visto antes, el código va a misa. El código siempre manda y nunca miente.

6. Compilación en modo Debug

Y esto del debug… ¿que es?

Pues para que nos entendamos es ejecutar un programa y poder ver que es lo que está haciendo, en teoría deberíamos saber que es lo que hace antes de ejecutarlo porque lo hemos programado nosotros pero a veces se nos escapan cosas, se producen errores y es la mejor manera de averiguar qué está pasando, lo que llamamos debugar.

playPara que veas un ejemplo, vamos a darle al botón de play verde que se ve por arriba.

formEsto nos va a compilar la aplicación en modo debug y nos la va a ejecutar para que la podamos probar. Deberías ver el formulario vacío que hemos visto antes pero ahora si que lo puedes mover, minimizar y cerrar pues ya no es una simple imagen sino toda una aplicación… ¡Tu primera aplicación!

Verás que el botón de play verde se ha transformado en un stop rojo, si lo pulsas se para la ejecución y volvemos a como estábamos antes. Esto también ocurre si cierras la ventana del Form1.

7. Introducción a los tipos de datos

Bueno, la cosa ya se va poniendo interesante ¿verdad?. Ya hemos visto como crear un proyecto, algunos elementos de VS y hemos ejecutado nuestra primera aplicación. Ahora es el momento de empezar a escribir nuestras primeras líneas de código.

Vamos a hacer algo tan tonto como una suma… ¿Pero que podemos sumar?

Tienes que imaginar la programación como un gran puzzle donde las piezas las creas tú, por ejemplo, viene un señor (en éste caso yo) y te dice “Oye tú, súmame dos números y dime el resultado”. Aquí el objetivo está claro, darle a éste señor el resultado de una suma, sabemos cómo juntar las piezas del puzzle pero no tenemos las piezas así que nos las vamos a inventar.

Vamos a crear dos variables, una variable es un elemento que puede ir cambiando de valor durante la ejecución del código.

Las variables se componen de un tipo y un nombre, cómo el señor nos ha pedido que sumemos dos números vamos a crear dos variables de tipo entero y, en un arrebato de originalidad, las vamos a llamar numero1 y numero2. El código quedaría como vemos a continuación:

codigo1Al escribir int le hemos dicho a C# que vamos a crear una variable de tipo entero, y a continuación hemos puesto su nombre para rematar con un punto y coma que significa que ya hemos acabado.

Vale, el siguiente paso es darle valor a esos números, para eso usaremos lo que se conoce como asignación. En el código lo vais a ver super claro:

codigo2

Vale, tenemos nuestras piezas, dos números que valen 5 y 3, nos queda sumarlos como nos han pedido. ¿Que cómo se suma? Pues sumando :p

8. Operaciones básicas con variables

codio suma

¡Wow! Espera… ¿que es esa marca roja? Pues resulta que Visual Studio nos está diciendo que hay un error en nuestro código, si dejas el ratón sobre la línea errónea podrás leer el mensaje de error… aunque no siempre se entiende lo que quiere decir…

error1

Éste error, en castellano estándar, significa “Eh tio/a, estás sumando dos cosas y no me estás diciendo dónde quieres que ponga el resultado.” Ojalá Visual Studio nos dijera así las cosas, sería todo mucho más fácil.

Bien, la solución es muy sencilla, vamos a crear una nueva variable para poner el resultado de nuestra suma y vamos a poner el resultado ahí. Quedaría así:

codio suma ok

Bien, repasemos:

Tenemos tres variables, a una le ponemos un 5, a la otra un 3 y a la última le ponemos la suma de las otras dos… vamos a darle al play a ver que pasa.

¿No pasa nada verdad? Pues sí y no, el código se está ejecutando pero no lo estamos enviando hacia la interficie gráfica que es la ventana que vemos cuando le damos al play.

9. Depuración punto por punto

Vamos a debugar para demostrar lo que digo, si hacéis clic en la barrita gris a la izquierda del número de línea 19 se marcará con un punto rojo como en la imagen:

breakpoint zero

El punto rojo se conoce como Breakpoint o punto de interrupción, de ésta manera le estamos diciendo al programa que cuando le demos al play se pare ahí. Vamos a darle al play y veremos lo siguiente:

breakpoint

Si dejas el ratón puesto sobre numero1 verás que te dice que su valor es 0, esto es así porque cuando se crea una variable de tipo int su valor por defecto es siempre 0.

Ahora pulsa la tecla F10, esto hace que el programa avance un paso.

debug2

Pon el ratón sobre numero1 y verás como ahora vale 5, si haces lo mismo sobre numero2 verás que vale 0. Ahora pulsa F10 dos veces para que nos coloquemos en el punto de ejecución donde se ha realizado al suma.

debug3

Repite el proceso y verás como numero1 vale 5, numero2 vale 3 y… ¡¡¡resultado vale 8!!.

Felicidades, has picado tu primer programa 🙂

10. Ser elegante no cuesta nada

Una cosa muy cierta es que un código limpio, bonito y bien estructurado no solo hace menos daño a la vista sino que nos va a ahorrar un montón de tiempo a la hora de buscar errores, ampliar el código, etc.

Nuestro primer programa tiene solamente (si contamos lo que nosotros hemos escrito) 8 líneas contando los espacios en blanco. Pues bien, podemos dejarlo un poco más elegante si establecemos los valores cuando creamos las variables, ya veréis como todo queda más claro:

codigo_limpio

Como puedes ver la lectura ahora es clara: numero1 vale 5, numero 2 vale 3, resultado es la suma de los dos anteriores.

11. Presentación del primer problema del curso

Bueno, hemos llegado al final de éste capítulo y es el momento de presentar un problema.

He pensado que puede ser más divertido si presento el problema y no lo resuelvo hasta que publique el próximo capítulo, así te doy la oportunidad de resolverlo por ti mismo que es la mejor forma de aprender.

Creo sinceramente que si te doy la solución directamente vas a tener la tentación de mirarla y “picando piedra” es como se aprenden los truquitos y se superan los problemas que te puedas encontrar… aún así recuerda que tienes lo comentarios para hacerme cualquier pregunta que te surja.

Por último te recomiendo que te hagas muy amigo de los buscadores como Google, Yahoo! o Bing, te solucionarán muchas de tus dudas de forma rápida y cómoda y además aprenderás un montón de trucos de gente que, seguramente, sabe mucho más que yo.

Enunciado
El mismo señor que te había pedido que sumaras dos número cualesquiera te pide ahora que le hagas lo mismo con una resta, una multiplicación y una división y guardes los resultados en cuatro variables diferentes.

Pistas
Puedes aprovechar el proyecto que se ha creado en éste capítulo.
Puedes crear tantas variables como quieras para los operandos y los resultados.
Los operadores que necesitas són:

  • Suma, símbolo más (+).
  • Resta, símbolo guión (-).
  • Multiplicación, símbolo asterisco (*).
  • División, símbolo barra (/).