Mostrando entradas con la etiqueta Curso C#. Mostrar todas las entradas
Mostrando entradas con la etiqueta Curso C#. Mostrar todas las entradas

jueves, 12 de noviembre de 2015

Estructura de Repetición For


Buenas noches, volviendo con el curso de C# vamos a exponer rapidamente que es una estructura de repetición FOR.

En programación un ciclo for, se define como una ciclo repita para, esta estructura de repetición en la mayoría de los lenguajes de programación define define una variable de control en su definición que indica de que manera se va a llevar  a cabo la repetición de los procesos indicados. La idea fundamental de las estructuras de repetición, es repetir una operación tanta cantidad de veces o hasta que se cumpla determinada condición.

Veamos el ejemplo. En C#


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

            System.Console.WriteLine("Esta aplicación cuenta hasta 100");

            for (int i = 0; i <= 100; i++) {

                System.Console.WriteLine(i);

            }
            System.Console.WriteLine("Ya terminó de contar");
            System.Console.ReadKey();
        }
    }
}
Observen, que básicamente la idea del ejemplo es repetir la impresión del conteo en cada vuelta. Esta estructura básica de programación permite más adelante hacer algo que comúnmente llamamos una multiplicación, es decir una suma repetida.
Veamos el siguiente ejemplo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EstructuraFor
{
    class Program
    {
        static void Main(string[] args)
        {
            String multiplicando = "";
            String multiplicador = "";
            System.Console.WriteLine("Por favor ingrese el multiplicando");
            multiplicando = System.Console.ReadLine();

            System.Console.WriteLine("Por favor ingrese el multiplicador");
            multiplicador= System.Console.ReadLine();

            double a = System.Convert.ToDouble(multiplicando);
            double b = System.Convert.ToDouble(multiplicador);


            double result = 0;
            for (double i = 0 ; i < b; i++) {

                result = result + a;

            }
            System.Console.WriteLine("La multiplicación es {0}", result);
            System.Console.ReadKey();
        }
    }
}

Ahora, en sus casas pueden practicar realizando una estructura de repetición que realice la potencia.

¿Como sería?

sábado, 28 de marzo de 2015

Estructuras de control de flujo (decisión)

Estructuras de control de flujo

Buenos días, hoy vamos a hablar de las estructuras de control de flujo, en esta primera parte de las estructuras de decisión. Estas estructuras son las que permiten escribir programas complejos dado que solo con variables y sentencias de captura las aplicaciones serían una sucesión lineal de instrucciones sin mucha utilidad.
Las estructuras de control se dividen en dos grupos: Estructuras condicionales, y estructuras de repetición . Cada una con sus propias especificaciones que ayudan a dar sentido a nuestros programas.

Estructuras de decisión.
Son las estructuras de control de flujo que permiten elegir comportamientos distintos para nuestros programas según las condiciones establecidas usando los operadores de comparación que vimos en la sesión anterior.

     Estructura de decisión if.


Las estructuras de decisión if permiten definir el flujo de nuestras aplicaciones. Si no definiéramos condiciones según a eventos a realizar por el usuario o decisiones que debe tomar el programa según el valor de algunas variables, nuestros programas serían solo instrucciones lineales una tras otra sin demasiado sentido. 

En el ejemplo anterior se le solicita al usuario que ingrese un número y de acuerdo al valor ingresado se imprime por pantalla un mensaje previo a la impresión del valor del valor del  número, a diferencia de las estructuras if else que veremos más adelante  si la condición no se cumple no hay flujo alternativo. Solo se descartan las instrucciones que no cumplen la condición.

Veamos el código fuente de este primer ejemplo. 



    Estructura if else.

La estructura if else, se encarga de cambiar de hacer el trabajo que la estructura anterior no realiza. En dado caso de que la primera condición no se cumpla se ejecutarán las instrucciones encerradas en el bloque else. 


En este caso, la condición divide el flujo en dos. Una donde es afirmativa y la otra donde es negativa. El caso else se ejecuta si solo si, el caso evaluado en la condición es falso. 

 Ahora veamos el código de este ejemplo.



Estructura If else if else.

En esta estructura aparece la diferencia de que condiciones adicionales son agregadas a la primera en dado caso que esta no se cumpla. Podemos agregar tantas condiciones adicionales como deseemos.

El flujo es que si la primera condición no se cumple se evaluara la siguiente. Hasta tanto se cumpla alguna, en dado caso de que alguna de las condiciones no se cumpla, se procede entonces a ejecutar el caso else. 


Después de las condiciones pueden existir sentencias adicionales, es decir estructuras de repetición, otras estructuras de decisión etc.

Veamos el código fuente.



Estructura switch.

La estructura switch es muy similar a las estructuras if else if else. Cada caso evaluado por el switch representaría un caso del if else if else. La ventaja sobre las condiciones normales es que el código luce más ordenado. Sin embargo no admite definir condiciones complejas como con los if. Solo condiciones donde la opción es una cadena  o número entero.

Veamos el primer ejemplo de esta.



Veamos el segundo.



Bueno, hasta aquí la entrada de hoy. 

Para aprender deben practicar. Recuerden siempre eso. 

A continuación los ejemplos del día de hoy

sábado, 28 de febrero de 2015

Variables y conversión de tipos en C#


Buen día a todos,

Hoy vamos a hablar acerca de algo muy importante a la hora de programar, las variables.  A partir de matemática de bachillerato sabemos que son valores que son desconocidos, pero en programación son el almacén principal de los datos para poder obtener la información que realiza nuestro programa. En C# las variables van atadas al tipo de dato que almacenan, entendiéndose por tipo de dato si es un número (entero corto, entero largo, decimal o complejo), una cadena de texto o un valor booleano.

A la hora de definir una variable en C# al igual que en lenguajes como C/C++ y java es especialmente necesario definir el tipo, por esta razón la sintaxis general es:

                identificador_tipo nombre_variable = valor ;

Así que empecemos con las cadenas.

Se define como un tipo cadena  o string a una secuencia de caracteres unicode, este es un tipo implícito de C#.
Se define mediante el identificador de tipo:
                string palabra = "Ensayo";
En la línea anterior, definimos una variable llamada palabra que contiene una cadena "Ensayo". ese es el valor de nuestra variable.

Veamos los número enteros.

En C# existen distintos tipos de enteros. De acuerdo a la documentación oficial son 9 y no todos necesariamente representan un número. 


Como se puede observar en la tabla anterior se pueden presentar datos astronómicamente grandes según el tipo de entero que se esté usando. Y el uso del tipo correcto tiene implicaciones en la cantidad de memoria usada por nuestro programa. Por dicha razón, si se va a mostrar la cantidad de opciones vinculadas a algo como por ejemplo las entradas del menú de un restaurante y es un número relativamente pequeño el de las respuestas a ser tomadas en cuenta debemos elegir un número byte, en cambio si nuestro objetivo es mostrar una operación matemática con un número de respuesta realmente grande (ejemplo una operación monetaria entre países) debemos usar un número entero de tipo Long. Claro, hay que tener en cuenta que si la operación tiene decimales ninguno de estos números nos va a ser realmente útil dado que perderíamos la precisión decimal.

Por otro lado el tipo char, representa un carácter Unicode de 16 bits, es decir una letra o carácter imprimible de 16 bits. Ejemplo, la letra Ñ tiene una representación de 16 bits en binario de la siguiente manera: 11000011 10010001

Algunos ejemplos de declaración de enteros:

int diez = 10;
sbyte nueve = 9;
short corto = 25340;
ushort = 32456;

Ahora, hablemos acerca de los decimales o números de punto flotante.
En C# existen dos tipos de números de punto flotante que son el float y el double, cada uno tiene un rango mínimo y máximo de alcance al igual que con los enteros  


Como podrás observar son números bastante pequeños o extremadamente grandes con la precisión decimal correspondiente, por esta razón son muy útiles a la hora de representar valores numéricos donde los decimales no pueden ser despreciados, como por ejemplo operaciones monetarias, de esta manera se resuelve el problema de las operaciones monetarias entre países, de la sección anterior.

Convertir una cadena a un número

Vale la pena resaltar que a la hora de leer un número los métodos proporcionados por C# toman la entrada como una cadena de texto(o tipo string), por tanto para posteriormente realizar las operaciones matemáticas que deseemos debemos proceder a realizar un conversión de tipos. Por defecto, C# lee  todo lo que entra por teclado como una cadena entonces es trabajo del programador realizar estas conversiones, para esto se usan las funciones que son parte de la librería System



System.Convert.ToDecimal(var);
System.Convert.ToInt16(var);
System.Convert.ToInt32(var);
System.Convert.ToInt64(var);



Y otras que puedes ver usando la característica intellisense de tu editor de Visual Studio. En nuestro programa de ejemplo, leeremos por teclado el nombre del usuario luego le pediremos que ingrese dos valores y ejecutaremos conversión de tipos para sumarlos. Y finalmente los mostraremos por teclado.  Repitamos el paso de la entrada anterior y generemos un nuevo proyecto de Consola. 

Menú archivo -> nuevo proyecto -> aplicación Windows -> aplicación de consola

Establecemos el nombre de la solución y el proyecto a Variables y luego en la sección de program.cs del explorador de soluciones agregamos el siguiente código. 


Para finalizar ejecutamos nuestro proyecto en la barra de menús presionando el botón iniciar, y veremos la siguiente salida. 



Recuerda, si te gusto la entrada y su contenido puedes invitarme a un café.

Para descargar las fuentes puedes hacerlo aquí

Hola Mundo en C#


Buenos días como dije anoche, voy a retomar el curso de C# para todo aquel que quiera aprender y como este es uno de los lenguajes más populares del mundo lo voy a hacer seriamente. Así que voy a publicar cada programa con la documentación asociada para que cualquiera lo entienda de principio a fin. Bueno, sin más preámbulo vamos a nuestro primer programa en C#.

Para comenzar tenemos que hablar acerca de cómo funcionan los proyectos. Para eso nos vamos al editor de Visual Studio y seleccionamos en el menú archivo nuevo proyecto, a continuación se abrirá la siguiente ventana:


Allí en la sección nombre le colocaremos el nombre de nuestra aplicación y el nombre de la solución, se entiende por solución el nombre general del proyecto. Para nuestro ejemplo será:

Nombre: HolaMundoConsola
Nombre de la solución: HolaMundo

Una vez creado el proyecto podremos observar su estructura en el explorador de soluciones a mano izquierda de nuestro editor Visual Studio. Tal como se ven en la siguiente captura.


Veamos la estructura y como funciona:

En la parte superior vemos el nombre de la solución tal como lo establecimos. Luego el nombre de proyecto de la aplicación. La sección References , Properties, y el App.config  las veremos más adelante en el curso.
Ahora la parte que nos interesa es la sección Program.cs donde realmente está el código fuente de nuestra aplicación. Y que como veremos durante esta serie de artículos es el punto de entrada para nuestras aplicaciones. Al abrirlo, veremos el siguiente código inicial. 


En la cabecera del archivo vemos las instrucciones using, estas instrucciones le dicen al compilador las librerías que debe utilizar para compilar nuestro proyecto.
La siguiente instrucción es el namespace, esta instrucción establece el espacio de nombres donde está contenida la clase 'Program', como vemos en el código ya tenemos un método Main o principal que actuara como punto de entrada para la aplicación.

Viéndolo en UML se ve de la siguiente manera. 


Bien, ahora vamos al código.


Bien, la pregunta es ¿de donde viene el objeto Console? mediante el cual llamamos al atributo Title, al método Write() y al método ReadKey(). La respuesta es a través del using System declarado en la primera linea de nuestro programa, C# toma de manera implícita todo lo que se encuentre en ese contexto.

Para finalizar, veamos nuestro programa en ejecución. 


Bueno, que hacen las lineas escritas anteriormente. 

  • La linea Console.Title establece el nombre de la consola.
  • La linea Console.Write imprime en la consola el texto que se le pase como argumento.
  • Y por ultimo la Console.ReadKey, espera a que el usuario presione cualquier tecla para salir de la aplicación. 


Bueno para descargar el programa, puedes seguir el siguiente enlace.

Recuerda, si te gusto la entrada me puedes invitar a un café.