Cada llenguatge de programació té les seves pròpies regles d'escriptura: com se separen les instruccions, com s'agrupen blocs de codi, com es nomenen les coses. A aquestes regles les anomenem, en conjunt, sintaxi. En aquesta lliçó aprendràs les regles de sintaxi fonamentals del C# —majúscules i minúscules, punt i coma, claus, comentaris, convencions de nomenclatura i identificadors vàlids— que faràs servir en absolutament tot el codi que escriguis a partir d'ara. Dominar bé aquestes regles t'estalviarà bona part dels errors de compilació que solen frustrar qui comença a programar.

1. Sensibilitat a majúscules i minúscules
2. Punt i coma, claus i blocs de codi
3. Comentaris: //, /* */ i ///
4. Convencions de nomenclatura: PascalCase i camelCase
5. Estructura general d'un fitxer C#
6. Identificadors vàlids

El C# és un llenguatge case-sensitive (sensible a majúscules i minúscules). Això significa que laMevaVariable, LaMevaVariable i LAMEVAVARIABLE es consideren tres noms diferents pel compilador. Això afecta tot: noms de variables, de mètodes, de classes, i també les mateixes paraules clau del llenguatge.

Aquest detall és molt important perquè és una font habitual d'errors per a qui ve d'altres contextos (per exemple, alguns sistemes de fitxers o llenguatges que no distingeixen majúscules de minúscules). En C#, sempre cal respectar exactament les majúscules i minúscules de cada paraula clau i de cada nom que facis servir.

En C#, (gairebé) tota instrucció acaba amb un punt i coma ;. El punt i coma indica al compilador "aquí acaba aquesta instrucció, la següent és independent":

Oblidar el punt i coma és, probablement, l'error de sintaxi més comú en començar a programar en C#. El compilador t'avisarà amb un missatge d'error indicant la línia exacta.

Les claus delimiten blocs de codi: un conjunt d'instruccions que es tracten com una unitat. Ja hem vist a la lliçó anterior que un espai de noms, una classe i un mètode són, cadascun, un bloc delimitat per claus. El mateix passarà, més endavant en el curs, amb els blocs de les estructures de control (if, bucles, etc. — Mòdul 2).

Una convenció molt estesa (i la que seguirem en aquest curs) és la indentació: sagnar (afegir espais o tabulacions) el codi que és dins d'un bloc, perquè sigui visualment evident què pertany a què. El C# no obliga a indentar el codi perquè compili —a diferència de Python, per exemple— però un codi ben indentat és molt més fàcil de llegir i mantenir.

No et preocupis encara pel significat de l'if; l'estudiarem amb detall al Mòdul 2. Aquí només ens interessa la forma, no el contingut.

Els comentaris són fragments de text que el compilador ignora completament: serveixen únicament perquè les persones que llegeixin el codi (inclòs tu mateix, en el futur) entenguin què fa o per què s'ha fet d'una determinada manera. El C# ofereix tres tipus:

Els comentaris de documentació (///) fan servir una sintaxi especial basada en etiquetes XML, com <summary>. Encara que en aquest mòdul no escrivim encara mètodes ni classes pròpies (això arriba al Mòdul 3), és important que reconeguis aquesta sintaxi: molts editors mostren automàticament el contingut d'aquests comentaris com a ajuda emergent quan uses un mètode, i en projectes professionals és una pràctica molt valorada documentar així el codi públic.

Una convenció de nomenclatura és un acord (no una regla obligatòria del compilador) sobre com escriure els noms de les coses al codi, perquè sigui coherent i fàcil de llegir per a qualsevol persona familiaritzada amb el llenguatge. En C#, la comunitat i el mateix equip de .NET segueixen, de forma molt consistent, aquestes dues convencions:

Exemple comparant tots dos estils sobre dades de BiblioTech:

Encara que el compilador no t'obliga a seguir aquestes convencions (compilaria igual si fessis servir majúscules i minúscules d'una altra manera), seguir-les és una pràctica professional fonamental: fa que el teu codi sigui reconeixible i coherent amb la resta de l'ecosistema .NET, incloses totes les biblioteques estàndard (Console, WriteLine, etc., ja segueixen PascalCase).

• Els noms han de ser descriptius: millor numeroPagines que n o np.
• S'evita, en general, l'ús de guions baixos _ com a separador dins del nom (per exemple, es prefereix titolLlibre a titol_llibre), encara que sí que s'utilitza de vegades un guió baix com a prefix en certs contextos (per exemple, en camps privats d'una classe, cosa que veurem al Mòdul 3).
• No s'usen accents, ñ ni caràcters especials en els noms de variables, per evitar problemes de compatibilitat entre teclats, editors i sistemes.

Recordant el que hem vist a la lliçó anterior, un fitxer .cs típic (en la seva forma clàssica) segueix aquesta estructura general, de fora cap a dins:

Com hem vist a la lliçó anterior, en projectes moderns amb top-level statements els passos 2, 3 i 4 queden implícits: només escrius el pas 1 (si cal algun using addicional) i el pas 5 directament. El compilador continua generant "per sota" aquesta mateixa estructura.

Recordaràs que, en veure el fitxer .csproj generat a la lliçó anterior, apareixia l'opció <ImplicitUsings>enable</ImplicitUsings>. Aquesta opció, disponible en projectes moderns de .NET, fa que certs espais de noms molt habituals (com System, on viu Console) estiguin disponibles automàticament a tot el projecte, sense necessitat d'escriure using System; al principi de cada fitxer. Aquesta és la raó per la qual, en els exemples de les lliçons anteriors, hem pogut fer servir Console.WriteLine directament sense cap línia using visible.

Un identificador és el nom que dones a qualsevol element del teu codi: una variable, un mètode, una classe, etc. El C# imposa algunes regles obligatòries (que, si no es compleixen, el programa directament no compila):

• Ha de començar per una lletra o per un guió baix _ (mai per un número).
• La resta de caràcters poden ser lletres, números o guions baixos.
• No pot coincidir exactament amb una paraula clau reservada del llenguatge (com class, namespace, if, int...), tret que s'escrigui amb el prefix especial @ (una tècnica molt poc habitual, reservada per a casos excepcionals).
• No pot contenir espais ni símbols com -, ., ñ, accents, etc.

Aquestes regles s'apliquen no només a variables sinó, com veurem en mòduls posteriors, a noms de mètodes, classes, propietats i qualsevol altre element que definim nosaltres mateixos.

• Oblidar el punt i coma: ja ho hem mencionat, però val la pena repetir-ho perquè és, de llarg, l'error més freqüent en començar.
• Barrejar majúscules i minúscules sense adonar-se'n: escriure Console.writeline(...) en lloc de Console.WriteLine(...) provoca un error de compilació, ja que el C# distingeix majúscules de minúscules.
• Niar claus sense indentar: encara que compili igual, el codi sense indentar és molt difícil de depurar quan el programa creix. Acostuma el teu editor a indentar automàticament (la majoria ho fan en prémer Retorn).
• Fer servir noms poc descriptius: variables com x, a1, temp dificulten entendre el codi més endavant. Prefereix sempre noms descriptius com titolLlibre o estaDisponible.
• Confondre convenció amb obligació: PascalCase i camelCase són convencions, no regles del compilador; però seguir-les és el que s'espera de qualsevol codi C# professional, i les seguirem durant tot el curs.
• Consell: quan el compilador assenyali un error de sintaxi en una línia, revisa també la línia anterior: moltes vegades l'error real (com un punt i coma oblidat) és just abans d'on s'informa del problema.

1. De la següent llista d'identificadors, indica quins són vàlids en C# i, per als que no ho siguin, explica per què: numeroPagines, 3isbn, _titol, nom complet, namespace, Autor2.

2. Reescriu el següent fragment de codi aplicant correctament les convencions de nomenclatura (camelCase per a variables) i una indentació adequada:

   string TITOL = "El Quixot";
   int Pagines=863;
   bool Disponible=true;
   Console.WriteLine(TITOL);
   

3. Afegeix al teu fragment corregit de l'exercici anterior: un comentari d'una línia que expliqui què fa la variable pagines, i un comentari de bloc (/* */) al principi del fitxer que expliqui breument què fa tot el programa.

1. • numeroPagines → Vàlid (comença per lletra).
   • 3isbn → No vàlid (comença per un número).
   • _titol → Vàlid (comença per guió baix).
   • nom complet → No vàlid (conté un espai).
   • namespace → No vàlid (és una paraula clau reservada del llenguatge).
   • Autor2 → Vàlid (comença per lletra, conté un número que no és el primer caràcter).

2. Versió corregida:

   string titol = "El Quixot";
   int pagines = 863;
   bool disponible = true;
   Console.WriteLine(titol);
   

   S'ha canviat TITOL, Pagines i Disponible (amb majúscula inicial, propi de PascalCase) a titol, pagines i disponible en camelCase, adequat per a variables locals; també s'ha afegit un espai al voltant del signe = per llegibilitat, encara que el compilador acceptaria totes dues formes.

3. Exemple de solució:

   /*
      Programa d'exemple de BiblioTech.
      Mostra per pantalla el titol d'un llibre del cataleg.
   */
   string titol = "El Quixot";
   int pagines = 863; // Nombre total de pagines del llibre
   bool disponible = true;
   Console.WriteLine(titol);
   

En aquesta lliçó has après les regles de sintaxi que governen qualsevol programa en C#: la distinció entre majúscules i minúscules, l'ús del punt i coma i les claus per delimitar instruccions i blocs, els diferents tipus de comentaris, les convencions de nomenclatura PascalCase i camelCase, l'estructura general d'un fitxer i les regles perquè un identificador sigui vàlid. Amb aquesta base ja pots llegir i escriure codi C# sintàcticament correcte i ben organitzat.

A la propera lliçó, Variables i Tipus de Dades, posarem en pràctica aquestes regles de nomenclatura declarant variables reals amb diferents tipus de dades —números, text, valors booleans— fent servir com a exemple les dades d'un llibre de BiblioTech: el seu títol, el seu ISBN, el seu nombre de pàgines i si està disponible o no.