Antes de seguir adelante con el curso, permitidme un pequeño inciso para dirigirme a aquellos de vosotros que os estéis iniciando en el mundo de la programación a través de este curso. Comprendo vuestra desazón: hasta ahora llevamos cuatro entregas y, prácticamente, no hemos visto nada más que teoría. No entendéis casi nada de los ejemplos que os habéis bajado y, por si fuera poco, lo más probable es que ahora mismo no os acordéis de cómo se hacían el 70 o el 80 por ciento de las cosas que hemos visto. Puede, incluso, que alguno de vosotros se esté empezando a plantear si seguir adelante o dejarlo por imposible. Pues bien, si os sirve de consuelo, yo también sufrí todo esto cuando empecé hace ya unos quince años y, sin embargo, aquí me tenéis. En realidad no es tan complicado como pueda pareceros ahora. No importa que no recordéis, por ejemplo, cómo se llamaban los tipos de datos, o qué rango de datos podían almacenar, o cuál era el operador de complemento binario, por ejemplo. Esto es lo de menos. Lo importante es que sepas qué cosas existen, qué posibilidades tienes y dónde buscarlas. Puedes creerme: casi nadie se sabe un lenguaje de programación entero de memoria, de principio a fin (yo me incluyo, por supuesto). Esto es casi imposible. Sin embargo, sí sabemos cuáles son las posibilidades, de modo que, cuando no recordamos cómo se hacía tal o cual cosa, nos basta con consultar la documentación para recordarlo.

 

Además, a partir de ahora vamos a empezar ya a ilustrar la teoría con pequeños programas, cosa que, podéis creerme, resulta mucho más gratificante. No lo habíamos hecho hasta ahora porque, como vais a comprobar, nos faltaban los cimientos: espacios de nombres, variables, constantes, tipos, operadores... Ahora ya los conocemos, o al menos nos suenan, y como el camino se hace andando, pues es lo que vamos a hacer: andar.

 

NUESTRA PRIMERA APLICACIÓN EN C#

 

Vamos a empezar con una sencilla aplicación para que te vayas familiarizando tanto con el entorno de desarrollo de Visual Studio .NET como con la clase System.Console que tanto has visto hasta ahora (y vas a seguir viéndola hasta que empecemos a desarrollar aplicaciones para Windows). Se trata, cómo no, de la aplicación más repetida en todos los lenguajes de programación de la Historia de la humanidad: la aplicación "Hola mundo".

 

Venga, iremos paso a paso. Lo primero que hay que hacer es ejecutar Visual Studio .NET. Ya sé que es evidente, pero tenía que decirlo... Cuando lo hagas aparecerá este cuadro de diálogo:

 

 

Dale el nombre y ubicación que quieras para tu aplicación. Lo que sí te aconsejo es que marques la casilla de verificación "Crear directorio para la solución", como está en la imagen. Así tendrás bien organizados todos los archivos de la misma. Fíjate en los dos cuadros que hay: el de la izquierda sirve, como puedes ver, para indicar el lenguaje que vas a utilizar, y el de la derecha para indicar el tipo de aplicación que vas a diseñar. Más adelante los iremos viendo, pero aún no es el momento más adecuado. De momento vamos a crear aplicaciones de consola (es decir, programas que se ejecutan en una ventana de DOS). ¿Cómo? ¿Que quieres empezar ya a hacer aplicaciones para Windows? Así me gusta, hombre, que seáis valientes. Sin embargo, no vamos a empezar con eso aún. Por ahora lo que quiero es enseñaros el lenguaje C# propiamente dicho, ya que comenzar desde cero (o prácticamente cero) diseñando aplicaciones para Windows sin conocer el lenguaje no haría sino entorpecer el aprendizaje del mismo. Cuando conozcas el lenguaje podrás comprobar que no te cuesta ningún trabajo adaptarte al diseño para Windows.

 

Venga. Ahora quiero que te fijes un poco en el entorno de desarrollo:

 

 

Tiene barra de menús y barras de botones como casi todos los programas de hoy en día. Debajo, y de izquierda a derecha, tienes: El cuadro de herramientas, que se desplegará cuando pases el ratón por encima. Si quieres que esté siempre desplegado (al estilo del cuadro de herramientas de VB 6.0, por ejemplo) tendrás que hacer clic sobre un pequeño icono con forma de chincheta que hay al lado del botón cerrar de dicho cuadro. A continuación tienes el espacio de trabajo: en él te aparecerán las ventanas de código de cada archivo, así como el examinador de objetos, la ayuda... Cada ventana mostrará una pequeña pestaña en la parte superior (justo debajo de las barras de botones), para que puedas pasar de unas a otras con un solo clic (en esta imagen tienes las pestañas Class1.cs y AssemblyInfo.cs). A la derecha tienes el explorador de soluciones. Bueno... realmente son cuatro ventanas en una: fíjate en las pestañas que tiene justo debajo: el explorador de soluciones, que se ocupa de mostrarte los archivos que componen la solución que estás creando con una jerarquía en árbol; la vista de clases, que muestra las clases que componen la solución, organizadas también en árbol; el contenido de la ayuda, que muestra eso precisamente; y la búsqueda de ayuda, que, obviamente, sirve para buscar algo en la ayuda. Justo debajo está la ventana de propiedades, que se ocupa de mostrar las propiedades de algún archivo del proyecto, o alguna clase, o algún objeto, o algún método... Aquí tenéis también otra pestaña, la de ayuda dinámica, que va mostrando temas de ayuda que tienen que ver con lo que estás haciendo (si escribes class te salen temas sobre class, si escribes string te salen temas sobre eso, etc). Debajo tienes más ventanas (la lista de tareas, ventana de comandos, resultados, resultados de búsqueda de símbolos). Puede que a ti no te coincidan, ya que todo esto es perfectamente configurable, y como yo me lo he configurado a mi gusto y no recuerdo cuáles eran las opciones por defecto, pues eso, que puede ser que a ti no te aparezcan las mismas ventanas que a mi (sobre todo aquí abajo). En el menú Ver puedes mostrar y ocultar todas las ventanas que quieras, y también puedes cambiarlas de sitio simplemente arrastrándolas con el ratón. Venga, poned todo esto como más cómodo os resulte y seguimos...

 

Bueno, ahora que ya me he asegurado de que nos vamos a entender cuando yo hable de una ventana o de otra, podemos continuar. Visual Studio .NET guarda los distintos archivos que componen un programa con distintas extensiones, dependiendo de para qué sirva. Los distintos archivos que contienen el código fuente en lenguaje C# los guarda con la extensión "cs" (fijaos en el explorador de soluciones, en el cual tenéis Class1.cs y AssemblyInfo.cs). Al archivo de proyecto que está escrito en C# le pone la extensión "csproj". El archivo de proyecto contiene diversa información sobre el mismo: opciones de compilación, una lista de referencias y una lista de los archivos que lo componen. Más adelante entraremos en más detalles. El último archivo que nos interesa por ahora es el archivo de solución, al cual le pone la extensión "sln". Este contiene información sobre los proyectos que componen la solución.

 

El programa que vamos a desarrollar mostrará sencillamente el texto "Hola Mundo" en la consola (a partir de ahora, la consola es la ventana de DOS). De entrada, Visual Studio .NET nos ha escrito casi todo el código. Es el que sigue:

 

using System;

 

namespace HolaMundo

{

    /// <summary>

    /// Summary description for Class1.

    /// </summary>

    class Class1

    {

        static void Main(string[] args)

        {

            //

            // TODO: Add code to start application here

            //

        }

    }

}

 

Siempre que crees una aplicación de Consola en C#, Visual Studio .NET añadirá este código. Seguro que, con lo que hemos visto hasta ahora, te suena mucho. La directiva using System nos permitirá usar miembros de este espacio de nombres sin poner la palabra System delante. Luego hay definido un espacio de nombres para la aplicación, que se llama igual que la misma (HolaMundo). Luego está el sumario, que sirve para que puedas poner ahí lo que quieras (un resumen de lo que hace el programa, una lista de bodas, los Evangelios..., aunque normalmente se suele poner un resumen de lo que hace el programa). Por último, una clase llamada Class1 con un método Main que es static, que es el método por el que empezará la ejecución del programa. Esas tres líneas que hay dentro del método contienen un comentario (realmente hubiera bastado una línea sola, pero supongo que así se ve mejor). Te lo traduzco: "Para hacer: Añade aquí el código para que empiece la aplicación". O sea, que ya sabes dónde hay que escribir el código de nuestra aplicación "Hola Mundo": en el método Main. Escribe esto:

 

Console.WriteLine("Hola Mundo");

 

Ya está. ¿Ya? Sí, sí. Ya está. Vamos a probarla, a ver qué tal funciona. Haz clic en el menú "Depurar_Iniciar", o bien haz clic en el botón que tiene un triángulo azul apuntando hacia la derecha, o bien pulsa la tecla F5. Se ha abierto una ventana de DOS y se ha cerrado rápidamente. No pasa nada. Todo está bien. Para evitar que se cierre inmediatamente después de ejecutarse tienes dos opciones: ejecutar la aplicación sin opciones de depuración (menú Depurar_Iniciar sin depurar" o bien pulsar Control+F5); o añadir una línea de código más para que espere a que se pulse intro antes de cerrar la ventana. Yo sé que, seguramente, vas a elegir la primera de ellas (ejecutar sin depuración), pero es mejor la segunda, y luego te explico por qué. Escribe la siguiente línea a continuación de la que escribimos antes:

 

string a = Console.ReadLine();

 

Tranquilo que luego te explico el código. Ahora vuelve a ejecutar como hicimos la primera vez. Como ves, ahora la ventana de DOS se queda abierta hasta que pulses intro. ¿Y por qué es mejor hacerlo así que ejecutar sin depuración? Porque si ejecutamos sin depuración, obviamente, no podremos usar las herramientas de depuración, como poner puntos de interrupción, ejecutar paso a paso y cosas así. En esta aplicación no tendría mucho sentido, es cierto, pero cuando hagamos programas más grandes podréis comprobar que todas estas herramientas son verdaderamente útiles.

 

Por lo tanto, todo el código de nuestro programa terminado es este:

 

using System;

 

namespace HolaMundo

{

    /// <summary>

    /// Summary description for Class1.

    /// </summary>

    class Class1

    {

        static void Main(string[] args)

        {

            //

            // TODO: Add code to start application here

            //

            Console.WriteLine("Hola Mundo");

            string a = Console.ReadLine();

        }

    }

}

 

¿Qué es eso de "Console"? Bueno, Console es una clase que pertenece a la biblioteca de clases de .NET Framework y está dentro del espacio de nombres System. Sirve para efectuar diversas operaciones de consola. Nosotros nos fijaremos principalmente en dos de ellas: Escribir datos en la consola y leer datos de la misma.´

 

Para escribir los datos tenemos los métodos Write y WriteLine. Este último, como puedes apreciar, es el que hemos usado para nuestra aplicación. La diferencia entre ambos es que Write escribe lo que sea sin añadir el carácter de fin de línea a la cadena, de modo que lo siguiente que se escriba se pondrá a continuación de lo escrito con Write. WriteLine sí añade el carácter de fin de línea a la cadena, de modo que lo siguiente que se escriba se colocará en la siguiente línea. Es decir, el siguiente fragmento de código:

 

Console.Write("Hola");

Console.WriteLine("Pepe");

Console.Write("¿Cómo andas, ");

Console.WriteLine("tío?");

 

Ofrecería este resultado en la consola:

 

HolaPepe

¿Cómo andas, tío?

 

Hay 19 sobrecargas del método WriteLine, y otras 18 del método Write. ¿Qué es eso de las sobrecargas? Cómo, ¿he dicho sobrecargas?, ¿sí? Pues no quería decirlo todavía. En fin... veremos muy detallada la sobrecarga de métodos cuando lleguemos al tema de los métodos. Mientras tanto, que sepas que, más o menos, quiero decir que podemos usar estos métodos de diversas maneras (si es que me meto en unos líos...).

 

Para leer datos de la consola tenemos los métodos Read y ReadLine. No, no son equivalentes a Write y WriteLine pero en dirección contraria. El método Read obtiene el primer carácter que aún no se haya extraído del buffer de entrada. En caso de que el buffer esté vacío o bien contenga un caracter no válido, retornará -1. Sin embargo, ReadLine obtiene una línea completa del buffer de entrada, es decir, toda la cadena de caracteres hasta encontrar el carácter de fin de línea (bueno, realmente el fin de línea está definido por dos caracteres, pero tampoco vamos a darle más importancia, ya que esto de la consola viene muy bien para aprender, pero poco más). Por cierto, estos dos métodos no están sobrecargados. ¿Qué es eso del buffer de entrada? Pues vamos a ver: cuando el programa ejecuta un método Read y tú escribes Hola, don Pepito, hola don José y después pulsas la tecla intro, todo lo que has escrito va a dicho buffer. Read, decíamos, obtiene el primer carácter no extraído del buffer, de modo que la primera vez devuelve la H, la segunda la o, luego la l, luego la a, y así hasta terminar el buffer. Por lo tanto, el buffer de entrada es, para que me entiendas, una zona de memoria donde se almacenan datos que se han ingresado pero que aún no se han leído.

 

No te voy a contar una por una cómo son todas las sobrecargas de los métodos Write y WriteLine (tampoco merece la pena, la verdad). Te voy a explicar de qué formas los vamos a usar más comúnmente, y si en algún momento del curso los usamos de otro modo, ya te lo explicaré. El método Write lo usaremos de las siguientes formas:

 

Console.Write(cadena);

Console.Write(objeto);

Console.Write(objeto.miembro);

Console.Write("literal {0} literal {1} literal {2}...", dato0, dato1, dato2);

 

En la primera línea, "cadena" puede ser una cadena literal (por lo tanto, entre comillas) o bien una variable de tipo string (por lo tanto, sin comillas). En la segunda línea, "objeto" será cualquier variable de cualquier tipo, o bien una expresión. En la tercera línea, "objeto" será de nuevo cualquier variable de cualquier tipo, y lo usaremos así cuando queramos escribir lo que devuelva un miembro de ese objeto (una propiedad o un método). La última forma del método Write la usaremos cuando queramos intercalar datos dentro de un literal. Write escribiría esa cadena intercalando dato0 donde está  {0}, dato1 donde está {1}, y dato 2 donde está {2}, y así tantos datos como queramos intercalar. Por cierto, estos datos pueden ser objetos de cualquier tipo, o bien expresiones o bien lo que devuelva algún miembro de algún objeto. Para los programadores de C, es algo parecido a printf, pero mucho más fácil de usar.

 

El método WriteLine lo usaremos de las mismas formas que el método Write, además de esta:

 

Console.WriteLine();

 

Usaremos el método WriteLine así cuando queramos poner un salto de línea en la consola.

 

Los métodos Read y ReadLine no tienen sobrecargas, así que solamente los podremos usar así:

 

variable = Console.Read();

cadena = Console.ReadLine();

 

En la primera línea he puesto "variable" porque Read devolverá un valor de tipo int, equivalente al código del carácter unicode recibido del buffer. Por este motivo, la variable solamente puede ser de tipo int. En la segunda línea, ReadLine retorna siempre un valor de tipo string, por lo tanto, "cadena" debe ser una variable de tipo string.

 

Para terminar ya con esta entrega vamos a terminar de "maquear" un poquito el programa. Así  vas cogiendo buenas costumbres desde el principio. Como a mi no me gusta nada eso de class1, vamos a cambiarlo. Haz clic sobre el archivo Class1.cs en el explorador de soluciones. A continuación, en la ventana de propiedades busca "Nombre de archivo" y cámbia eso de Class1.cs por un nombre más significativo (HolaMundo.cs, por ejemplo). Por último, en la ventana de código, cambia class1 por HolaMundoApp. Es una buena costumbre colocar el método Main en una clase que se llame como la aplicación más las letras App. Puedes borrar si quieres el sumario (ya que este programa no creo que necesite muchas apreciaciones) y los comentarios que añadió Visual Studio en el método Main (sí, eso de // TODO: ...). Ya hemos terminado. No te olvides de guardarlo antes de salir de Visual Studio .NET, con Archivo_Guardar Todo, o bien el botón con varios diskettes dibujados, o bien la combinación de teclas Control+Mayúsculas+F5. De todos modos, si se te olvida y ha habido modificaciones, Visual Studio te preguntará si quieres guardarlas antes de salir. Nuestro primer programa en C# ha quedado así:

 

using System;

 

namespace HolaMundo

{

    class HolaMundoApp

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Hola Mundo");

            string a = Console.ReadLine();

        }

    }

}

 

¡Qué bonito! Sigue este vínculo si quieres bajártelo. Hasta la próxima entrega.