Cada lenguaje de programación tiene sus propias reglas de escritura: cómo se separan las instrucciones, cómo se agrupan bloques de código, cómo se nombran las cosas. A estas reglas las llamamos, en conjunto, sintaxis. En esta lección aprenderás las reglas de sintaxis fundamentales de C# —mayúsculas y minúsculas, punto y coma, llaves, comentarios, convenciones de nomenclatura e identificadores válidos— que usarás en absolutamente todo el código que escribas a partir de ahora. Dominar bien estas reglas te evitará gran parte de los errores de compilación que suelen frustrar a quien empieza a programar.

1. Sensibilidad a mayúsculas y minúsculas
2. Punto y coma, llaves y bloques de código
3. Comentarios: //, /* */ y ///
4. Convenciones de nomenclatura: PascalCase y camelCase
5. Estructura general de un fichero C#
6. Identificadores válidos

C# es un lenguaje case-sensitive (sensible a mayúsculas y minúsculas). Esto significa que miVariable, MiVariable y MIVARIABLE son considerados tres nombres distintos por el compilador. Esto afecta a todo: nombres de variables, de métodos, de clases, y también a las propias palabras clave del lenguaje.

Este detalle es muy importante porque es una fuente habitual de errores para quien viene de otros contextos (por ejemplo, algunos sistemas de archivos o lenguajes que no distinguen mayúsculas de minúsculas). En C#, siempre hay que respetar exactamente las mayúsculas y minúsculas de cada palabra clave y de cada nombre que uses.

En C#, (casi) toda instrucción termina con un punto y coma ;. El punto y coma le indica al compilador "aquí termina esta instrucción, la siguiente es independiente":

Olvidar el punto y coma es, probablemente, el error de sintaxis más común al empezar a programar en C#. El compilador te avisará con un mensaje de error indicando la línea exacta.

Las llaves delimitan bloques de código: un conjunto de instrucciones que se tratan como una unidad. Ya vimos en la lección anterior que un espacio de nombres, una clase y un método son, cada uno, un bloque delimitado por llaves. Lo mismo ocurrirá, más adelante en el curso, con los bloques de las estructuras de control (if, bucles, etc. — Módulo 2).

Una convención muy extendida (y la que seguiremos en este curso) es la indentación: sangrar (añadir espacios o tabulaciones) el código que está dentro de un bloque, para que sea visualmente evidente qué pertenece a qué. C# no obliga a indentar el código para que compile —a diferencia de Python, por ejemplo— pero un código bien indentado es muchísimo más fácil de leer y mantener.

No te preocupes todavía por el significado de if; lo estudiaremos en detalle en el Módulo 2. Aquí solo nos interesa la forma, no el contenido.

Los comentarios son fragmentos de texto que el compilador ignora por completo: sirven únicamente para que las personas que lean el código (incluido tú mismo, en el futuro) entiendan qué hace o por qué se hizo de una determinada forma. C# ofrece tres tipos:

Los comentarios de documentación (///) usan una sintaxis especial basada en etiquetas XML, como <summary>. Aunque en este módulo no escribimos todavía métodos ni clases propias (eso llega en el Módulo 3), es importante que reconozcas esta sintaxis: muchos editores muestran automáticamente el contenido de estos comentarios como ayuda emergente cuando usas un método, y en proyectos profesionales es una práctica muy valorada documentar así el código público.

Una convención de nomenclatura es un acuerdo (no una regla obligatoria del compilador) sobre cómo escribir los nombres de las cosas en el código, para que sea coherente y fácil de leer para cualquier persona familiarizada con el lenguaje. En C#, la comunidad y el propio equipo de .NET siguen, de forma muy consistente, estas dos convenciones:

Ejemplo comparando ambos estilos sobre datos de BiblioTech:

Aunque el compilador no te obliga a seguir estas convenciones (compilaría igual si usaras mayúsculas y minúsculas de otra forma), seguirlas es una práctica profesional fundamental: hace que tu código sea reconocible y coherente con el resto del ecosistema .NET, incluidas todas las bibliotecas estándar (Console, WriteLine, etc., ya siguen PascalCase).

• Los nombres deben ser descriptivos: mejor numeroPaginas que n o np.
• Se evita, en general, el uso de guiones bajos _ como separador dentro del nombre (por ejemplo, se prefiere tituloLibro a titulo_libro), aunque sí se usa a veces un guion bajo como prefijo en ciertos contextos (por ejemplo, en campos privados de una clase, algo que veremos en el Módulo 3).
• No se usan tildes, ñ ni caracteres especiales en los nombres de variables, para evitar problemas de compatibilidad entre teclados, editores y sistemas.

Recordando lo visto en la lección anterior, un archivo .cs típico (en su forma clásica) sigue esta estructura general, de fuera hacia dentro:

Como vimos en la lección anterior, en proyectos modernos con top-level statements los pasos 2, 3 y 4 quedan implícitos: solo escribes el paso 1 (si hace falta algún using adicional) y el paso 5 directamente. El compilador sigue generando "por debajo" esa misma estructura.

Recordarás que, al ver el archivo .csproj generado en la lección anterior, aparecía la opción <ImplicitUsings>enable</ImplicitUsings>. Esta opción, disponible en proyectos modernos de .NET, hace que ciertos espacios de nombres muy habituales (como System, donde vive Console) estén disponibles automáticamente en todo el proyecto, sin necesidad de escribir using System; al principio de cada archivo. Es la razón por la que, en los ejemplos de las lecciones anteriores, hemos podido usar Console.WriteLine directamente sin ninguna línea using visible.

Un identificador es el nombre que le das a cualquier elemento de tu código: una variable, un método, una clase, etc. C# impone algunas reglas obligatorias (que si no se cumplen, el programa directamente no compila):

• Debe empezar por una letra o por un guion bajo _ (nunca por un número).
• El resto de caracteres pueden ser letras, números o guiones bajos.
• No puede coincidir exactamente con una palabra clave reservada del lenguaje (como class, namespace, if, int...), salvo que se escriba con el prefijo especial @ (una técnica muy poco habitual, reservada para casos excepcionales).
• No puede contener espacios ni símbolos como -, ., ñ, tildes, etc.

Estas reglas se aplican no solo a variables sino, como veremos en módulos posteriores, a nombres de métodos, clases, propiedades y cualquier otro elemento que definamos nosotros mismos.

• Olvidar el punto y coma: ya lo hemos mencionado, pero merece repetirse porque es, con diferencia, el error más frecuente al empezar.
• Mezclar mayúsculas y minúsculas sin darse cuenta: escribir Console.writeline(...) en lugar de Console.WriteLine(...) provoca un error de compilación, ya que C# distingue mayúsculas de minúsculas.
• Anidar llaves sin indentar: aunque compile igual, el código sin indentar es muy difícil de depurar cuando el programa crece. Acostumbra tu editor a indentar automáticamente (la mayoría lo hacen al pulsar Intro).
• Usar nombres poco descriptivos: variables como x, a1, temp dificultan entender el código más adelante. Prefiere siempre nombres descriptivos como tituloLibro o estaDisponible.
• Confundir convención con obligación: PascalCase y camelCase son convenciones, no reglas del compilador; pero seguirlas es lo que se espera de cualquier código C# profesional, y las seguiremos durante todo el curso.
• Consejo: cuando el compilador señale un error de sintaxis en una línea, revisa también la línea anterior: muchas veces el error real (como un punto y coma olvidado) está justo antes de donde se informa el problema.

1. De la siguiente lista de identificadores, indica cuáles son válidos en C# y, para los que no lo sean, explica por qué: numeroPaginas, 3isbn, _titulo, nombre completo, namespace, Autor2.

2. Reescribe el siguiente fragmento de código aplicando correctamente las convenciones de nomenclatura (camelCase para variables) y una indentación adecuada:

   string TITULO = "El Quijote";
   int Paginas=863;
   bool Disponible=true;
   Console.WriteLine(TITULO);
   

3. Añade a tu fragmento corregido del ejercicio anterior: un comentario de una línea que explique qué hace la variable paginas, y un comentario de bloque (/* */) al principio del archivo que explique brevemente qué hace todo el programa.

1. • numeroPaginas → Válido (empieza por letra).
   • 3isbn → No válido (empieza por un número).
   • _titulo → Válido (empieza por guion bajo).
   • nombre completo → No válido (contiene un espacio).
   • namespace → No válido (es una palabra clave reservada del lenguaje).
   • Autor2 → Válido (empieza por letra, contiene un número que no es el primer carácter).

2. Versión corregida:

   string titulo = "El Quijote";
   int paginas = 863;
   bool disponible = true;
   Console.WriteLine(titulo);
   

   Se ha cambiado TITULO, Paginas y Disponible (con mayúscula inicial, propio de PascalCase) a titulo, paginas y disponible en camelCase, adecuado para variables locales; también se ha añadido un espacio alrededor del signo = por legibilidad, aunque el compilador aceptaría ambas formas.

3. Ejemplo de solución:

   /*
      Programa de ejemplo de BiblioTech.
      Muestra por pantalla el título de un libro del catálogo.
   */
   string titulo = "El Quijote";
   int paginas = 863; // Número total de páginas del libro
   bool disponible = true;
   Console.WriteLine(titulo);
   

En esta lección has aprendido las reglas de sintaxis que gobiernan cualquier programa en C#: la distinción entre mayúsculas y minúsculas, el uso del punto y coma y las llaves para delimitar instrucciones y bloques, los distintos tipos de comentarios, las convenciones de nomenclatura PascalCase y camelCase, la estructura general de un archivo y las reglas para que un identificador sea válido. Con esta base ya puedes leer y escribir código C# sintácticamente correcto y bien organizado.

En la siguiente lección, Variables y Tipos de Datos, pondremos en práctica estas reglas de nomenclatura declarando variables reales con distintos tipos de datos —números, texto, valores booleanos— usando como ejemplo los datos de un libro de BiblioTech: su título, su ISBN, su número de páginas y si está disponible o no.