Programacion con C#

Aplicación básica ¡Hola Mundo!

    Básicamente una aplicación en C# puede verse  como un conjunto de uno o más ficheros de código fuente con las instrucciones necesarias para que la aplicación funcione como se desea y que son pasados al compilador para que genere un ejecutable. Cada uno de estos ficheros no es más que un fichero de texto plano escrito usando caracteres Unicode y siguiendo la sintaxis propia de C#.

    Como primer contacto con el lenguaje, nada mejor que el típico programa de iniciación “¡Hola Mundo!” que lo único que hace al ejecutarse es mostrar por pantalla el mensaje ¡Hola Mundo! Su código es:[2]


1:         class HolaMundo
2:         {
3:                     static void Main()
4:                     {
5:                           System.Console.WriteLine("¡Hola Mundo!");
6:                     }
7:         }

    Todo el código escrito en C# se ha de escribir dentro de una definición de clase, y lo que en la línea 1: se dice es que se va a definir una clase (class) de nombre HolaMundo1 cuya definición estará comprendida entre la llave de apertura de la línea 2: y su correspondiente llave de cierre en  la línea línea 7:

    Dentro de la definición de la clase (línea 3:) se define un método de nombre Main cuyo código es el indicado entre la llave de apertura de la línea 4: y su respectiva llave de cierre (línea 6:) Un método no es más que un conjunto de instrucciones a las que se les asocia un nombre, de modo que para posteriormente ejecutarlas baste referenciarlas por su nombre en vez de tener que rescribirlas.

    La partícula que antecede al nombre del método indica cuál es el tipo de valor que se devuelve tras la ejecución del método, y en este caso es void que significa que no se devuelve nada. Por su parte, los paréntesis colocados tras el nombre del método indican cuáles son los parámetros que éste toma, y el que estén vacíos significa que el método no toma ninguno. Los parámetros de un método permiten modificar el resultado de su ejecución en función de los valores que se les dé en cada llamada.

    La palabra static que antecede a la declaración del tipo de valor devuelto es un  modificador del significado de la declaración de método que indica que el método  está asociado a la clase dentro de la que se define y no a los objetos que se creen a partir de ella. Main() es lo que se denomina el punto de entrada de la aplicación, que no es más que el método por el que comenzará su ejecución. Necesita del modificador static para evitar que para llamarlo haya que crear algún objeto de la clase donde se haya definido.

    Finalmente, la línea 5: contiene la instrucción con el código a ejecutar, que lo que se  hace es solicitar la ejecución del método WriteLine() de la clase Console definida en el espacio de nombres System pasándole como parámetro la cadena de texto con el contenido ¡Hola Mundo! Nótese que las cadenas de textos son secuencias  de caracteres delimitadas por comillas dobles aunque dichas comillas no forman parte de la cadena. Por su parte, un espacio de nombres puede considerarse que es para las clases algo similar a lo que un directorio es para los ficheros: una forma de agruparlas.

    El método WriteLine() se usará muy a menudo en los próximos temas, por lo que es conveniente señalar ahora que una forma de llamarlo que se utilizará en repetidas ocasiones consiste en pasarle un número indefinido de otros  parámetros de cualquier tipo e incluir en el primero subcadenas de  la forma {i}. Con ello se consigue que se muestre por la ventana de consola la cadena que se le pasa como primer parámetro pero sustituyéndole las subcadenas {i} por el valor convertido en cadena de texto del parámetro que ocupe la posición i+2 en la llamada a WriteLine(). Por ejemplo, la siguiente instrucción mostraría Tengo 5 años por pantalla si x valiese 5:


System.Console.WriteLine("Tengo {0} años", x);
     

    Para indicar cómo convertir cada objeto en un cadena de texto basta redefinir su método ToString(), aunque esto es  algo que no se verá hasta el Tema 5: Clases.

    Antes de seguir es importante resaltar que C# es sensible a las mayúsculas, los que significa que no da igual la capitalización con la que se escriban los identificadores. Es decir, no es lo mismo escribir Console que COnsole o CONSOLE, y si se hace de alguna de las dos últimas formas el compilador producirá un error debido a que en el espacio de nombres System no existe ninguna clase con dichos nombres. En este sentido, cabe señalar que un error común entre programadores acostumbrados a Java es llamar al punto de entrada main en vez de Main, lo que provoca un error al compilar ejecutables en tanto que el compilador no detectará ninguna definición de punto de entrada.

Puntos de entrada

    Ya se ha dicho que el  punto de entrada de una aplicación es un método de nombre Main que contendrá el código por donde se ha de iniciar la ejecución de la misma. Hasta ahora sólo se ha visto una versión de Main() que no toma parámetros y tiene como tipo de retorno void, pero en realidad todas sus posibles versiones son:


            static void Main()

            static int Main()

            static int Main(string[] args)

            static void Main(string[] args)

    Como se ve, hay versiones de Main() que devuelven un valor de tipo int. Un int no es más que un tipo de datos capaz de almacenar valor enteros comprendidos entre –2.1471483.648 y 2.1471483.647, y el número devuelto por Main() sería interpretado como código de retorno de la aplicación. Éste valor suele usarse para indicar si la aplicación a terminado con éxito (generalmente valor 0) o no (valor según la causa de la terminación anormal), y en el Tema 8: Métodos se explicará como devolver valores.

    También hay versiones de Main() que toman un parámetro donde se almacenará la lista de argumentos con los que se llamó a la aplicación, por lo que sólo es útil usar estas versiones del punto de entrada si la aplicación va a utilizar dichos argumentos para algo. El tipo de este parámetro es string[], lo que significa que es una tabla de cadenas de texto (en el Tema 5: Claes se explicará detenidamente qué son las tablas y las cadenas), y su nombre -que es el que habrá de usarse dentro del código de Main() para hacerle referencia- es args en el ejemplo, aunque podría dársele cualquier otro

Compilación en línea de comandos

    Una vez escrito el código anterior con algún editor de textos –como el Bloc de Notas de Windows- y almacenado en formato de texto plano en un fichero HolaMundo.cs[3], para compilarlo basta abrir una ventana de consola (MS-DOS en Windows), colocarse en el directorio donde se encuentre y pasárselo como parámetro al compilador así:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc HolaMundo.cs

    csc.exe es el compilador de C# incluido en el .NET Framework SDK para Windows de Microsoft. Aunque en principio el programa de instalación del SDK lo añade automáticamente al path para poder llamarlo sin problemas desde cualquier directorio, si lo ha instalado a través de VS.NET esto no ocurrirá y deberá configurárselo ya sea manualmente, o bien  ejecutando el fichero por lotes Common7\Tools\vsvars32.bat que VS.NET incluye bajo su directorio de instalación, o abriendo la ventana de consola desde el icono Herramientas de Visual Studio.NET à Símbolo del sistema de Visual Studio.NET correspondiente al grupo de programas de VS.NET en el menú Inicio de Windows que no hace más que abrir la ventana de consola y llamar automáticamente a vsvars32.bat. En cualquier caso, si usa otros compiladores de C# puede que varie la forma de realizar la  compilación, por lo que lo que aquí se explica en  principio sólo será válido para los compiladores de C# de Microsoft para Windows.

    Tras la compilación se obtendría un ejecutable llamado HolaMundo.exe cuya ejecución produciría la siguiente salida por la ventana de consola:


   Hola Mundo!

    Si la aplicación que se vaya a compilar no utilizase la ventana de consola para mostrar su salida sino una interfaz gráfica de ventanas, entonces habría que compilarla pasando  al compilador la opción /t con el valor winexe antes del nombre del fichero a compilar. Si no se hiciese así se abríría la ventana de consola cada vez que ejecutase la aplicación de ventanas, lo que suele ser indeseable en este tipo de aplicaciones. Así, para compilar Ventanas.cs como ejecutable de ventanas sería conveniente escribir:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:winexe Ventanas.cs

     

    Nótese que aunque el nombre winexe dé la sensación de que este valor para la opción /t sólo permite generar ejecutables de ventanas, en realidad lo que permite es generar ejecutables sin ventana de consola asociada. Por tanto, también puede usarse para generar ejecutables que no tengan ninguna interfaz asociada, ni de consola ni gráfica.

    Si en lugar de un ejecutable -ya sea de consola o de ventanas- se desea obtener una librería, entonces al compilar hay que pasar al compilador la opción /t con el valor library. Por ejemplo, siguiendo con el ejemplo inicial habría que escribir:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc /t:library HolaMundo.cs

    En este caso se generaría un fichero HolaMundo.dll cuyos tipos de datos podrían utilizarse desde otros fuentes pasando al compilador una referencia a los mismos mediante la opción /r. Por ejemplo, para compilar como ejecutable un fuente A.cs que use la clase HolaMundo de la librería HolaMundo.dll se escribiría:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc /r:HolaMundo.dll A.cs

    En general /r permite referenciar a tipos definidos en cualquier ensamblado, por lo que  el valor que se le indique también puede ser el nombre de un ejecutable. Además, en cada compilación es posible referenciar múltiples ensamblados ya sea incluiyendo la opción /r una vez por cada uno o incluiyendo múltiples referencias en una única opción /r usando comas o puntos y comas como separadores. Por ejemplo, las siguientes tres llamadas al compilador son equivalentes:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /r:HolaMundo.dll;Otro.dll;OtroMás.exe  A.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /r:HolaMundo.dll,Otro.dll,OtroMás.exe A.cs

C:\WINDOWS\....\v2.0.50727>csc /t:HolaMundo.dll /r:Otro.dll /r:OtroMás.exe A.cs

    Hay que señalar que aunque no se indique nada, en toda compilación siempre se referencia por defecto a la librería mscorlib.dll de la BCL, que incluye los tipos de uso más frecuente. Si se usan tipos de la BCL no incluidos en ella habrá que incluir al compilar referencias a las librerías donde estén definidos (en la documentación del SDK sobre cada tipo de la BCL puede encontrar información sobre donde se definió)

    Tanto las librerías como los ejecutables son ensamblados. Para generar un módulo de código que no forme parte de ningún ensamblado sino que contenga definiciones de tipos que puedan añadirse a ensamblados que se compilen posteriormente, el valor que ha de darse al compilar a la opción /t es module. Por ejemplo:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc /t:module HolaMundo.cs

    
    Con la instrucción anterior se generaría un módulo llamado HolaMundo.netmodule que  podría ser añadido a compilaciones de ensamblados incluyéndolo como valor de la opción /addmodule. Por  ejemplo, para añadir el módulo anterior a la compilación del fuente librería Lib.cs como librería se escribiría:


C:\WINDOWS\...\v2.0.50727>
csc /t:library /addmodule:HolaMundo.netmodule Lib.cs

     

    Aunque hasta ahora todas las compilaciones de ejemplo se han realizado utilizando un único fichero de código fuente, en realidad nada impide que se puedan utilizar más. Por ejemplo, para compilar los ficheros A.cs y B.cs en una librería A.dll se ejecutaría:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>c
sc /t:library A.cs B.cs

    Nótese que el nombre que por defecto se dé al ejecutable generado siempre es igual al del primer fuente especificado pero con la extensión propia del tipo de compilación realizada (.exe para ejecutables, .dll para librerías y .netmodule para módulos) Sin embargo, puede especificárse  como valor en la opción /out del compilador cualquier otro tal y como muestra el siguiente ejemplo que compila el fichero A.cs como una librería de nombre Lib.exe:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc /t:library /out:Lib.exe A.cs

    Véase que aunque se haya dado un nombre terminado en .exe al fichero resultante, éste sigue siendo una librería y no un ejecutable e intentar ejecutarlo produciría un mensaje de error. Obviamente no tiene mucho sentido darle esa extensión, y sólo se le ha dado en este ejemplo para demostrar que, aunque recomendable, la extensión del fichero no tiene porqué corresponderse realmente con el tipo de fichero del que se trate.

    A la hora de especificar ficheros a compilar también se pueden utilizar los caracteres de comodín típicos del sistema operativo.  Por ejemplo, para compilar todos los ficheros con extensión .cs del directorio actual en una librería llamada Varios.dll se haría:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>
csc /t:library /out:varios.dll *.cs

    Con lo que hay que tener cuidado, y en especial al compilar varios fuentes, es con que no se compilen a la vez más de un tipo de dato con punto de entrada, pues entonces el compilador no sabría cuál usar como inicio de la aplicación. Para orientarlo, puede especificarse como valor de la opción /main el  nombre del tipo que contenga el Main() ha usar como punto de entrada. Así, para compilar los ficheros A.cs y B.cs en un ejecutable cuyo punto de entrada sea el definido en el tipo Principal, habría que escribir:


C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /main:Principal A.cs B.cs

    Lógicamente, para que esto funcione A.cs o B.cs tiene que contener alguna definición de algún tipo llamado Principal con un único método válido como punto de entrada (obviamente, si contiene varios se volvería a tener el problema de no saber cuál utilizar)

Compilación con Visual Studio.NET

    Para compilar una aplicación en Visual Studio.NET primero hay que incluirla dentro de algún proyecto. Para ello basta pulsar el botón New Project en la página de inicio que se muestra nada más arrancar dicha herramienta, tras lo que se obtendrá una pantalla con el aspecto mostrado en la Ilustración 1 08D0C9EA79F9BACE118C8200AA004BA90B02000000080000000E0000005F00520065006600340038003400360039003700390033003300000000 .

    En el recuadro de la ventana mostrada etiquetado como Project Types se ha de  seleccionar el tipo de proyecto a crear. Obviamente, si se va a trabajar en C# la opción que habrá que escoger en la misma será siempre Visual C# Projects.

    En el recuadro Templates se ha de seleccionar la plantilla correspondiente al subtipo  de proyecto dentro del tipo indicado en Project Types que se va a realizar. Para realizar un ejecutable de consola, como es nuestro caso, hay que seleccionar el icono etiquetado como Console Application. Si se quisiese realizar una librería habría que seleccionar Class Library, y si se quisies realizar un ejecutable de ventanas habría que seleccionar Windows Application. Nótese que no se ofrece ninguna plantilla para realizar módulos, lo que se debe a que desde Visual Studio.NET no pueden crearse.

    Por último, en el recuadro de texto Name se ha de escribir el nombre a dar al proyecto y en Location el del directorio base asociado al mismo. Nótese que bajo de Location aparecerá un mensaje informando sobre cual será el directorio donde finalmente se almacenarán los archivos del proyecto, que será el resultante de concatenar la ruta especificada para el directorio base y el nombre del proyecto.


[Ampliar Imagen]

Ilustración 1 : Ventana de creación de nuevo proyecto en Visual Studio.NET

    Una vez configuradas todas estas opciones, al pulsar botón OK Visual Studio creará toda la infraestructura adecuada para empezar a trabajar cómodamente en el proyecto. Como puede apreciarse en la Ilustración 2 , esta infraestructura consistirá en la generación de un fuente que servirá de plantilla para la realización de proyectos del tipo elegido (en nuestro caso, aplicaciones de  consola en C#):


[Ampliar Imagen]

Ilustración 2 : Plantilla para aplicaciones de consola generada por Visual Studio.NET

    A partir de esta plantilla, escribir el código de la aplicación de ejemplo es tan sencillo con simplemente teclear System.Console.WriteLine(“¡Hola Mundo!”) dentro de la definición del método Main() creada por Visual Studio.NET. Claro está, otra posibilidad es borrar toda la plantilla y sustituirla por el código para HolaMundo mostrado anteriormente.

    Sea haga como se haga, para compilar y ejecutar tras ello la aplicación sólo hay que pulsar CTRL+F5 o seleccionar Debug à Start Without Debugging en el menú principal de Visual Studio.NET. Para sólo compilar el proyecto, entonces hay que seleccionar Build à Rebuild All. De todas formas, en ambos casos el ejecutable generado se almacenará en el subdirectorio Bin\Debug del directorio del  proyecto.

    En el extremo derecho de la ventana principal de Visual Studio.NET puede encontrar el denominado Solution Explorer (si no lo encuentra, seleccione View à Solution Explorer), que es una herramienta que permite consultar cuáles son los archivos que forman el proyecto. Si selecciona en él el icono correspondiente al proyecto en que estamos trabajando y pulsa View à Property Pages obtendrá una hoja de propiedades del proyecto con el aspecto mostrado en la Ilustración 3 :


[Ampliar Imagen]

Ilustración 3 : Hoja de propiedades del proyecto en Visual Studio.NET

    Esta ventana permite configurar de manera visual la mayoría de opciones con las que se llamará al compilador en línea de comandos. Por ejemplo, para cambiar el nombre del fichero de salida (opción /out) se indica su nuevo nombre en el cuadro de texto Common Properties à General à Assembly Name, para cambiar el tipo de proyecto a generar (opción /t) se utiliza Common Properties à General à Output Type (como verá si intenta cambiarlo, no es posible generar módulos desde Visual Studio.NET), y el tipo que contiene el punto de entrada a utilizar (opción /main) se indica en Common Properties à General à Startup Object

Finalemente, para añadir al  proyecto referencias a ensamblados externos (opción /r) basta seleccionar Project à Add Reference en el menú principal de VS.NET.

Programacion con C#
José Antonio González Seco

José Antonio es experto en tecnologias Microsoft. Imparte cursos y conferencias en congresos sobre C# y .NET en Universidades de toda España (Sevilla, Barcelona, San Sebastián, Valencia, Oviedo, etc.) en representación de grandes empresas como Microsoft.
Fecha de alta:03/10/2006
Última actualizacion:03/10/2006
Visitas totales:175274
Valorar el contenido:
Últimas consultas realizadas en los foros
Últimas preguntas sin contestar en los foros de devjoker.com