C#

Desde los fundamentos del lenguaje hasta LINQ, async/await y el ecosistema .NET; características modernas y buenas prácticas para aplicaciones listas para producción.

¿Qué es C#?

C# es un lenguaje de tipado estático desarrollado por Microsoft que combina características orientadas a objetos y funcionales. Con .NET 8 es multiplataforma (Windows, Linux, macOS) y se utiliza para APIs web, aplicaciones de escritorio, servicios en la nube, trabajos en segundo plano y juegos (Unity) en un amplio rango.

Ecosistema: ASP.NET Core (web), Entity Framework Core (acceso a datos), xUnit/NUnit (pruebas), NuGet (gestión de paquetes) y la CLI de dotnet (línea de comandos).

TL;DR

C# moderno: records, pattern matching, async/await y span/memory para rendimiento.
REST rápidas con Minimal APIs; CRUD eficiente y LINQ con EF Core.
Arquitectura en capas + inyección de dependencias para un diseño testeable.

Fundamentos del lenguaje

Los fundamentos de la sintaxis de C#, el sistema de tipos y el flujo de control. El primer paso para comprender la lógica del lenguaje.

Introducción a C# y al ecosistema .NET

11 enero 2026 • Fundamentos del lenguaje

C# es un lenguaje moderno, seguro y orientado a objetos. Con el ecosistema .NET es posible desarrollar aplicaciones web, móviles, de escritorio y juegos.

C# Fundamentos de C#

Leer →

Primer proyecto en C#

11 enero 2026 • Fundamentos del lenguaje

Primera aplicación de consola en C# con Visual Studio 2022: uso de WriteLine, ReadKey y ReadLine.

Leer →

Tipos de datos básicos en C#

11 enero 2026 • Fundamentos del lenguaje

Tipos de datos básicos en C#: numéricos, de texto, lógicos, orientados a objetos y anulables.

C# Fundamentos de C# Variables

Leer →

Estructura de sintaxis de C#

13 enero 2026 • Fundamentos del lenguaje

Aprende los fundamentos de la sintaxis de C#, incluyendo bloques de código, comentarios y reglas de nombrado de variables.

Leer →

Operadores y expresiones en C#

13 enero 2026 • Fundamentos del lenguaje

Operadores y expresiones en C#: uso de operadores aritméticos, de comparación, lógicos, de incremento/decremento, ternario y null-coalescing.

Leer →

Estructuras condicionales en C# (if, else, switch)

13 enero 2026 • Fundamentos del lenguaje

Estructuras de decisión en C#: aprende a usar if, else if, else y switch para ejecutar acciones diferentes según las condiciones.

C# Sentencia else Sentencia if Sentencia switch

Leer →

En C#, usa class cuando los objetos se identifican por su identidad. Usa record cuando se identifican por sus valores.


// class: basado en identidad
class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var u1 = new User { Name = "Carlos", Age = 30 };
var u2 = new User { Name = "Carlos", Age = 30 };

Console.WriteLine(u1 == u2); // False


// record: basado en valores
record UserRecord(string Name, int Age);

var r1 = new UserRecord("Carlos", 30);
var r2 = new UserRecord("Carlos", 30);

Console.WriteLine(r1 == r2); // True

En C#, usa Any() en lugar de comprobar Count > 0 para saber si una colección tiene elementos. Es más legible y a menudo más eficiente.


// Menos legible
if (items.Count > 0)
{
    Console.WriteLine("Hay elementos");
}

// Uso recomendado
if (items.Any())
{
    Console.WriteLine("Hay elementos");
}

En C#, modificar una colección dentro de un bucle foreach provoca un error en tiempo de ejecución. Se debe recorrer una copia o usar otro tipo de bucle.


// Esto provoca un error
foreach (var item in items)
{
    items.Remove(item);
}

// Enfoque seguro: recorrer una copia
foreach (var item in items.ToList())
{
    items.Remove(item);
}

// Alternativa: usar un bucle for
for (int i = items.Count - 1; i >= 0; i--)
{
    items.RemoveAt(i);
}

Usar DateTime.UtcNow en lugar de DateTime.Now ayuda a evitar errores relacionados con zonas horarias.


// Hora local (depende de la zona horaria del servidor)
DateTime localTime = DateTime.Now;

// Hora universal (recomendado)
DateTime utcTime = DateTime.UtcNow;

Console.WriteLine(localTime);
Console.WriteLine(utcTime);

En C#, evita capturar la Exception general. Captura solo las excepciones que esperas manejar.


// Uso arriesgado: oculta el problema real
try
{
    int number = int.Parse(input);
}
catch (Exception)
{
    Console.WriteLine("Ocurrió un error");
}

// Uso recomendado: excepción específica
try
{
    int number = int.Parse(input);
}
catch (FormatException)
{
    Console.WriteLine("Número no válido");
}

En C#, comprobar solo null o una cadena vacía no es suficiente. Usar string.IsNullOrWhiteSpace() es más seguro.


// Comprobaciones arriesgadas
if (text == null || text == "")
{
    Console.WriteLine("Texto inválido");
}

// Comprobación segura y recomendada
if (string.IsNullOrWhiteSpace(text))
{
    Console.WriteLine("Texto inválido");
}

En C#, cuando hay muchas condiciones, usar un enfoque basado en Dictionary suele ser más claro que un bloque switch largo.


// Enfoque con switch
string GetRoleName(int roleId)
{
    switch (roleId)
    {
        case 1: return "Admin";
        case 2: return "Editor";
        case 3: return "Usuario";
        default: return "Desconocido";
    }
}

// Enfoque con Dictionary
var roles = new Dictionary<int, string>
{
    { 1, "Admin" },
    { 2, "Editor" },
    { 3, "Usuario" }
};

string roleName = roles.TryGetValue(roleId, out var name)
    ? name
    : "Desconocido";

En C#, usa un bucle for en lugar de foreach cuando necesitas el índice o cuando debes modificar la colección de forma controlada.


// foreach: sin índice
foreach (var item in items)
{
    Console.WriteLine(item);
}

// for: cuando se necesita el índice
for (int i = 0; i < items.Count; i++)
{
    Console.WriteLine($"{i}: {items[i]}");
}

// for: más seguro al eliminar elementos
for (int i = items.Count - 1; i >= 0; i--)
{
    items.RemoveAt(i);
}

En C#, el operador ?. permite acceder de forma segura a una propiedad o método. Si el objeto es null, no ocurre ningún error y el resultado también es null.


Person? person = null;

// Forma antigua
string name1 = person != null ? person.Name : null;

// Forma recomendada
string? name2 = person?.Name;

Console.WriteLine(name1); // null
Console.WriteLine(name2); // null

En C#, usa IEnumerable<T> cuando solo necesitas recorrer los datos. Usa IReadOnlyList<T> cuando también necesitas acceder por índice sin modificar la colección.


// Solo recorrer
IEnumerable<int> numbers = new[] { 10, 20, 30 };

foreach (var n in numbers)
{
    Console.WriteLine(n);
}

// Lista de solo lectura con acceso por índice
IReadOnlyList<int> readOnlyList = new List<int> { 10, 20, 30 };

Console.WriteLine(readOnlyList[0]); // 10