Sintaxis de C#

La sintaxis de C# define las reglas y estructuras fundamentales que permiten escribir código válido y comprensible. Como lenguaje de programación moderno, C# combina la potencia de la programación orientada a objetos con una sintaxis clara y expresiva que facilita tanto el aprendizaje como el desarrollo profesional.

Estructura básica de un programa

Todo programa en C# se organiza alrededor de clases y espacios de nombres. La estructura mínima incluye una clase que contiene el método Main, punto de entrada de la aplicación:

using System;

namespace MiPrimerPrograma
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("¡Hola, mundo!");
        }
    }
}

El espacio de nombres (namespace) organiza el código y evita conflictos de nombres. La directiva using permite acceder a funcionalidades de otros espacios de nombres sin escribir el nombre completo cada vez.

Elementos sintácticos fundamentales

Identificadores y convenciones

Los identificadores en C# siguen reglas específicas: deben comenzar con una letra o guión bajo, pueden contener letras, números y guiones bajos, y distinguen entre mayúsculas y minúsculas.

C# utiliza diferentes convenciones de nomenclatura según el elemento:

public class CalculadoraFinanciera    // PascalCase para clases
{
    private int numeroOperaciones;     // camelCase para campos privados
    public string NombreUsuario { get; set; }  // PascalCase para propiedades
    
    public void CalcularInteres()      // PascalCase para métodos
    {
        int tasaAnual = 5;            // camelCase para variables locales
    }
}

Delimitadores y separadores

Los delimitadores estructuran el código de manera jerárquica. Las llaves {} definen bloques de código, los paréntesis () agrupan parámetros y expresiones, y los corchetes [] se utilizan para arrays y atributos.

public int[] CalcularFactoriales(int limite)
{
    int[] resultados = new int[limite];
    
    for (int i = 0; i < limite; i++)
    {
        resultados[i] = CalcularFactorial(i + 1);
    }
    
    return resultados;
}

El punto y coma (;) termina las declaraciones, mientras que las comas (,) separan elementos en listas de parámetros, arrays y declaraciones múltiples.

Declaración de variables y tipos

La declaración de variables en C# requiere especificar el tipo de datos, seguido del nombre de la variable:

int edad = 25;
string nombre = "Ana García";
bool esActivo = true;
double salario = 2500.50;

C# también permite la inferencia de tipos usando la palabra clave var, donde el compilador determina el tipo basándose en el valor asignado:

var temperatura = 23.5;        // double
var mensaje = "Bienvenido";    // string
var contador = 0;              // int

Tipos de valor y referencia

Los tipos de valor almacenan datos directamente, mientras que los tipos de referencia almacenan referencias a objetos en memoria:

// Tipos de valor
int numero = 42;
char letra = 'A';
bool confirmado = false;

// Tipos de referencia
string texto = "Programación";
int[] numeros = {1, 2, 3, 4, 5};
object dato = new object();

Operadores y expresiones

Los operadores en C# se clasifican según su función y precedencia. Los operadores aritméticos realizan cálculos matemáticos:

int a = 10, b = 3;
int suma = a + b;          // 13
int division = a / b;      // 3 (división entera)
double divisionReal = (double)a / b;  // 3.333...
int resto = a % b;         // 1

Los operadores de comparación evalúan relaciones entre valores:

bool mayor = a > b;        // true
bool igual = a == b;       // false
bool diferente = a != b;   // true

Los operadores lógicos combinan expresiones booleanas:

bool resultado = (a > 5) && (b < 10);  // AND lógico
bool alternativa = (a < 0) || (b > 0); // OR lógico
bool negacion = !(a == b);             // NOT lógico

Estructuras de control

Condicionales

Las estructuras condicionales permiten ejecutar código basándose en condiciones específicas:

int puntuacion = 85;

if (puntuacion >= 90)
{
    Console.WriteLine("Excelente");
}
else if (puntuacion >= 70)
{
    Console.WriteLine("Bueno");
}
else
{
    Console.WriteLine("Necesita mejorar");
}

La expresión switch ofrece una alternativa elegante para múltiples condiciones:

string dia = "lunes";

string mensaje = dia switch
{
    "lunes" => "Inicio de semana",
    "viernes" => "Fin de semana laboral",
    "sabado" or "domingo" => "Fin de semana",
    _ => "Día regular"
};

Bucles

Los bucles permiten repetir código mientras se cumplan ciertas condiciones:

// Bucle for - iteraciones conocidas
for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"Iteración: {i}");
}

// Bucle while - condición al inicio
int contador = 0;
while (contador < 3)
{
    Console.WriteLine($"Contador: {contador}");
    contador++;
}

// Bucle foreach - iteración sobre colecciones
string[] nombres = {"Ana", "Carlos", "María"};
foreach (string nombre in nombres)
{
    Console.WriteLine($"Nombre: {nombre}");
}

Métodos y parámetros

Los métodos encapsulan funcionalidad reutilizable. Su sintaxis incluye modificadores de acceso, tipo de retorno, nombre y parámetros:

public static double CalcularAreaCirculo(double radio)
{
    return Math.PI * radio * radio;
}

public static void MostrarInformacion(string nombre, int edad = 18)
{
    Console.WriteLine($"Nombre: {nombre}, Edad: {edad}");
}

Los parámetros opcionales tienen valores predeterminados, mientras que los parámetros por referencia permiten modificar variables del método llamador:

public static void IntercambiarValores(ref int a, ref int b)
{
    int temporal = a;
    a = b;
    b = temporal;
}

// Uso del método
int x = 5, y = 10;
IntercambiarValores(ref x, ref y);  // x=10, y=5

Manejo de cadenas

Las cadenas de texto en C# ofrecen múltiples formas de manipulación y formato:

string nombre = "Juan";
int edad = 30;

// Concatenación tradicional
string mensaje1 = "Hola, " + nombre + ". Tienes " + edad + " años.";

// Interpolación de cadenas
string mensaje2 = $"Hola, {nombre}. Tienes {edad} años.";

// Formato compuesto
string mensaje3 = string.Format("Hola, {0}. Tienes {1} años.", nombre, edad);

La interpolación de cadenas permite incluir expresiones directamente:

double precio = 29.99;
int cantidad = 3;
string factura = $"Total: {precio * cantidad:C2}";  // Total: €89,97