C#: guía rápida de sintaxis

C# dispone de distintos tipos para representar texto, números, valores lógicos y otros datos. Elegir un tipo adecuado ayuda a expresar mejor la intención del programa.

También podemos utilizar varcuando el compilador puede inferir claramente el tipo a partir del valor asignado.

var nombre="Ana";
var edad=30;

varno convierte C# en un lenguaje dinámico: la variable sigue teniendo un tipo concreto determinado en tiempo de compilación.

Arrays

Un array almacena una cantidad fija de elementos del mismo tipo.

int[] notas={ 7, 8, 5, 9}; Console.WriteLine(notas[0]);
Console.WriteLine(notas.Length);

List<T>

Una lista permite añadir y eliminar elementos dinámicamente y es una de las colecciones más utilizadas en aplicaciones .NET.

var lenguajes=new List<string>
{ "C#", "Python", "Java"}; lenguajes.Add("JavaScript"); Console.WriteLine(lenguajes.Count);

Dictionary<TKey,TValue>

Los diccionarios almacenan pares clave-valor y permiten localizar información mediante una clave.

var alumno=new Dictionary<string, string>
{ ["nombre"]="Lucía", ["curso"]="Programación"}; Console.WriteLine(alumno["nombre"]);

Antes de acceder directamente a una clave, conviene comprobar si existe cuando los datos pueden ser variables.

if (alumno.TryGetValue("curso", out string? curso))
{ Console.WriteLine(curso);}

for

forresulta útil cuando necesitamos controlar explícitamente un contador.

for (int i=0; i < 5; i++)
{ Console.WriteLine(i);}

foreach

foreachresulta especialmente cómodo para recorrer colecciones.

var nombres=new List<string>{ "Ana", "Luis", "Marta"}; foreach (string nombre in nombres)
{ Console.WriteLine(nombre);}

while

whilerepite un bloque mientras la condición siga siendo verdadera.

int contador=1; while (contador <=5)
{ Console.WriteLine(contador); contador++;}

Conviene comprobar que la condición pueda llegar a ser falsa para evitar bucles infinitos.

Una clase define la estructura y el comportamiento de los objetos que se crean a partir de ella.

public class Alumno
{ public string Nombre{ get; set;}=""; public int Nota{ get; set;} public bool EstaAprobado() { return Nota >=5;}}

Crear y utilizar un objeto:

var alumno=new Alumno
{ Nombre="Carlos", Nota=8}; Console.WriteLine(alumno.Nombre);
Console.WriteLine(alumno.EstaAprobado());

Una interfaz define un contrato que una clase debe cumplir. Esto permite trabajar con comportamientos sin depender directamente de una implementación concreta.

public interface INotificacion
{ void Enviar(string mensaje);} public class EmailNotificacion : INotificacion
{ public void Enviar(string mensaje) { Console.WriteLine($"Email:{mensaje}");}}

Las interfaces son especialmente útiles cuando distintas clases deben ofrecer una misma operación con implementaciones diferentes.

C# moderno permite indicar si una referencia puede contener null. Esto ayuda a detectar posibles problemas antes de ejecutar el programa.

string? segundoNombre=null; if (segundoNombre is not null)
{ Console.WriteLine(segundoNombre.Length);}

También podemos utilizar el operador de coalescencia nula:

string nombreMostrado=segundoNombre ?? "Sin segundo nombre";

Las expresiones lambda permiten representar funciones breves de forma compacta. Aparecen con frecuencia en LINQ y en muchas APIs de .NET.

Func<int, int> cuadrado = numero => numero * numero;
Console.WriteLine(cuadrado(5));

En una consulta LINQ:

var pares=numeros.Where(n=> n % 2==0);

La parte situada a la izquierda de =>representa los parámetros y la parte derecha expresa la operación que se ejecuta.

Crea una pequeña aplicación que almacene productos con nombre, precio y stock.

El ejercicio debería permitir:

1. Crear una clase Producto.
2. Crear una lista de productos.
3. Mostrar todos los productos.
4. Filtrar los productos con stock disponible.
5. Ordenarlos por precio.
6. Calcular el valor total del stock.

Una posible base:

public class Producto
{
    public string Nombre { get; set; } = "";
    public decimal Precio { get; set; }
    public int Stock { get; set; }
}

var productos = new List<Producto>
{
    new() { Nombre = "Teclado", Precio = 45.90m, Stock = 8 },
    new() { Nombre = "Ratón", Precio = 22.50m, Stock = 0 },
    new() { Nombre = "Monitor", Precio = 189.00m, Stock = 4 }
};

var disponibles = productos
    .Where(p => p.Stock > 0)
    .OrderBy(p => p.Precio);

foreach (var producto in disponibles)
{
    Console.WriteLine($"{producto.Nombre} - {producto.Precio:C}");
}

Para completar el ejercicio, calcula también el valor total del inventario:

decimal valorInventario = productos
    .Sum(p => p.Precio * p.Stock);

Console.WriteLine($"Valor del inventario: {valorInventario:C}");

Este ejercicio permite combinar clases, colecciones, propiedades, LINQ y salida formateada.

• Utiliza nombres claros para clases, métodos, variables y propiedades.
• Evita clases y métodos con demasiadas responsabilidades.
• Utiliza tipos que representen correctamente los datos.
• Gestiona la nulabilidad de forma explícita.
• Captura excepciones concretas cuando realmente puedas tratarlas.
• Utiliza LINQ cuando mejore la legibilidad, no únicamente para escribir menos código.
• Evita duplicar lógica que pueda extraerse a un método o componente reutilizable.
• No almacenes claves, contraseñas ni secretos directamente en el código.
• Separa la lógica de negocio de presentación e infraestructura cuando la aplicación crezca.
• Escribe código pensando también en quien tendrá que mantenerlo después.

Una aplicación mantenible no depende únicamente de que el código funcione: también necesita ser comprensible, comprobable y fácil de modificar.

Esta guía está pensada como recurso de consulta y apoyo al aprendizaje. Para profundizar en las características del lenguaje y en las APIs del ecosistema .NET, conviene consultar la documentación oficial de Microsoft.

• Documentación oficial de C#
• Recorrido por C#
• LINQ en C#