Sintaxis de C#

Resumen: en este tutorial, aprenderás sobre la sintaxis básica de C#, incluidos espacios en blanco, declaraciones, identificadores, palabras reservadas, literales y comentarios.

Introducción a la sintaxis de C#

La sintaxis de C# es similar a la de C/C++. Este tutorial se centra en espacios en blanco, declaraciones, identificadores, palabras clave, literales y comentarios.

Espacio en blanco

Los espacios en blanco se refieren a los caracteres que no tienen una salida visible, incluidos:

• Retorno de carro
• Espacios
• Nueva línea
• Tab

El compilador de C# ignora los espacios en blanco. Pero usa espacios en blanco para hacer que el código sea legible.

Por ejemplo, el compilador de C# tratará los siguientes fragmentos de código de la misma manera a pesar de sus diferencias en la presentación:

// with whitespace
bool isDark = false;

if (isDark)
{
    website.EnableDarkMode();
}

bool isDark = false;
if (isDark){ website.EnableDarkMode();}

En este ejemplo vemos código sin espacios en blanco ni comentarios: todo está apretado. Las declaraciones y las operaciones están todas en una línea, lo que hace que sea difícil para los ojos seguir y entender lo que está sucediendo.

using System;
class Program{
    static void Main(string[] args){
        int a=10;int b=20;int c=a+b;Console.WriteLine(c);
    }
}

Ahora veremos este otro ejemplo, vemos código con espacios en blanco, saltos de linea y sin comentarios: aquí, hemos introducido espacios en blanco, separando las declaraciones y operaciones. Esto hace que el código sea mucho más legible que el primer ejemplo. Sin embargo, todavía no explica por sí mismo qué está sucediendo, lo que nos lleva al siguiente paso

using System;
class Program
{
    static void Main(string[] args)
    {
        int a = 10;
        int b = 20;
        int c = a + b;
        Console.WriteLine(c);
    }
}

Ahora vemos el siguiente ejemplo de código con espacios en blanco y comentarios: En este último bloque, no solo hay espacios en blanco que organizan el código, sino también comentarios que explican qué está sucediendo en cada paso. Si alguien nuevo lee este código, los comentarios le guiarán a través de él, haciendo que la función de cada parte sea comprensible.

using System;

// Definición de la clase Program
class Program
{
    // Método principal del programa
    static void Main(string[] args)
    {
        // Declaración de variables
        int a = 10; // valor inicial de a
        int b = 20; // valor inicial de b

        // Suma de variables
        int c = a + b; // c almacena la suma de a y b

        // Imprimir el resultado en la consola
        Console.WriteLine(c); // muestra el contenido de c
    }
}

Y recuerda, un buen código es como un buen chiste... ¡no es necesario que lo expliquemos!

Declaraciones

Una declaración es una instrucción de código fuente que declara un tipo o le indica al programa que haga algo. Una declaración simple termina con un punto y coma (;).

Por ejemplo, el siguiente código tiene dos declaraciones simples:

int age = 9;
Console.WriteLine("Welcome to C#");

La primera instrucción define una variable entera e inicializa sus valores en 9. La segunda instrucción imprime un mensaje en la ventana de la consola.

Bloques

Un bloque es una secuencia de cero o más sentencias. Un bloque comienza con una llave de apertura ({) y termina con una llave de cierre (}).

Por ejemplo, puedes agrupar las dos declaraciones anteriores en un bloque como este:

{
    int age = 9;
    Console.WriteLine("Welcome to C#");
}

A diferencia de una declaración, un bloque no requiere un punto y coma (;).

El flujo de nuestros programas se mueve a través de estos bloques, ejecutando las declaraciones en el orden en que aparecen, de arriba a abajo.

public class Program
{
    public static void Main(string[] args)
    {
        // Declaración de variables
        int temperatura = 22;
        string mensaje = "";

        // Estructura de control 'if-else' que forma un bloque de código
        if (temperatura < 20)
        {
            mensaje = "Hace frío. ¡Mejor lleva una chaqueta!";
        }
        else if (temperatura < 30)
        {
            mensaje = "El clima está agradable. ¡Disfruta el día!";
        }
        else
        {
            mensaje = "Hace calor. ¡No olvides tu protector solar!";
        }

        // Imprimir el mensaje basado en la temperatura
        Console.WriteLine(mensaje);
    }
}

Cuando en nuestro código existen estructuras de control, como las sentencias 'if', el flujo del programa puede cambiar. Dependiendo de si la condición es verdadera o falsa, el programa ejecutará diferentes bloques de código.

Lo mismo ocurre con las funciones. Cuando llamamos a una función, el flujo de nuestro programa salta al bloque de código de esa función, lo ejecuta y luego regresa y continúa donde lo dejó.

using System;

public class ProgramaDemostracion
{
    
    public static void Main(string[] args)
    {
        // Llamada a la función desde el método principal
        string saludo = CrearMensajeDeSaludo("Estrada Web Group");
        
        // Imprimir el mensaje de saludo
        Console.WriteLine(saludo);
    }

    // Una función que crea un mensaje de saludo
    public static string CrearMensajeDeSaludo(string nombre)
    {
        return "¡Hola, " + nombre + "! Bienvenido al tutorial de C#.";
    }
}

Entender cómo las declaraciones forman bloques y cómo el flujo del programa se mueve a través de estos bloques es fundamental para comprender cómo construir y analizar programas en C#. Como pueden ver, cada parte tiene su propósito y lugar en el gran esquema de las cosas.

using System;

public class ProgramaDemostracion
{
    public static void Main(string[] args)
    {
        // Declaración de variables
        int numero = 10;
        string resultado;

        // Llamada a función
        resultado = ChequearNumero(numero);

        // Imprimir el resultado
        Console.WriteLine("Resultado: " + resultado);

        // Flujo de control: bucle for
        Console.WriteLine("Conteo regresivo:");
        for (int i = 5; i > 0; i--)
        {
            Console.WriteLine(i);
        }

        Console.WriteLine("¡Despegue!");
    }

    // Función que utiliza declaración de variables, flujo de control y devuelve un valor
    public static string ChequearNumero(int valor)
    {
        string mensaje;

        // Flujo de control: if-else
        if (valor > 0)
        {
            mensaje = "El número es positivo.";
        }
        else if (valor < 0)
        {
            mensaje = "El número es negativo.";
        }
        else
        {
            mensaje = "El número es cero.";
        }

        return mensaje;
    }
}

Identificadores

En nuestra aventura en CSharp, nos encontramos con criaturas místicas conocidas como 'Identificadores' y 'Palabras Reservadas'. Los identificadores son los nombres únicos de nuestros personajes (variables, funciones, etcétera), y las palabras reservadas... bueno, son como las piedras preciosas en un videojuego: ¡tienen poderes especiales y no puedes usarlas como quieras!

Para ilustrarlo mejor veamos un ejemplo, imagina que estamos escribiendo la historia de un videojuego en nuestro código:

using System;

public class AventuraMagica
{
    public static void Main(string[] args)
    {
        // Declarando las variables de nuestros héroes
        string heroe = "Sir Codalot";
        int puntosDeVida = 100;

        // Invocando un hechizo (función) desde nuestro libro de hechizos (código)
        Console.WriteLine("¡En un mundo gobernado por el código, " + heroe + " emprende una valiente aventura!");

        // ¡Oh no! Un monstruo aparece. Vamos a usar una 'palabra reservada' para controlar el flujo de la batalla.
        bool tieneEscudoMagico = true; // Nuestro héroe tiene un escudo mágico

        if (tieneEscudoMagico)
        {
            Console.WriteLine(heroe + " usa su escudo mágico. ¡El monstruo no puede dañarlo!");
        }
        else
        {
            // Nuestro héroe sufre daño
            puntosDeVida -= 20;
            Console.WriteLine("¡Auch! " + heroe + " ahora tiene " + puntosDeVida.ToString() + " puntos de vida.");
        }

        // Nuestro héroe encuentra una 'piedra preciosa' (palabra reservada) que le permite 'teletransportarse' (return) a un lugar seguro.
        RegresarAlCastillo(heroe);
    }

    // Definiendo nuestro hechizo mágico (función)
    public static void RegresarAlCastillo(string nombreDelHeroe)
    {
        // La 'piedra preciosa' que permite a nuestro héroe escapar de peligros
        Console.WriteLine("Con un destello de luz, " + nombreDelHeroe + " se teletransporta de vuelta al castillo seguro y sonoro.");
    }
}

En este ejemplo, estamos utilizando identificadores como heroe, puntosDeVida, y tieneEscudoMagico para representar diferentes elementos de nuestro juego. Las palabras reservadas, como if y else, actúan como nuestras "piedras preciosas" mágicas que controlan el flujo de la aventura, determinando qué acciones toma nuestro héroe.

Los identificadores son nombres que eliges para variables, funciones, clases, métodos, etc. Los nombres de los identificadores siguen estas reglas:

• Los caracteres alfabéticos (de la a a la z, de la A a la Z) y de subrayado (_) pueden aparecer en cualquier posición.
• Los dígitos no pueden aparecer en la primera posición, pero en cualquier otra posición si.

Los identificadores de C# distinguen entre mayúsculas y minúsculas. Por ejemplo, contador y Contador son identificadores diferentes.

Palabras reservadas

Las palabras clave son nombres que tienen significados especiales para el compilador. Todas las palabras clave son identificadores reservados. Por lo tanto, no puede usarlos como identificadores.

La siguiente tabla muestra las palabras reservadas de C#:

Además de estas palabras reservadas, C# tiene palabras reservadas contextuales que brindan significados específicos en el código. Sin embargo, no son identificadores reservados. Y aprenderás sobre ellos más adelante en el tutorial.

Si debes usar un identificador con el mismo nombre que una palabra clave reservada, puedes prefijarlo con el símbolo @. Por ejemplo:

@class

Ten en cuenta que el símbolo @ no forma parte del identificador. Entonces, el identificador @myVariable es el mismo que myVariable.

En la práctica, usa el símbolo @ cuando interactúas con bibliotecas de otros lenguajes .NET que tienen diferentes palabras clave.

Literales

Los literales son valores primitivos en el programa. Por ejemplo, un entero tiene el siguiente literal:

10

Para formar una cadena, coloque el texto entre comillas dobles (") de esta manera:

"Hello"

Y aquí vienen los literales, los 'objetos' reales en nuestra historia de CSharp. Son los números, textos y otros valores con los que nuestras variables y funciones jugarán.

Por ejemplo en este código

using System;

public class HistoriaDeLiterales
{
    public static void Main(string[] args)
    {
        // Aquí tenemos algunos literales numéricos, los 'cristales mágicos' con los que nuestro héroe puede interactuar.
        int cristales = 5; // Literal entero
        double pesoDeCristales = 4.5; // Literal de punto flotante

        // Los literales de cadena son como 'pergaminos' que contienen mensajes o hechizos.
        string mensajeSecreto = "¡La cueva del tesoro está al oeste!"; // Literal de cadena

        // Los literales booleanos son como 'pociones' que solo pueden ser verdaderas o falsas.
        bool tieneMapa = true; // Literal booleano

        // Usando nuestros 'cristales mágicos' para resolver un acertijo y abrir una puerta secreta.
        int totalCristales = cristales + 3; // Aquí, '3' es un literal que se suma a nuestra variable 'cristales'.

        Console.WriteLine("Nuestro héroe tiene " + totalCristales + " cristales mágicos.");

        // Leyendo el 'pergamino' para saber hacia dónde ir.
        Console.WriteLine("El pergamino dice: " + mensajeSecreto);

        // Verificando si nuestro héroe tiene un mapa.
        if (tieneMapa)
        {
            Console.WriteLine("¡Nuestro héroe saca un mapa del bolsillo! La aventura continúa...");
        }
        else
        {
            Console.WriteLine("Parece que nuestro héroe tendrá que adivinar el camino...");
        }

        // Supongamos que nuestro héroe usa los cristales para intercambiarlos por información o artículos.
        double pesoTotal = pesoDeCristales * totalCristales; // Operación usando literales y variables.
        Console.WriteLine("El peso total de los cristales es: " + pesoTotal + " kilogramos.");
    }
}

Comentarios

Utiliza comentarios para explicar el código o documentarlo. El compilador de C# ignora los comentarios al compilar el programa.

C# admite tres tipos de comentarios:

• Comentarios de una sola línea
• Comentarios delimitados
• Comentarios de la documentación

Comentarios de una sola línea

Un comentario de una sola línea comienza con una barra inclinada doble (//) y continúa hasta el final de la línea. Por ejemplo:

int age = 18; // tu edad

En este ejemplo, aquí está el comentario de una sola línea:

// tu edad

Comentarios delimitados

Un comentario delimitado comienza con /* y termina con */. Un comentario delimitado puede abarcar cualquier número de líneas. Por ejemplo:

/*
Un comentario delimitado puede abarcar varias líneas y
el compilador de C# lo ignora
*/

 Comentarios de la documentación

Los comentarios de la documentación contienen texto XML utilizado para hacer la documentación del programa.

/// <summary>
/// The main program
/// </summary>
class Program
{
    // ...
}

La documentación comienza con tres barras diagonales contiguas (///).

Consejos y trucos

Antes de continuar, aquí hay algunos trucos que te serán utilies al momento de estar programando.

• Siempre usa nombres significativos para variables, funciones y clases. ¡Es como ponerle un buen título a un libro!. Ayuda a otros (¡y a ti en el futuro!) a entender rápidamente qué hace tu código. Evita nombres como a, x, o z Por ejemplo totalDeClientes es mucho mejor que tc.
• Comenta tu código, pero solo donde el propósito del código no es obvio por sí mismo. Los comentarios deben explicarte el "por qué" o la lógica compleja, no el "qué" que se puede ver en el código. Evita comentar cada línea; ¡es excesivo y hace que el código sea más difícil de leer! Usa comentarios para explicar soluciones a problemas complejos o la razón detrás de decisiones no obvias.
• Se consistente con tu estilo de código. Elige un estilo de codificación y apégate a él. Esto hace que tu código sea más predecible y fácil de leer para todos en el equipo. Por ejemplo Si empiezas a nombrar tus variables privadas con un guión bajo _variablePrivada, hazlo en todo tu proyecto.
• Escribe código conciso. Si puedes decir algo en menos líneas sin sacrificar la claridad, hazlo. Reduce la sobrecarga cognitiva al leer código y a menudo mejora el rendimiento del programa.
• Prueba tu código a menudo y en diferentes escenarios. No esperes hasta el final. Te ayuda a atrapar errores temprano y asegura que tu código funcione como se espera en todas las situaciones. Evita el pensamiento de "lo arreglaré después". ¡A veces, "después" nunca llega! Implementa pruebas unitarias para funciones críticas y verifica tu código después de cada cambio significativo.

Resumen

• El compilador de C# ignora los espacios en blanco, como el retorno de carro, el espacio, la nueva línea y el tab.
• Una declaración simple termina con un punto y coma (;). Un bloque comienza y termina con un par de llaves coincidentes ({}).
• Los identificadores de C# distinguen entre mayúsculas y minúsculas.
• C# admite comentarios de una sola línea (//...), delimitados (/*...*/) y comentarios de documentación (///).