Amb l'entorn de desenvolupament ja preparat, ha arribat el moment de crear el teu primer projecte real: BiblioTechConsola, la primera pedra del sistema BiblioTech que construirem al llarg de tot el curs. En aquesta lliçó crearàs el projecte pas a pas, escriuràs i executaràs un "Hola Món", i analitzarem línia a línia cada part del codi, incloent-hi tant la forma clàssica com la forma moderna (top-level statements) d'escriure'l. Entendre bé aquesta estructura mínima és fonamental, perquè serà la base sobre la qual es recolzarà tot el codi que escriguis en els propers mòduls.

1. Crear el projecte BiblioTechConsola pas a pas
2. Escriure i executar el primer Hola Món
3. Explicació línia a línia de la versió clàssica
4. La variant moderna: top-level statements
5. Compilar i executar amb dotnet run

Obre un terminal a la carpeta on vulguis desar els teus projectes del curs i executa:

Aquesta ordre, com hem vist a la lliçó anterior, crea una carpeta BiblioTechConsola amb l'estructura bàsica d'un projecte de consola:

Obre la carpeta BiblioTechConsola amb el teu editor (VS Code, Visual Studio o Rider) i localitza el fitxer Program.cs. Aquest fitxer conté, per defecte, un petit programa d'exemple generat automàticament per la plantilla:

Aquesta és la versió moderna (amb top-level statements) que genera dotnet new console a les versions actuals del SDK. Modifiquem-la perquè parli de BiblioTech:

Pots eliminar el comentari generat automàticament (la línia que comença per //); no és necessari perquè el programa funcioni, és només informació orientativa que afegeix la plantilla.

Desa el fitxer Program.cs amb el contingut anterior i, des del terminal, dins de la carpeta del projecte, executa:

Hauries de veure al terminal:

Enhorabona! Acabes d'escriure i executar el teu primer programa en C#. Encara que sembli molt simple, aquest petit programa ja posa en joc diversos conceptes fonamentals del llenguatge que dissecarem a continuació.

Abans de la introducció dels top-level statements (a partir de C# 9, any 2020), tot programa de consola en C# s'havia d'escriure amb una estructura més explícita. És molt important conèixer aquesta forma clàssica, perquè:

• És la que trobaràs en moltíssim codi existent, documentació i tutorials antics.
• És, en realitat, el que el compilador genera "per sota" fins i tot quan fem servir la forma moderna i simplificada.

Així es veuria el nostre mateix programa en la seva forma clàssica i completa:

Expliquem cada línia, de dalt a baix:

És important fixar-se en el niuament: l'espai de noms conté la classe, la classe conté el mètode Main, i el mètode Main conté la instrucció Console.WriteLine. Aquesta jerarquia de claus és l'estructura general de (gairebé) qualsevol fitxer .cs que escriguis, i la retrobarem amb més detall a la propera lliçó, "Sintaxi i Estructura Bàsica".

Des de C# 9, el llenguatge permet ometre tot el codi "de bastida" (namespace, classe, mètode Main) quan el programa és simple, deixant només les instruccions que realment importen. A això se n'hi diu top-level statements (instruccions de nivell superior). És exactament el que va generar dotnet new console en crear el teu projecte:

Què ha passat amb tota la resta? El compilador de C# continua generant per sota la mateixa estructura (namespace, class Program, static void Main) de forma automàtica; simplement no l'has d'escriure tu mateix. És exactament el mateix programa, només que amb menys codi repetitiu (boilerplate) per escriure i llegir.

En aquest curs farem servir, per defecte, top-level statements per als exemples de consola senzills (especialment en aquest primer mòdul), perquè permeten centrar-se en el concepte que s'està aprenent sense distreure's amb codi repetitiu. Quan arribem a la Programació Orientada a Objectes (Mòdul 3), on definirem les nostres pròpies classes (Llibre, Soci, Prestec), tornarà a ser habitual veure estructures més semblants a la forma clàssica, combinades amb Main com a punt d'entrada.

Sí. Encara que no es declari explícitament string[] args, el sistema posa a la teva disposició una variable implícita anomenada args si la necessites:

No et preocupis si encara no entens l'if o la interpolació $"...": els veurem en detall als mòduls 2 i 6 respectivament (control de flux i cadenes de text). És només perquè sàpigues que la variable args segueix disponible encara que no es vegi el mètode Main explícitament.

Ja hem fet servir dotnet run per executar el nostre programa, però convé entendre exactament què passa "sota el capó" quan el llancem:

1. Restauració de dependències: dotnet comprova si el projecte necessita descarregar paquets externs (en el nostre cas, cap encara) i els prepara si cal.
2. Compilació: el compilador de C# tradueix el codi font (Program.cs) a llenguatge intermedi (IL), generant un executable dins la carpeta bin/.
3. Execució: el CLR carrega aquest executable i l'executa, compilant l'IL a codi màquina sobre la marxa (compilació JIT, mencionada a la primera lliçó).

Si només vols compilar sense executar (per exemple, per comprovar que no hi ha errors sense veure la sortida en pantalla), pots usar:

I si vols executar directament l'executable ja compilat (sense passar de nou per tot el procés de compilació), pots localitzar-lo dins de bin/Debug/net8.0/ i executar-lo directament des d'allà. A la pràctica, durant l'aprenentatge, dotnet run és la forma més còmoda i la que farem servir durant tot el curs.

Un flux de treball habitual mentre aprens és: editar Program.cs, desar, i tornar a executar dotnet run. Per exemple, prova a afegir una segona línia al teu programa:

En executar dotnet run de nou, veuràs ambdues línies al terminal, una sota l'altra, perquè WriteLine sempre afegeix un salt de línia al final del que escriu.

• Oblidar el punt i coma ; al final d'una instrucció: és un dels errors més freqüents en començar. El compilador mostrarà un missatge d'error indicant la línia exacta on falta.
• Desar el fitxer però executar des de la carpeta equivocada: dotnet run s'ha d'executar des de la carpeta del projecte (on és el fitxer .csproj), no des d'una carpeta superior o inferior.
• Pensar que sempre cal escriure la forma clàssica completa: no és així; per a programes senzills, els top-level statements són perfectament vàlids i són, de fet, la forma que genera la plantilla oficial de dotnet new console.
• Confondre Console.Write amb Console.WriteLine: Write escriu el text sense saltar de línia; WriteLine sí que salta de línia al final. Si dos missatges seguits apareixen "enganxats" a la mateixa línia, probablement has fet servir Write en lloc de WriteLine.
• Consell: quan el compilador mostri un error, llegeix-lo amb calma: normalment indica el fitxer, la línia i una descripció força precisa de què està malament (per exemple, "falta un punt i coma" o "no es troba aquest nom").

1. Crea el projecte BiblioTechConsola seguint els passos d'aquesta lliçó (si encara no ho has fet) i modifica Program.cs perquè, fent servir top-level statements, escrigui dues línies: una amb el nom del sistema ("BiblioTechConsola") i una altra amb un missatge de benvinguda de la teva elecció. Executa el programa amb dotnet run i comprova el resultat.

2. Reescriu el programa de l'exercici anterior fent servir la forma clàssica completa (using, namespace, class Program, static void Main), mantenint el mateix comportament (les mateixes dues línies de sortida). Executa'l i comprova que el resultat en pantalla és idèntic al de l'exercici 1.

3. Fent servir la variable implícita args en la versió de top-level statements, escriu un programa que mostri "Benvingut a BiblioTechConsola!" si no es passa cap argument, o una salutació personalitzada si se'n passa un. (Pista: a la majoria d'editors pots configurar els arguments de línia d'ordres a les opcions de depuració/execució; si encara no saps com fer-ho, no et preocupis, centra't en el fet que el codi compili correctament).

1. Contingut de Program.cs:

   Console.WriteLine("BiblioTechConsola");
   Console.WriteLine("Benvingut al sistema de gestio de la biblioteca!");
   

   En executar dotnet run, el terminal hauria de mostrar ambdues línies, una sota l'altra.

2. Versió clàssica equivalent:

   using System;
   
   namespace BiblioTechConsola
   {
       class Program
       {
           static void Main(string[] args)
           {
               Console.WriteLine("BiblioTechConsola");
               Console.WriteLine("Benvingut al sistema de gestio de la biblioteca!");
           }
       }
   }
   

   El resultat en pantalla és exactament el mateix que a l'exercici 1, perquè totes dues formes es compilen, en essència, al mateix programa.

3. Exemple de solució:

   if (args.Length > 0)
   {
       Console.WriteLine($"Hola, {args[0]}! Benvingut a BiblioTechConsola.");
   }
   else
   {
       Console.WriteLine("Benvingut a BiblioTechConsola!");
   }
   

   Si el programa s'executa sense arguments, es mostrarà el missatge genèric; si se li passa un argument (per exemple, un nom), es mostrarà la salutació personalitzada. No cal entendre encara en profunditat l'if ni la interpolació $"...": els veurem amb detall més endavant en el curs.

En aquesta lliçó has creat el teu primer projecte real del curs, BiblioTechConsola, i has après a distingir entre l'estructura clàssica d'un programa en C# (namespace, classe, mètode Main) i la forma moderna amb top-level statements, entenent que totes dues produeixen exactament el mateix resultat. També has practicat el cicle complet d'editar i executar amb dotnet run.

Ara que saps crear i executar programes, és el moment d'aprofundir en les regles de sintaxi que governen qualsevol fitxer C#: majúscules i minúscules, blocs delimitats per claus, tipus de comentaris i convencions de nomenclatura. Això és precisament el que veurem a la propera lliçó, Sintaxi i Estructura Bàsica.