C# Basico desde cero - Clase 4 _ Esctructuras de control SWITCH / CASE

Hola amigos, sean bienvenidos a esta nueva clase de C# basico.
En la clase de hoy vamos a hablar de una herramienta muy util que nos va a ayudar a hacer nuestro código mas prolijo.
Habrán visto luego de la clase pasada que con la estructura IF/ELSE surge un problema: que pasa cuando empezamos a anidar if?.
Como ya habrán probado podemos anidar la cantidad de if que querríamos pero, es esto lo correcto? Definitivamente la respuesta es no. Nunca es bueno tener una cantidad de if anidados, pero que pasa cuando tenemos que evaluar por múltiples estados? Para esto nos vamos a valer de la herramienta SWITCH/CASE.

Como funciona? Fácil, esta herramienta va a recibir como parámetro la variable a ser evaluada, y por cada opción posible vamos a escribir una entrada CASE. De esta manera nuestra variable de entrada va a ser evaluada n cantidad de veces, siendo n el numero de opciones CASE que tiene nuestro SWITCH o hasta que encuentre la sentencia BREAK, la cual va a servir para informar a nuestro SWITCH que hemos encontrado el valor buscado y queremos detener la evaluación. Cabe destacar que en caso de no encontrar esta sentencia se van a evaluar todas las opciones CASE que hayamos puesto hasta llegar al final.
Otra opción importante que cuenta nuestra herramienta es la opción DEFAULT, con esta opción ( que se agrega con ultima sentencia a ser ejecutada del SWITCH ) vamos a indicar que antes de terminar la evaluación ingrese ahí, la utilidad de esta es opción es indicar cual va a ser el comportamiento por defecto en caso de que todas las demás evaluaciones hayan dado resultado negativo ( o no cuenten con una sentencia BREAK ).

using System;
namespace HelloWord
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 2;
            string print = string.Empty;

            switch (a)
            {
                case 0:
                    print = "Se encontro en la posicion 1";
                    break;
                case 1:
                    print = "Se encontro en la posicion 2";
                    break;
                case 2:
                    print = "Se encontro en la posicion 3";
                    break;
                default:
                    print = "No se encontro el numero buscado";
                    break;
            }

            Console.WriteLine("El numero: {0}, " + print, a);


            Console.ReadKey();
        }
    }
}

Como podemos ver en nuestro ejemplo la variable va a ser evaluada en cada CASE que disponemos, una vez que encuentre la opción que corresponde ( en nuestro ejemplo la ultima ) pondremos en una variable de tipo string la cadena "encontrado en la opción n" y luego lo imprimiremos por pantalla.

Como vemos el resultado de la ejecución de nuestro código da como resultado que se encontró en la tercer opción. Ahora supongamos el caso de que nuestro número sea 3, en este caso ninguna de nuestras opciones CASE dará un resultado, es ahí donde entra en juego la opción DEFAULT, la cual pondrá en la variable print que no se ha encontrado el numero buscado, y de esta manera luego lo mostrara en pantalla como podemos ver en la siguiente imagen:

Esto es todo por ahora, espero que hayan disfrutado esta nueva entrada, para la próxima nos espera un nuevo tipo de datos que nos va a introducir en un nivel mas avanzado de programación, las colecciones de datos.

C# Basico desde cero - Clase 3 _ Esctructuras de control IF / ELSE

Hola a todos, bueno hoy como había prometido vamos a continuar con nuestro curso sobre C# básico, para esto lo que vamos a aprender hoy es a darle mas vida a nuestras aplicaciones en C#, después de la clase de hoy van a ser capaces de darle la capacidad de seleccionar una porción de código u otra.

Como ya habíamos hablado anteriormente, el código de nuestras aplicaciones se ejecuta en forma secuencial, es decir una linea después de la otra, así nuestra aplicación va siguiendo una a una las instrucciones que nosotros escribimos para que ejecute, pero como sucede en la vida real muchas veces las instrucciones que nosotros queremos ejecutar están condicionadas, estas dependen de determinados valores de entrada que nos hace elegir entre un camino u otro.

De esta manera, el lenguaje C# nos ofrece un amplio abanico de estructuras de control que nos van a permitir entre otras cosas elegir entre estos posibles bloques de codigo a ejecutar.

Desde el principio secuencia IF

Para empezar en este mundo de las estructuras de control vamos a comenzar por la mas basica, la estrucutra IF, la misma cuenta con la siguiente forma:

if (condicion_de_verdad)
{
    //Codigo a ejecutar 
}

Asi podemos ver que la misma comienza con la keyword IF (se lo podria pensar en español como el equivalente a hacerse la pregunta SI..entonces, también podemos ver que luego de esta keyword siguen un bloque en donde nos vamos a detener para hacer varias aclaraciones, este es el bloque que llamaremos "condición de verdad". Luego de esto, como todo bloque de código en C# (tema ya aprendido) nuestro código a ejecutar se encuentra entre { }.

Condición de verdad

Esta es la que nos va a determinar si ejecutaremos nuestro código o no, la misma en C# tiene que contar con un formato determinado en el cual deben evaluarse siempre dos variables (mas adelante veremos que no siempre son necesarias) y del resultado de esta evaluación determinara si ejecutaremos o no nuestro código.

Operadores lógicos

Estos son los encargados de realizar la comparación entre nuestras dos variables. Como en toda comparación necesitamos definir el conjunto de operadores que vamos a utilizar para comparar nuestras variables, en C# tenemos definidos el siguiente conjunto de operadores lógicos:

== : Igual
<  : Menor
>  : Mayor
<= : Menos o Igual
>= : Mayor o Igual
&& : And condicional
|| : Or condicional

La forma básica en la que vamos a utilizar estos operadores es la siguiente:

if (variable_A == variable_B)
{
   //Codigo a ejecutar
}

Lo que estamos diciendo en este ejemplo en lenguaje coloquial es: "Si, la variable_A es IGUAL a la variable_B, entonces..." De esta manera el código a ejecutar solo sera ejecutado si y solo si las variables son iguales. De la misma manera hubiéramos podido utilizar el operador < para indicar que solo se ejecutaría nuestro código en caso de que la variable_A fuera Menor a la variable_B.

Ejemplo de comparación de variables

using System;
namespace HelloWord
{
class Program
{
 static void Main(string[] args)
 {
  int a = 1;
  int b = 1;

  if (a == b)
  {
   Console.WriteLine("El numero: {0}, es igual al numero: {1}",a,b);
  }

  if (a < b)
  {
   Console.WriteLine("El numero: {0}, es menor al numero: {1}",a,b);
  }

  Console.ReadKey();
 }
}
}

Como podemos ver en nuestro ejemplo en ambos casos comparamos la variable a con la variable b, de esta manera en el primer caso imprimimos por pantalla que los números son iguales, y en el segundo caso no imprimimos nada porque nuestro código no se ejecuta debido a que a no es menor a b. Esto lo podemos ver en la imagen a continuación:

Enriqueciendo la secuencia IF, agregamos la secuencia ELSE

Como el subtitulo lo dice lo que vamos a hacer es enriquecer el comportamiento de la secuencia de control IF, como vamos a hacer eso? muy fácilmente agregando la secuencia ELSE. Esta secuencia nos va a permitir elegir entre un bloque de código u otro.

La forma básica en la que vamos a utilizar estos operadores es la siguiente:

if (variable_A == variable_B)
{
   //Codigo a ejecutar 1
}
else
{
  //Otro codigo a ejecutar 2
}

Como podemos ver en este nuevo ejemplo lo que estamos diciendo en lenguaje coloquial es: "Si, la variable_A es igual a la variable_B entonces ejecutar el código 1, SI NO, ejecutar el código 2". Básicamente lo que hicimos fue darle la opción de que si la primer evaluación no fue satisfactoria ejecute un código alternativo. En pocas palabras le dimos a elegir entre dos opciones.

Ejemplo de sentencia ELSE

using System;
namespace HelloWord
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b = 1;

            if (a == b)
            {
                Console.WriteLine("El numero: {0}, es igual al numero: {1}",a,b);
            }

            if (a < b)
            {
                Console.WriteLine("El numero: {0}, es menor al numero: {1}",a,b);
            }
            else
            {
                Console.WriteLine("El numero: {0}, NO es menor al numero: {1}",a,b);
            }

            Console.ReadKey();
        }
    }
}

Como habrán notado en el ejemplo anterior, lo que agregamos fue la sentencia ELSE para darle la opción de que si NO es menor entonces imprima por pantalla esa información como lo podemos ver en la imagen a continuación.

Para terminar, estas dos son las sentencias de control mas basicas y a la vez las mas utilizadas debido a que nos permiten como dijimos anteriormente añadir comportamiento a nuestra aplicación. para nuestra próxima clase nos queda seguir viendo las estructuras de control que nos van a permitir optimizar estas que vimos hoy o iterar sobre conjuntos de datos por ejemplo. Como siempre espero que hayan disfrutado de la clase y cualquier comentario no duden en publicarlo acá mismo.

C# Basico desde cero - Clase 2 _ Tipos de datos y variables

Hola a todos, en esta segunda clase vamos a hablar sobre los tipos de datos y las variables. Como primer punto vamos a definir que es una variable, para que nos sirve que como esta compuesta esta variable.

Como su nombre lo dice una variable es un componente que puede cambiar de valor, esto para que nos va a servir? En principio para representar estados.

Como declaramos una variable? Bueno es muy fácil, una variable cuenta de 3 componentes básicos (los que sepan un poquito mas pensaran en 4 incluyendo el modificador de acceso, pero eso lo voy a dejar como dije antes para la clase de objetos).

Componentes:

1. Tipo de dato: representa el tipo de dato que podemos almacenar en una variable. Como C# es un lenguaje de datos fuertemente tipado TODAS las variables tienen un dato definido.
2. Nombre: el nombre de la variable es el identificador, este debe ser único dentro del ámbito donde esta definido.
3. Inicializador: define con que valor va a ser inicializada nuestra variable.

Un ejemplo de una variable podrían ser los siguientes:

int edad = 19;
string nombre = "Carlos";

Existen dos formas de utilizar los tipos de datos, la primera es utilizar los tipos de datos nativos, los que vienen incluidos en el lenguaje, algunos ejemplos de estos son:

1. int [valor numérico, nos sirve para representar números entre –2147483648 to 2147483647] 
2. long [valor numérico, nos sirve para representar números entre –9223372036854775808 y 9223372036854775807] 
3. double [valor numérico, nos sirve para representar números entre –1.79769313486232E+308 y 1.79769313486232E+308] 
4. decimal [valor numérico, nos sirve para representar números entre–79228162514264337593543950335 y 79228162514264337593543950335] 
5. char [representa un carácter] 
6. string [representa un array/cadena de caracteres] 
7. bool [valor lógico, admite solo dos valores (true/false)] 

Que tienen de especial estos tipos de datos que nos tomamos el tiempo para aprenderlos? Estos son los llamados tipos por valor, que al ser tipos de datos nativos del lenguaje, a nivel de ejecución las variables de estos tipos de datos se encuentran almacenadas en el heap, que quiere decir esto? Que estas variables son mas rápidas para accederlas, también nos dan otras ventajas pero no nos vamos a detener en esto ahora ya que lo vamos a ver mas adelante cuando analicemos objetos.

Por otro lado la otra forma de declarar los tipos de datos es con tipos definidos por los usuarios, esto es ni mas ni menos que darnos la posibilidad a nosotros de crear nuestros propios tipos de datos, y como vamos a hacer esto? con la creación de clases, pero como vengo diciendo esto lo vamos a analizar en detalle cuando veamos objetos.

Bueno entonces con lo que llevamos aprendido, como seria un ejemplo practico de esto, vamos a volver a utilizar el codigo de nuestra clase pasada, pero en lugar de imprimir un "string" fijo, vamos a imprimir por pantalla los valores de varias variables para ver como se muestran.

Ejemplo de impresion de variables por pantalla:

using System;
namespace HelloWord
{
    class Program
    {
        static void Main(string[] args)
        {
            int edad = 9;
            string nombre = "Carlos";
            string apellido = "Perez";
            char inicial = 'C';

            Console.WriteLine("La edad es: {0}", edad);
            Console.WriteLine("El nombre es: {0} y el apellido es: {1}", nombre,apellido);
            Console.WriteLine("La inicial es: {0}", inicial);

            Console.ReadKey();
        }
    }
}

Como podemos ver en nuestro ejemplo, declaramos tres variables distintas y lo único que vamos a hacer con estas es mostrarlas por pantalla, para esto utilizamos como ya habíamos visto en la clase anterior el método WriteLine de la clase Console, esta vez utilizamos una variante muy útil que nos permite mediante etiquetas del tipo { } indiquemos que variable debe imprimirse en ese lugar.

En la imagen a continuación van a ver como es la salida por pantalla de nuestra aplicación

Hasta acá hemos llegado con la clase de hoy, sumado a lo visto anteriormente ya hemos adquirido los suficientes conocimientos para hacer aplicaciones muy sencillas que nos permitan mostrar datos por pantalla. En nuestra próxima clase nos vamos a introducir en el mundo de las secuencias de control para darle mas vida a nuestras aplicaciones.

C# Basico desde cero - Clase 1 _ Primer aplicación de consola

Me encuentro en la ardua tarea de a alguien que no sabe nada de programación enseñarle a programar. Para comenzar se me ocurrieron (y estuve pensando mucho al respecto) que seria una buena idea enseñarle directamente con C#.
Si parece raro no?, cuando uno piensa en aprender a programar se remonta automáticamente a los conceptos que nos enseñaron en la facultad, comenzar con pseudo-código, pascal, c, c++  y luego si tiene suerte pasar por algún lenguaje mas amigable como ser C# o Java.

La cosa es que hablando con un amigo (Fernando) y comentándole al respecto llegamos a la conclusión de que seria una buena idea hacer la prueba de iniciar nuevos programadores en lenguajes como C#. Debido a esto es que me decidí a enseñarle a esta persona que les comentaba antes (mi hermano) a programa directamente en C#, haciendo que sea este lenguaje su primer contacto con el mundo de la programación.

Con este objetivo por delante me motivo a escribir estas "clases" en mi blog y de paso revivirlo. Para esto hoy voy a hablar sobre la clase mas básica que puede recibir alguien que esta comenzando con C# y es a escribir nuestro primer "Hola Mundo" en C#. Si ya se que de esto hay mucho dando vueltas por internet y que tal vez no aporte mucho esta entrada al mundo de la ciencia, pero la idea de este primer acercamiento es dar por sentada las bases para alguien que no sabe absolutamente de programación.

Empezar desde cero

Para comenzar lo que voy a hacer es crear una aplicación de consola que el único propósito que va a tener es imprimir por pantalla la frase "Hola mundo!". Notaran que remarque la palabra propósito porque es una palabra que mas adelante nos va a servir mucho cuando veamos y entendamos el mundo de la programación orientada a objetos.
Volviendo a nuestro ejemplo, vamos a analizarlo desde el punto de vista de la sintaxis de la aplicación para entender como esta compuesta una aplicación de consola, cuales son los puntos básicos y que tener en cuenta

Código Fuente de nuestro primer programa

using System;

namespace HelloWord
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hola mundo!");

            Console.ReadKey();
        }
    }
}

Ahora vamos a analizar el código escrito arriba para poder definir los conceptos básicos de programación que se encuentran ahí.
En primer lugar tenemos la palabra reservada (keyword) using, esta y como la estamos usando en este ejemplo nos sirve para "importar" el contenido del namespace System. Que dijimos con todo esto? Que todo el código que se encuentra en el namespace System va a estar incluido en nuestra aplicación, es decir, nosotros nos vamos a poder valer todos las clases que allí se encuentran.
Hablando de clases nos encontramos con la otra keyword class, esta keyword nos dice que Program es una clase, por ahora no nos interesa mucho saber que es una clase o como se comportan las clases así que de momento vamos a dejar este concepto ahí.

Como verán otras de las cosas que utilizamos en nuestro programa son las llaves { }, esto nos va a marcar el comienzo y el fin de las sentencias que estamos escribiendo. Siempre que comenzamos un bloque de código este debe empezar con un { y terminar con un }, de esta manera definimos y damos un ámbito al codigo que estamos escribiendo.

Ahora bien, vamos a nuestro programa en si, toda aplicación debe tener un punto de acceso, un lugar donde el sistema operativo univocamente sepa por donde comenzar a ejecutar el código que nosotros escribimos, para esto C# utiliza un método en particular el cual se llama Main, de esta manera el sistema operativo sabe que la ejecución de este programa debe comenzarla por este método.

Estructura básica de un método:

tipo_retorno Nombre ([tipo_parametro parametro])
{
    cuerpo_del_método;
    return;
}

De acá podemos ver la estructura básica de un método, como verán el mismo cuenta con los siguientes componentes:

tipo_retorno: se especifica el tipo de dato que va a retornar nuestro método, en nuestro primer ejemplo decimos que nuestro método retornara el tipo especial void, que significa que no retornara nada.
Nombre: el nombre de un método junto con los parámetros son el identificador único del método, digo único porque por obvios motivos no pueden haber dos métodos con el mismo nombre y mismos parámetros (veremos cuando aprendamos objetos que es posible tener mas de un método con el mismo nombre) Como norma se utiliza el nombre del método para definir la acción que va a realizar.
cuerpo_del_método: acá se definen en orden secuencial las acciones que queremos que realice nuestro método para poder cumplir con su propósito. Como  verán algo muy importante es que todas las sentencias de código que pongamos deben finalizar un un ';' esto le indica al compilador donde termina cada sentencia.
return: esta keyword no indica la variable a devolver por nuestro método, en nuestro primer ejemplo no es necesario agregarlo ya que aclaramos que no va devolver valor alguno porque especificamos el tipo_retorno como void.


Ahora si volviendo a nuestro primer ejemplo, nuestro propósito era escribir en pantalla la frase "Hola mundo!" con lo cual nos vamos a valer del objeto Console para mediante el método WriteLine pasarle como parámetro nuestra frase. Luego usamos otro método del objeto Console, el ReadKey para que nuestro programa no termine y se quede esperando que el usuario presione una tecla.

Hasta acá vamos a llegar con nuestra primera clase, en la próxima empezaremos a hablar acerca de las variables y los tipos de datos.
Espero que lo hayan disfrutado tanto como yo disfrute escribirlo, seria una buena idea para practicar hacer aplicaciones que solo impriman mensajes de este tipo por pantalla. Si tienen alguna pregunta no duden en dejar sus comentarios.