Guía de C# y .NET: De 0 a 100

¿Qué es C# y .NET?

C# es un lenguaje de programación tipado estáticamente, multiparadigma, creado por Anders Hejlsberg en Microsoft y lanzado en 2000 como parte de la iniciativa .NET. Su diseño combina la potencia de C++ con la simplicidad de Visual Basic, incorporando características funcionales, orientadas a objetos y de programación asíncrona en un mismo lenguaje.

.NET es el ecosistema: primero fue .NET Framework (solo Windows), luego .NET Core (multiplataforma, open-source, 2016), y desde .NET 5 (2020) es una plataforma unificada que reemplaza ambos. Hoy estamos en .NET 9 (2024), con releases anuales en noviembre.

¿Dónde se usa?

• Web: ASP.NET Core — potencian Stack Overflow, Microsoft, GoDaddy, JetStream
• Juegos: Unity (C# scripting), Godot (C# bindings) — estándar en desarrollo indie
• Desktop/ MAUI: .NET MAUI, WPF, WinForms — aplicaciones nativas Windows/macOS/iOS/Android
• Cloud / Microservicios: Azure Functions, AWS Lambda con .NET, microservicios con gRPC
• Bases de datos: Entity Framework Core, Dapper — ORM y micro-ORM estándar
• Machine Learning: ML.NET, TorchSharp, TensorFlow.NET
• IoT: .NET nanoFramework, Windows IoT, Raspberry Pi con .NET
• CLI / DevOps: PowerShell está escrito en C#, herramientas cross-platform

¿Quién lo usa? Stack Overflow (toda su plataforma), Unity Technologies (motor de juegos), JetBrains (Rider, ReSharper), GoDaddy (hosting), Siemens (automación industrial), Dell (aplicaciones empresariales).

Fuente: Microsoft .NET Docs, C# docs, .NET GitHub

Prerrequisitos

Antes de empezar, necesitas:

• Conocimientos básicos de terminal: navegar directorios, ejecutar comandos, usar un editor de texto
• El lenguaje/herramienta instalado en tu sistema (sigue la sección de Instalación si aún no lo tienes)

Si no cumples algún requisito, no te preocupes: cada sección te guiará paso a paso.

Instalación en todos los entornos

Windows

1. Descarga el instalador desde dotnet.microsoft.com/download
2. Ejecuta el instalador MSI — incluye SDK, runtime, CLI y ASP.NET Core
3. Verifica: abre cmd o PowerShell y ejecuta dotnet --version
4. Alternativa vía winget: winget install Microsoft.DotNet.SDK.9
5. Visual Studio: instala Community Edition desde visualstudio.microsoft.com — selecciona carga de trabajo “Desarrollo de .NET” y “ASP.NET y desarrollo web”
6. JetBrains Rider: IDE de pago con soporte nativo .NET (30 días trial)

macOS

• Instalador oficial: descarga .pkg desde dotnet.microsoft.com
• Homebrew: brew install dotnet-sdk
• Visual Studio for Mac (legacy): Microsoft anunció su retiro para 2024, migrar a VS Code + C# Dev Kit o Rider
• Verifica: dotnet --version

Linux (Debian/Ubuntu)

# Añadir repositorio Microsoft (necesario para apt)
wget https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt update
sudo apt install dotnet-sdk-9.0 aspnetcore-runtime-9.0

# Fedora/RHEL
sudo dnf install dotnet-sdk-9.0

SDK de versiones múltiples (no necesita pyenv)

# Simplemente instala múltiples SDKs — coexisten sin problema
dotnet --list-sdks     # 6.0, 7.0, 8.0, 9.0
dotnet --list-runtimes

# El global.json en cada proyecto fija la versión
# {
#   "sdk": { "version": "8.0.400" }
# }

Docker

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY ["MiApp/MiApp.csproj", "MiApp/"]
RUN dotnet restore "MiApp/MiApp.csproj"
COPY . .
WORKDIR "/src/MiApp"
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
WORKDIR /app
COPY --from=build /app .
EXPOSE 8080
ENTRYPOINT ["dotnet", "MiApp.dll"]

Usa imágenes oficiales de mcr.microsoft.com/dotnet. dotnet/aspnet para runtime (~200 MB), dotnet/sdk para build (~800 MB). Multi-stage build reduce drásticamente el tamaño final.

Alias útiles

Añade a tu ~/.bashrc o ~/.zshrc:

alias dn='dotnet'
alias dnb='dotnet build'
alias dnr='dotnet run'
alias dnt='dotnet test'
alias dnp='dotnet publish'
alias dnn='dotnet new'
alias dnl='dotnet list'
alias dnw='dotnet watch'

Fuente: Microsoft .NET install docs, .NET Docker images

Escala de aprendizaje: de 0 a 100

Cada nivel incluye lo que debes saber y un proyecto para fijar los conceptos.

Nivel 0–15: Fundamentos absolutos

Qué aprender:

• Sintaxis básica: Console.WriteLine(), variables, tipos (int, string, double, bool, decimal)
• Control de flujo: if/else if/else, switch (tradicional y expression), for, foreach, while, do-while
• Pattern matching básico: type pattern, switch expression, property pattern
• Arrays y List<T>: acceso por índice, Add(), Remove(), Count
• Métodos: static, parámetros, return, sobrecarga
• Paradigmas: qué significa multiparadigma, diferencia entre imperativo, POO y funcional
• Conceptos clave: diferencia entre value type (int, struct) y reference type (class, string). string es inmutable — cada concatenación crea una nueva. var infiere el tipo pero es tipado estático. using para recursos.

Proyecto: Calculadora CLI — suma, resta, multiplica, divide. Bucle while para repetir. Manejo de división por cero con try/catch. Menú con switch expression. Pattern matching para clasificar resultados. Muestra resultados con formato $"Resultado: {resultado:F2}".

Nivel 15–30: POO, tipos avanzados y colecciones

Qué aprender:

• Clases: constructores, fields, propiedades ({ get; set; }), métodos
• Encapsulación: private, public, protected, propiedades con lógica
• Namespaces, using (global, static, alias), file-scoped namespaces
• enum para constantes con nombre
• record para datos inmutables (C# 9+)
• struct para tipos de valor pequeños
• Tipos de datos: value types vs reference types, built-in (int, long, float, double, decimal, char, bool), nullable value types (int?), nullable reference types (string?), var, dynamic, object
• string: inmutabilidad, Split(), Join(), Replace(), Contains(), StringBuilder
• Arrays: multidimensional, jagged, covarianza
• Colecciones: List<T>, Dictionary<K,V>, HashSet<T>, Queue<T>, Stack<T>
• DateTime y TimeSpan
• Conceptos clave: readonly vs const. Boxing/unboxing — cuándo ocurre y cómo evitarlo. Stack vs heap. Propiedades auto-implementadas. Inicializadores de objeto.

Proyecto: Gestor de tareas CLI — clase Tarea con Id, Titulo, Completada, FechaCreacion. List<Tarea> como almacenamiento. Dictionary<string, Tarea> para búsquedas rápidas. Comandos: add, list, done, delete. Persistencia con System.Text.Json. Switch expression para procesar comandos. Nullable reference types para manejar valores opcionales.

Nivel 30–45: Herencia, interfaces, LINQ, archivos y algoritmos

Qué aprender:

• Herencia: class Derivada : Base, base(), virtual/override, sealed
• Clases abstractas vs interfaces: cuándo usar cada una
• Interfaces: IComparable<T>, IDisposable, IEnumerable<T>, interfaces propias
• LINQ: method syntax (Where, Select, OrderBy, GroupBy, Join, Aggregate) y query syntax
• Delegados: Func<>, Action<>, Predicate<>
• Lambdas: (x, y) => x + y, lambdas estáticas y naturales
• Sistema de archivos: System.IO (File, FileInfo, Directory, Path), StreamReader/Writer, FileStream
• Algoritmos: Array.Sort (Introsort), List.Sort, BinarySearch, Comparer<T>, Comparison<T>
• Big O de colecciones: List<T>, Dictionary<K,V>, HashSet<T>, SortedDictionary<K,V>, SortedSet<T>, PriorityQueue<T>
• Conceptos clave: IEnumerable<T> es lazy — no se ejecuta hasta que iteres. LINQ Where/Select no modifican la colección original. Las interfaces permiten polimorfismo sin herencia. IDisposable + using para recursos no gestionados.

Proyecto: Sistema de inventario — clases Producto, Inventario con List<Producto>. Interfaz IAlmacenable. LINQ para búsquedas (Where, FirstOrDefault, OrderBy, GroupBy). IComparable<Producto> y Comparer<T> para ordenación. Serialización JSON a archivo con System.Text.Json. BinarySearch para búsqueda eficiente.

Nivel 45–60: Async, genéricos y testing

Qué aprender:

• async/await: Task, Task<T>, WhenAll, WhenAny
• HttpClient para peticiones web
• Genéricos: clases y métodos genéricos, constraints (where T : class)
• Pattern matching: switch expressions, property patterns, type patterns
• Nullable reference types: string?, ??, ?., ??=
• Testing: xUnit, NUnit, MSTest — [Fact], [Theory], Assert
• Conceptos clave: async es “I/O-bound” — no crea hilos nuevos, usa el threadpool eficientemente. Evita .Result y .Wait() (deadlock). Los nullable reference types son una feature de análisis en compilación, no en runtime. Pattern matching hace el código más legible que if/else anidados.

Proyecto: Cliente de clima API — llama a OpenWeatherMap o API similar con HttpClient. Deserializa JSON response con System.Text.Json. Tests unitarios con xUnit (usa ITestOutputHelper para debug). CancellationToken para timeout. Genéricos para un IRepositorio<T> base. Pattern matching para categorizar condiciones climáticas.

Nivel 60–75: ASP.NET Core, EF Core, archivos y serialización

Qué aprender:

• Minimal APIs (C# 6+): app.MapGet/MapPost/MapPut/MapDelete
• Inyección de dependencias (DI): AddScoped, AddTransient, AddSingleton
• Entity Framework Core: DbContext, DbSet, migraciones, LINQ queries
• Modelos con required (C# 11), init properties, data annotations
• Middleware pipeline: logging, autenticación, CORS
• Configuración: appsettings.json, IOptions<T>, environment variables
• Sistema de archivos avanzado: FileStream async, StreamReader/Writer async, FileSystemWatcher
• Serialización: System.Text.Json (con Source generators), CSV con CsvHelper, YAML con YamlDotNet
• Compresión: System.IO.Compression (ZipArchive, GZipStream, DeflateStream)
• Conceptos clave: DI es nativa en ASP.NET Core — no necesitas contenedor externo. EF Core usa change tracking — AsNoTracking() para solo lectura. Las migraciones generan SQL, revísalo antes de aplicarlo en producción. Los middlewares son como tuberías (pipeline de request).

Proyecto: API de recetas — Minimal API con endpoints CRUD para recetas e ingredientes. EF Core + SQLite. Migraciones. DI para servicios y repositorios. Búsqueda por ingrediente con LINQ. Exportación a CSV con CsvHelper. Importación desde YAML con YamlDotNet. Compresión de imágenes con GZipStream.

Nivel 75–90: SignalR, Dapper, multimedia y producción

Qué aprender:

• SignalR: Hubs, Clients.All, grupos, escalabilidad con Redis backplane
• Dapper: queries SQL manuales, Query<T>, Execute, multi-mapping
• Docker: Dockerfile multi-stage, docker-compose con app + db + redis
• Caching: IMemoryCache, IDistributedCache con Redis
• Background services: BackgroundService para tareas programadas
• Health checks: AddHealthChecks() para monitoreo
• OpenAPI/Swagger: documentación automática de endpoints
• Multimedia: SkiaSharp (gráficos 2D multiplataforma), ImageSharp (procesamiento de imágenes), OpenTK (OpenGL), NAudio (audio), OpenCVSharp (visión artificial)
• Conceptos clave: SignalR escala con un backplane (Redis, Azure SignalR Service). Dapper es 10-50x más rápido que EF Core para lecturas simples. SkiaSharp funciona en Windows, Linux, macOS y mobile. ImageSharp es puro .NET sin dependencias nativas. BackgroundService es la forma correcta de ejecutar tareas en background. Los health checks permiten a Kubernetes/orquestadores saber si la app está viva.

Proyecto: Dashboard de monitorización en tiempo real — API que recolecta métricas del sistema (CPU, RAM, disco). SignalR para streaming de métricas a clientes web. Dapper para almacenar histórico en PostgreSQL. BackgroundService que recolecta métricas cada 5 segundos. Docker Compose (api + postgres + redis). Health checks + Swagger. Generación de gráficos en tiempo real con SkiaSharp.

Nivel 90–100: Arquitectura y sistemas distribuidos

Qué aprender:

• Arquitectura limpia / hexagonal en .NET: separación en capas (Domain, Application, Infrastructure, API)
• gRPC: servicios con protobuf, streaming bidireccional, Grpc.Net.Client
• RabbitMQ / Azure Service Bus: mensajería entre microservicios
• Polly: resiliencia (retry, circuit breaker, timeout, bulkhead)
• OpenTelemetry: distributed tracing, métricas, logs
• Native AOT: dotnet publish -aot, aplicaciones sin runtime
• Source generators: metaprogramación en compilación
• Performance: BenchmarkDotNet para benchmarks, Memory diagnoser, Span<T> y Memory<T> para evitar allocations
• Conceptos clave: Native AOT produce binarios de ~2-3 MB que arrancan en milisegundos (ideal para serverless/containers). Span<T> permite manipular memoria sin copias ni GC allocations. Polly con circuit breaker evita cascading failures. OpenTelemetry es el estándar para observabilidad.

Proyecto: Sistema de notificaciones distribuidas — microservicios con Clean Architecture. gRPC para comunicación interna. RabbitMQ como event bus. SignalR como BFF para clientes. Polly para resiliencia en llamadas externas. OpenTelemetry (Jaeger + Prometheus). Native AOT para el servicio de notificaciones. BenchmarkDotNet para asegurar rendimiento.

Fuente: ASP.NET Core docs, Clean Architecture (Steve Smith), gRPC for .NET, Polly docs

Primeros pasos y configuración del entorno

Si prefieres ver directamente el “Hola Mundo” en C#, consulta El Atlas del Hola Mundo.

Crear un proyecto nuevo

dotnet new console -o MiApp     # App de consola
dotnet new webapi -o MiApi       # ASP.NET Core Web API
dotnet new mvc -o MiMvc          # ASP.NET Core MVC
dotnet new sln                   # Solución (SLN) para múltiples proyectos

Program.cs con top-level statements (C# 9+)

// Program.cs — ya no necesitas class Program ni Main
using System;
using System.Linq;

string nombre = "Mundo";
Console.WriteLine($"Hola {nombre}!");

int[] numeros = [1, 2, 3, 4, 5];
var pares = numeros.Where(n => n % 2 == 0);
Console.WriteLine(string.Join(", ", pares));

Estructura de proyecto (csproj)

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Dapper" Version="2.1.28" />
  </ItemGroup>
</Project>

• Nullable: activa nullable reference types
• ImplicitUsings: using System;, using System.Linq;, etc. automáticos
• PackageReference: paquetes NuGet

NuGet — gestión de paquetes

dotnet add package Dapper
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Newtonsoft.Json
dotnet list package         # ver paquetes instalados
dotnet remove package Dapper

Editores recomendados

Los IDEs y editores más usados son VSCode, JetBrains y Neovim. Extensiones y configuraciones recomendadas.

Configuración inicial del proyecto

dotnet new console -o MiApp --use-program-main
cd MiApp
dotnet add package FluentAssertions
dotnet new tool-manifest
dotnet tool install dotnet-format

Archivo Directory.Build.props (configuración compartida entre proyectos):

<Project>
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
</Project>

Fuente: .NET CLI docs, NuGet docs

Paradigmas de programación

C# es multiparadigma: puedes escribir POO, funcional, imperativo, async y reactivo, a menudo combinándolos en un mismo proyecto.

POO puro

En C# todo es un objeto. Hasta int tiene métodos:

int n = 42;
Console.WriteLine(n.ToString("X"));    // "2A"
Console.WriteLine(n.GetHashCode());    // 42

Toda clase deriva de object. Los value types heredan de ValueType → object. La herencia es simple (una clase base), pero puedes implementar múltiples interfaces.

Funcional

LINQ trajo map/filter/reduce, inmutabilidad con record, funciones de primera clase y pattern matching:

// LINQ = composición de funciones
var nums = Enumerable.Range(1, 100);
var resultado = nums
    .Where(n => n % 2 == 0)
    .Select(n => n * n)
    .Aggregate((a, b) => a + b);

// Tuples con nombre
(int Suma, int Prod) Op(int a, int b) => (a + b, a * b);
var r = Op(3, 4);
Console.WriteLine($"{r.Suma}, {r.Prod}");  // 7, 12

// Pattern matching como expresión
string Clasificar(int edad) => edad switch
{
    < 13 => "Niño",
    >= 13 and < 20 => "Adolescente",
    _ => "Adulto"
};

// Record: inmutabilidad e igualdad estructural
public record Persona(string Nombre, int Edad);
var p1 = new Persona("Ana", 30);
var p2 = p1 with { Edad = 31 };  // Copia inmutable, no muta p1

Imperativo

Bucles, statements y mutación explícita cuando el problema lo requiere:

int suma = 0;
for (int i = 0; i <= 100; i++)
    if (i % 2 == 0) suma += i;

Async-first

C# fue pionero en hacer async parte del lenguaje con async/await. Toda API moderna de .NET expone versiones async:

string data = await File.ReadAllTextAsync("file.txt");
var json = await httpClient.GetStringAsync(url);
var users = await db.Usuarios.ToListAsync();

No hay threads bloqueados durante la espera — el compilador transforma el método en una máquina de estados.

Reactivo (Rx.NET / System.Reactive)

System.Reactive implementa el patrón Observer con streams y LINQ-style queries sobre eventos:

dotnet add package System.Reactive

using System.Reactive.Linq;

var ticks = Observable.Interval(TimeSpan.FromSeconds(1))
    .Where(t => t % 2 == 0)
    .Subscribe(t => Console.WriteLine($"Tick {t}"));

// Combinar streams
var clicks = Observable.FromEventPattern<EventArgs>(btn, "Click");
var moves = Observable.FromEventPattern<EventArgs>(btn, "MouseMove");
var merged = clicks.Merge(moves);

Útil para UI, tiempo real y pipelines de datos asíncronos.

Fuente: Functional C#, Rx.NET, ReactiveX

Tipos de datos y variables

Sistema de tipos

¿Qué es?

C# tiene tipado estático fuerte: el tipo de cada variable se conoce en tiempo de compilación y no se realizan conversiones implícitas entre tipos incompatibles. Es como una caja etiquetada: sabes exactamente qué contiene sin necesidad de abrirla.

El sistema de tipos es nominal (el nombre del tipo determina la compatibilidad), a diferencia del duck typing de Python o el structural typing de TypeScript.

🔗 Wikipedia — Tipado estático, Microsoft — C# type system

Sintaxis básica

int x = 42;                    // Tipado estático: x siempre es int
// x = "hola";                 // ❌ Error de compilación
var y = 42;                    // Inferencia: y es int
dynamic z = 42;                // Dynamic: tipo resuelto en runtime
z = "texto";                   // OK — dynamic permite cambio de tipo

🧪 Cómo probarlo

// En xUnit
[Fact]
public void Tipado_estatico_no_permite_cambio()
{
    int x = 42;
    Assert.Equal(42, x);
    // x = "texto";  // No compila
}

[Fact]
public void Dynamic_permite_cambio()
{
    dynamic d = 42;
    Assert.Equal(42, d);
    d = "texto";
    Assert.Equal("texto", d);
}

💡 Memoria y rendimiento

• Tipado estático: el compilador genera el código máquina exacto para cada tipo — sin overhead en runtime
• var es azúcar sintáctico: no afecta al rendimiento, es idéntico a declarar el tipo explícito
• dynamic usa DLR (Dynamic Language Runtime) — añade overhead de resolución en runtime
• object requiere boxing/unboxing para value types

✅ Buenas prácticas

• ✅ Usa var cuando el tipo sea obvio por la derecha (var dict = new Dictionary<string, int>())
• ❌ No abuses de dynamic — pierdes seguridad de tipos, IntelliSense y rendimiento
• ❌ No uses var cuando oscurece la legibilidad (var x = ObtenerValor())

🏗️ Metodología

• En APIs y interfaces públicas, prefiere tipos explícitos sobre var
• En código interno (métodos privados/locales), var mejora la legibilidad
• dynamic es útil para interop con COM, JSON dinámico o lenguajes dinámicos

🔗 Para saber más

• Microsoft — Implicitly typed local variables
• Microsoft — dynamic type

Value types vs Reference types

¿Qué es?

C# divide todos los tipos en dos categorías fundamentales. Los value types (struct) almacenan el valor directamente en la pila (o inline en el heap). Los reference types (class) almacenan una referencia al objeto en el heap, gestionado por el garbage collector.

Analogía: un value type es como una hoja de papel con el número escrito; un reference type es como la dirección de una casa — todos los que tienen la dirección ven la misma casa.

🔗 Microsoft — Value types, Reference types

Sintaxis básica

struct Punto { public int X, Y; }
var p1 = new Punto { X = 1, Y = 2 };
var p2 = p1; p2.X = 99;
Console.WriteLine(p1.X);  // 1 — copia independiente

class Persona { public string? Nombre; }
var a = new Persona { Nombre = "Ana" };
var b = a; b.Nombre = "Juan";
Console.WriteLine(a.Nombre);  // "Juan" — misma referencia

🧪 Cómo probarlo

[Fact]
public void Value_type_copia_independiente()
{
    var p1 = new Punto { X = 1, Y = 2 };
    var p2 = p1;
    p2.X = 99;
    Assert.Equal(1, p1.X);  // No se afecta
}

[Fact]
public void Reference_type_comparte_objeto()
{
    var a = new Persona { Nombre = "Ana" };
    var b = a;
    b.Nombre = "Juan";
    Assert.Equal("Juan", a.Nombre);  // Mismo objeto
}

💡 Memoria y rendimiento

• Value types en stack: asignación y liberación inmediatas (push/pop)
• Reference types en heap: el GC debe recolectarlos — más presión de memoria
• Pasar un struct grande por valor COPIA todo — usar ref o in para evitar copia
• Boxing: un value type convertido a object se COPIA al heap — evítalo en bucles

✅ Buenas prácticas

• ✅ Usa struct para datos pequeños (< 16 bytes) y lógica simple
• ✅ Usa readonly struct para garantizar inmutabilidad
• ⚠️ No pases structs grandes por valor — usa ref o in
• ❌ No hagas structs mutables — causa confusión (las copias no se sincronizan)

🏗️ Metodología

• Value types: números, coordenadas, flags, datos inmutables pequeños
• Reference types: objetos de dominio, servicios, datos que comparten estado
• readonly struct: cuando necesitas rendimiento de value type con seguridad de inmutabilidad

🔗 Para saber más

• Microsoft — Choosing between class and struct
• Microsoft — ref returns and ref locals

Built-in types (tipos primitivos)

¿Qué es?

C# proporciona un conjunto de tipos primitivos que son alias de tipos del sistema (System.Int32, System.Double, etc.). Cada uno tiene un tamaño fijo en memoria y un rango específico.

🔗 Microsoft — Built-in types

Sintaxis básica

int entero = 42;
long largo = 42L;
float flotante = 3.14f;    // Sufijo f
double doble = 3.14;       // Por defecto
decimal dinero = 19.99m;   // Sufijo m — preciso para dinero
char letra = 'A';
bool activo = true;

🧪 Cómo probarlo

[Theory]
[InlineData(42, typeof(int))]
[InlineData(3.14, typeof(double))]
[InlineData(19.99m, typeof(decimal))]
public void Tipos_primitivos_corresponden(dynamic valor, Type tipoEsperado)
{
    Assert.Equal(tipoEsperado, valor.GetType());
}

💡 Memoria y rendimiento

• decimal es más lento que double (~20x) — usa double para cálculos científicos
• float es más rápido que double en GPUs pero menos preciso
• nint se optimiza según plataforma (32/64 bits) — útil para punteros y tamaños
• bool en realidad ocupa 1 byte (no 1 bit) en la mayoría de contextos

✅ Buenas prácticas

• ✅ Usa decimal para dinero y valores financieros
• ✅ Usa double para cálculos científicos y mediciones
• ⚠️ No compares floats con == — usa Math.Abs(a - b) < epsilon
• ❌ No uses float para dinero — la falta de precisión causa errores acumulativos

🏗️ Metodología

• En aplicaciones financieras: decimal para todos los valores monetarios
• En juegos/gráficos: float (las GPUs trabajan en float32)
• En ciencia/datos: double (precisión suficiente, buen rendimiento)
• En sistemas embebidos: considera byte/short para ahorrar memoria

🔗 Para saber más

• Microsoft — Floating-point numeric types
• What Every Computer Scientist Should Know About Floating-Point

Nullable types

¿Qué es?

C# tiene dos sistemas de nulabilidad: nullable value types (int?, bool?) desde C# 2, y nullable reference types (string?) desde C# 8. Los primeros son tipos especiales Nullable<T> que envuelven un value type. Los segundos son una característica de análisis de flujo en compilación.

🔗 Microsoft — Nullable value types, Nullable reference types

Sintaxis básica

// Nullable value types
int? edad = null;
edad = 25;
if (edad.HasValue)
    Console.WriteLine(edad.Value);
int definitivo = edad ?? 0;  // Null-coalescing

// Nullable reference types (C# 8+)
#nullable enable
string nombre = "Ana";      // No nullable — no puede ser null
string? apodo = null;       // Nullable — puede ser null
Console.WriteLine(apodo?.Length);  // Safe navigation: null si apodo es null

// Operadores null-condicionales
string? texto = ObtenerTexto();
int? longitud = texto?.Length;     // null si texto es null
string saludo = texto ?? "default"; // Null-coalescing
texto ??= "valor por defecto";     // Null-coalescing assignment

🧪 Cómo probarlo

[Fact]
public void Nullable_value_type_funciona()
{
    int? edad = null;
    Assert.False(edad.HasValue);
    
    edad = 25;
    Assert.True(edad.HasValue);
    Assert.Equal(25, edad.Value);
}

[Fact]
public void Null_coalescing_devuelve_default()
{
    string? texto = null;
    string resultado = texto ?? "default";
    Assert.Equal("default", resultado);
}

💡 Memoria y rendimiento

• int? es Nullable<int> — ocupa ~8 bytes (4 del int + 4 del bool HasValue)
• Nullable reference types son solo análisis en compilación — sin impacto en runtime
• ?. (null-conditional) genera una rama condicional en IL
• ?? (null-coalescing) genera una comparación y salto

✅ Buenas prácticas

• ✅ Habilita Nullable en todos los proyectos nuevos (<Nullable>enable</Nullable>)
• ✅ Usa ?? sobre operador ternario cuando sea posible
• ⚠️ No uses ! (null-forgiving operator) a menos que estés seguro — silencia warnings reales
• ❌ No ignores los warnings de nullabilidad — son bugs potenciales

🏗️ Metodología

• Public APIs: prefiere no retornar null — usa Option<T> o pattern Result<T>
• Bases de datos: usa ?? para valores por defecto cuando leas columnas nullables
• Deserialización JSON: los campos opcionales deben ser string?, los requeridos string

🔗 Para saber más

• Microsoft — Nullable reference types tutorial
• Nullable migration strategies

string e inmutabilidad

¿Qué es?

string en C# es una secuencia inmutable de caracteres Unicode (UTF-16). Cada operación que parece modificar un string crea uno nuevo en el heap. Es un reference type, pero se comporta como value type en cuanto a semántica de copia (inmutable).

🔗 Microsoft — string

Sintaxis básica

string s = "Hola";
string t = s;
s += " Mundo";        // Crea NUEVA cadena
Console.WriteLine(t);  // "Hola" — inmutable

// Concatenación eficiente
var sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
    sb.Append(i);
string resultado = sb.ToString();

// Raw string literals (C# 11)
string json = """
{
    "nombre": "Ana",
    "edad": 30
}
""";

// Interpolación
int edad = 30;
string msg = $"Tiene {edad} años";

🧪 Cómo probarlo

[Fact]
public void String_es_inmutable()
{
    string s = "Hola";
    string t = s;
    s += " Mundo";
    Assert.Equal("Hola", t);  // t no cambia
}

[Fact]
public void StringBuilder_es_eficiente()
{
    var sb = new StringBuilder();
    for (int i = 0; i < 100; i++)
        sb.Append(i);
    Assert.Equal(100, sb.Length);
}

💡 Memoria y rendimiento

• Concatenación con + en bucles es O(n²) — crea n cadenas intermedias
• StringBuilder es O(n) — reusa un buffer interno que crece al doble
• String interning: las cadenas literales iguales comparten la misma memoria
• string.IsNullOrEmpty() vs str == "" — prefiere el método estático

✅ Buenas prácticas

• ✅ Prefiere $"" (interpolación) sobre string.Format() o concatenación con +
• ✅ Usa StringBuilder para más de 3-4 concatenaciones o en bucles
• ⚠️ No uses + dentro de bucles con strings
• ❌ No uses string.Compare() cuando puedas usar == (salvo que necesites orden cultural)

🏗️ Metodología

• Para manipulación intensiva de texto: StringBuilder o Span<char>
• Para parsing: ReadOnlySpan<char> evita allocaciones
• Para datos internacionales: usa StringComparison.InvariantCulture o Ordinal

🔗 Para saber más

• Microsoft — Best Practices for Using Strings
• StringBuilder docs

Colecciones

¿Qué es?

Las colecciones en C# son contenedores tipados para almacenar y manipular grupos de objetos. La mayoría viven en System.Collections.Generic y ofrecen diferentes garantías de rendimiento y ordenación.

🔗 Microsoft — Collections

Sintaxis básica

// List<T> — array dinámico
var lista = new List<int> { 1, 2, 3 };
lista.Add(4); lista.RemoveAt(0);

// Dictionary<K,V> — tabla hash O(1)
var dict = new Dictionary<string, int>
{
    ["Ana"] = 30, ["Juan"] = 25
};
dict.TryGetValue("Ana", out int edad);

// HashSet<T> — conjunto único O(1)
var set = new HashSet<int> { 1, 2, 3, 3, 3 };
Console.WriteLine(set.Count);  // 3

// Queue<T> — FIFO
var q = new Queue<string>();
q.Enqueue("primero"); q.Enqueue("segundo");
Console.WriteLine(q.Dequeue());  // "primero"

// Stack<T> — LIFO
var p = new Stack<int>();
p.Push(1); p.Push(2);
Console.WriteLine(p.Pop());  // 2

// Collection expressions (C# 12)
List<int> nums = [1, 2, 3];

🧪 Cómo probarlo

[Fact]
public void HashSet_elimina_duplicados()
{
    var set = new HashSet<int> { 1, 2, 2, 3 };
    Assert.Equal(3, set.Count);
}

[Fact]
public void Dictionary_contiene_clave()
{
    var dict = new Dictionary<string, int> { ["Ana"] = 30 };
    Assert.True(dict.ContainsKey("Ana"));
    Assert.False(dict.ContainsKey("Luis"));
}

[Fact]
public void Queue_es_FIFO()
{
    var q = new Queue<string>();
    q.Enqueue("primero"); q.Enqueue("segundo");
    Assert.Equal("primero", q.Dequeue());
    Assert.Equal("segundo", q.Dequeue());
}

💡 Memoria y rendimiento

*O(n) cuando el array interno necesita redimensionarse.

✅ Buenas prácticas

• ✅ Prefiere List<T> sobre ArrayList (sin boxing)
• ✅ Usa TryGetValue sobre ContainsKey + [] en Dictionary (mitad de búsquedas)
• ⚠️ No modifiques una colección mientras la iteras con foreach
• ❌ No asumas que Dictionary mantiene orden de inserción (usa OrderedDictionary)

🏗️ Metodología

• List<T>: colección ordenada, acceso por índice, iteración frecuente
• Dictionary<K,V>: búsquedas por clave, cachés, índices secundarios
• HashSet<T>: membresía, duplicados, operaciones de conjunto
• Queue<T>: cola de procesamiento, BFS, buffers FIFO
• Stack<T>: backtracking, undo/redo, DFS

🔗 Para saber más

• Microsoft — Collection Data Structures
• Microsoft — Concurrent Collections

Arrays y Span<T>

¿Qué es?

Los arrays en C# son colecciones de tamaño fijo, contiguas en memoria. Span<T> (C# 7.2+) es una ventana sobre memoria contigua — puede apuntar a arrays, memoria nativa o stack — sin copiar datos.

🔗 Microsoft — Arrays, Span<T>

Sintaxis básica

// Arrays — tamaño fijo
int[] arr = [1, 2, 3, 4, 5];
int[,] mat = { { 1, 2 }, { 3, 4 } };
int[][] jagged = [[1, 2], [3, 4, 5], [6]];

// Span<T> — slice sin copia
Span<int> slice = arr.AsSpan(2, 3);
slice[0] = 99;
Console.WriteLine(arr[2]);  // 99 — el array original cambia

// stackalloc — buffer en stack, cero allocations
Span<byte> buffer = stackalloc byte[256];

// Memory<T> — versión heap-safe (para campos async)
Memory<int> mem = arr.AsMemory(2, 3);

🧪 Cómo probarlo

[Fact]
public void Span_modifica_array_original()
{
    int[] arr = [1, 2, 3, 4, 5];
    Span<int> slice = arr.AsSpan(1, 3);
    slice[0] = 99;
    Assert.Equal(99, arr[1]);
}

[Fact]
public void Array_covarianza_solo_reference()
{
    string[] strings = ["a", "b"];
    object[] objects = strings;  // OK
    Assert.Throws<ArrayTypeMismatchException>(() =>
    {
        objects[0] = 42;  // Runtime error
    });
}

💡 Memoria y rendimiento

• Los arrays son el tipo de colección más eficiente en memoria (solo los datos)
• Span<T> elimina copias de memoria — operaciones sobre subconjuntos sin allocations
• stackalloc asigna en stack — ultrafino pero limitado (~1 MB de stack)
• Los arrays multidimensionales [,] son un solo bloque; los jagged [][] son arrays de arrays

✅ Buenas prácticas

• ✅ Usa Span<T> para operaciones de slicing sin copia (procesamiento de texto, buffers)
• ✅ Prefiere stackalloc para buffers temporales pequeños
• ⚠️ Los arrays multidimensionales pueden ser más lentos que jagged arrays
• ❌ No uses Array.Copy cuando Span<T> pueda hacer slicing

🏗️ Metodología

• Arrays: datos de tamaño fijo conocido en tiempo de compilación
• Span<T>: procesamiento de alto rendimiento (parsers, serializadores)
• Memory<T>: operaciones async que necesitan buffer temporal

🔗 Para saber más

• Microsoft — Memory and Span usage guidelines
• Microsoft — Array performance tips

Control de flujo y modularidad

Control de flujo

¿Qué es?

El control de flujo determina el orden en que se ejecutan las instrucciones. C# ofrece condicionales, bucles, saltos y manejo de recursos. Su sintaxis deriva de C, con importantes mejoras como switch expressions, pattern matching y using declarations.

🔗 Microsoft — Statements

Sintaxis básica

if/else y switch:

int edad = 18;
if (edad >= 18)
    Console.WriteLine("Mayor");
else if (edad >= 13)
    Console.WriteLine("Adolescente");
else
    Console.WriteLine("Niño");

// Switch expression (C# 8+)
string tipo = edad switch
{
    < 13 => "Niño",
    >= 13 and < 20 => "Adolescente",
    _ => "Adulto"
};

// Pattern matching
object valor = 42;
string desc = valor switch
{
    int i => $"Entero: {i}",
    string s => $"Texto: {s}",
    null => "Nulo",
    _ => "Otro"
};

// List pattern (C# 11)
int[] nums = [1, 2, 3, 4, 5];
var dl = nums switch
{
    [1, 2, .. var resto] => $"Empieza con 1,2, luego {resto.Length} más",
    [] => "Vacía"
};

Bucles:

for (int i = 0; i < 10; i++) Console.WriteLine(i);
foreach (var n in Enumerable.Range(1, 10)) Console.WriteLine(n);
int j = 0;
while (j < 10) { Console.WriteLine(j); j++; }
int k = 0;
do { Console.WriteLine(k); k++; } while (k < 10);

break, continue, goto:

for (int i = 0; i < 10; i++)
{
    if (i == 3) continue;
    if (i == 7) break;
}

**using y checked/unchecked:**
```csharp
// using declaration — se descarta al salir del ámbito
using var reader = new StreamReader("archivo.txt");

int max = int.MaxValue;
checked  { int r = max + 1; }   // OverflowException
unchecked { int r = max + 1; }  // Silencia overflow

🧪 Cómo probarlo

[Theory]
[InlineData(10, "Niño")]
[InlineData(15, "Adolescente")]
[InlineData(25, "Adulto")]
public void Switch_expression_clasifica_edad(int edad, string esperado)
{
    string tipo = edad switch
    {
        < 13 => "Niño",
        >= 13 and < 20 => "Adolescente",
        _ => "Adulto"
    };
    Assert.Equal(esperado, tipo);
}

[Fact]
public void Pattern_matching_detecta_tipo()
{
    object valor = 42;
    string desc = valor switch
    {
        int i => $"Entero: {i}",
        _ => "Otro"
    };
    Assert.Equal("Entero: 42", desc);
}

💡 Memoria y rendimiento

• Switch expression compila a tablas de salto (jump tables) cuando es posible — O(1)
• Pattern matching con múltiples casos es optimizado por el compilador
• foreach sobre arrays usa GetEnumerator() — sin allocations para arrays
• goto raramente necesario — suele indicar diseño mejorable

✅ Buenas prácticas

• ✅ Prefiere switch expression sobre if/else encadenados para múltiples condiciones
• ✅ Usa pattern matching para reducir verbose if/else + cast
• ⚠️ No anides switch dentro de switch — refactoriza a método separado
• ❌ No uses goto excepto para salir de bucles anidados (raro)

🏗️ Metodología

• Condicionales simples (≤3 ramas): if/else es más legible
• Múltiples condiciones (≥4 ramas): switch expression
• Type checking: pattern matching con switch
• Bucles: for cuando sabes el número de iteraciones; while cuando no; foreach para colecciones

🔗 Para saber más

• Microsoft — Pattern matching
• Microsoft — Iteration statements

Modularidad y organización del código

¿Qué es?

C# organiza el código en namespaces (contenedores lógicos), assemblies (unidades de compilación) y archivos físicos. Los proyectos .NET pueden tener múltiples assemblies que se referencian entre sí.

🔗 Microsoft — Namespaces

Sintaxis básica

Namespaces y usings:

namespace MiApp.Modelos;

using System;
using Proj = MiApp.Models;      // Alias
global using System.Linq;       // C# 10+: aplica a todo el proyecto

File-scoped namespaces (C# 10+):

namespace MiApp.Modelos;
public class Usuario { }

Assemblies:

dotnet new classlib -o MiLib
dotnet add MiApp reference MiLib

Partial class/struct:

// Archivo 1: Usuario.Part1.cs
public partial class Usuario
{
    public string Nombre { get; set; }
}

// Archivo 2: Usuario.Part2.cs
public partial class Usuario
{
    public override string ToString() => $"{Nombre}";
}

🧪 Cómo probarlo

// Verificar que un tipo es accesible desde otro assembly
[Fact]
public void Tipo_publico_es_accesible()
{
    var type = typeof(MiLib.SomeClass);
    Assert.NotNull(type);
}

💡 Memoria y rendimiento

• Los assemblies se cargan en memoria al primer uso (lazy loading)
• global using no afecta al rendimiento — es azúcar de compilación
• partial class no tiene overhead en runtime — se fusiona en compilación

✅ Buenas prácticas

• ✅ Un archivo por tipo (clase/struct/interface), nombrado como el tipo
• ✅ Usa file-scoped namespaces (menos indentación)
• ⚠️ No uses global using para todo — solo para lo que se usa en >80% de archivos
• ❌ No pongas múltiples clases públicas en el mismo archivo (salvo tipos pequeños)

🏗️ Metodología

• Proyectos pequeños (<5 archivos): namespace único o ninguno
• Librerías: namespace = Empresa.Tecnologia.Componente
• Proyectos grandes: separa en assemblies diferentes por capa (API, Dominio, Infraestructura)

🔗 Para saber más

• Microsoft — File-scoped namespaces
• Microsoft — Partial Classes and Methods

Conceptos clave explicados a fondo

CLR, IL, JIT y Garbage Collector

¿Qué es?

C# no se compila a código máquina directamente. El compilador Roslyn genera IL (Intermediate Language). En runtime, el CLR (Common Language Runtime) activa el compilador JIT (Just-In-Time) que traduce IL a código nativo. El GC (Garbage Collector) gestiona la memoria automáticamente.

🔗 Microsoft — CLR

Sintaxis básica

// Tu código C# → IL → JIT → código nativo
int suma = 2 + 2;
// IL: ldc.i4.2 / ldc.i4.2 / add / stloc.0
// x86_64: mov eax, 2 / add eax, 2 / mov [rbp-4], eax

// GC generacional: Gen 0 (objetos nuevos), Gen 1, Gen 2 (longevos)
void EjemploGC()
{
    var temporal = new byte[1024];    // Gen 0
    var cache = new byte[1024 * 1024];  // LOH (> 85KB)
}

JIT vs AOT:

🧪 Cómo probarlo

[Fact]
public void CLR_ejecuta_IL_correctamente()
{
    int suma = 2 + 2;
    Assert.Equal(4, suma);
}

[Fact]
public void LOH_se_usa_para_objetos_grandes()
{
    var grande = new byte[100_000]; // > 85KB → LOH
    Assert.Equal(100_000, grande.Length);
}

💡 Memoria y rendimiento

• GC generacional: Gen 0 se recolecta en ~ms, Gen 2 es costosa (pausa ~100ms)
• LOH (>85KB) no se compacta por defecto — puede fragmentarse
• Native AOT elimina JIT en runtime pero limita la generación de código dinámico
• Tiered compilation: los métodos empiezan con JIT rápido y se re-JITean con optimizaciones si son llamados frecuentemente

✅ Buenas prácticas

• ✅ Evita llamar GC.Collect() en producción
• ✅ Usa Native AOT para serverless y CLIs; JIT para apps que necesitan reflexión pesada
• ⚠️ No asumas que objetos en Gen 0 se recolectan inmediatamente
• ❌ No crees objetos temporales grandes (>85KB) en bucles — llenan LOH rápido

🏗️ Metodología

• Apps web: JIT — necesitas reflexión y generación dinámica
• CLIs/serverless: Native AOT — inicio rápido, menor footprint
• Juegos: ReadyToRun para balance entre inicio y rendimiento

🔗 Para saber más

• Microsoft — Garbage Collection
• Pro .NET Memory Management (Konrad Kokosa)

Value types vs Reference types, Boxing/Unboxing

¿Qué es?

C# divide los tipos en dos categorías: value types (almacenados en stack o inline en heap) y reference types (siempre en heap, GC gestiona). Entender la diferencia es crucial para rendimiento y predictibilidad.

🔗 Microsoft — Value types

Sintaxis básica

// Value type: struct — se copia por valor
struct Punto { public int X { get; set; } public int Y { get; set; } }
var p1 = new Punto { X = 1, Y = 2 };
var p2 = p1;
p2.X = 99;
Console.WriteLine(p1.X);  // 1 — no se afecta

// Reference type: class — se copia la referencia
var persona1 = new Persona { Nombre = "Ana" };
var persona2 = persona1;
persona2.Nombre = "Juan";
Console.WriteLine(persona1.Nombre);  // "Juan" — mismo objeto

// Boxing: value type → object (crea objeto en heap)
int numero = 42;
object obj = numero;               // Boxing
int numero2 = (int)obj;            // Unboxing

// Genéricos evitan boxing
var listaBuena = new List<int>();  // Sin boxing

🧪 Cómo probarlo

[Fact]
public void Struct_se_copia_por_valor()
{
    var p1 = new Punto { X = 1, Y = 2 };
    var p2 = p1;
    p2.X = 99;
    Assert.Equal(1, p1.X);  // p1 no cambia
}

[Fact]
public void List_generica_evita_boxing()
{
    var list = new List<int> { 42 };
    Assert.Equal(42, list[0]); // Sin boxing
}

💡 Memoria y rendimiento

• Value types en stack: sin presión de GC, más rápidos
• Cada boxing aloca en heap y copia — evítalo en bucles calientes
• Structs grandes (>16 bytes) pueden ser más lentos que classes por la copia completa
• Genéricos eliminan boxing — usa List<T> nunca ArrayList

✅ Buenas prácticas

• ✅ Usa struct para datos pequeños (<16 bytes) e inmutables
• ✅ Usa class para la mayoría de tipos (más flexibles, menos copias)
• ⚠️ No pases structs grandes por parámetro sin in (copia completa)
• ❌ No uses colecciones no genéricas (ArrayList, Hashtable) — siempre boxing

🏗️ Metodología

• Datos de valor: struct readonly para coordenadas, vectores, colores
• Entidades/DTOs: class o record (reference type)
• Hot paths: prefiere structs pequeños para reducir presión de GC
• APIs: usa genéricos para evitar boxing en parámetros

🔗 Para saber más

• Microsoft — Boxing and Unboxing

Tipos primitivos, string y colecciones

¿Qué es?

Los tipos primitivos son alias de tipos System.* (int → Int32). string es inmutable. Las colecciones base incluyen arrays, List<T>, Dictionary<,>, HashSet<T>, Queue<T> y Stack<T>.

🔗 Microsoft — Built-in types

Sintaxis básica

// Primitivos
int entero = 42;
double pi = 3.1416;
decimal precio = 19.99m;
bool activo = true;

// string — inmutable
string s1 = "Hola";
s1 += " Mundo";  // Crea NUEVA cadena

// StringBuilder — para mutación eficiente
var sb = new StringBuilder();
for (int i = 0; i < 1000; i++) sb.Append(i);

// Arrays
int[] arr = [1, 2, 3];
Span<int> slice = arr.AsSpan(1, 2);  // Sin copia

// Colecciones genéricas
var lista = new List<int> { 1, 2, 3 };
var dict = new Dictionary<string, int> { ["Ana"] = 30 };
var hashSet = new HashSet<int> { 1, 2, 3 };
var cola = new Queue<string>();
var pila = new Stack<int>();

🧪 Cómo probarlo

[Fact]
public void StringBuilder_es_mas_eficiente_que_concatenacion()
{
    var sb = new StringBuilder();
    for (int i = 0; i < 100; i++) sb.Append(i);
    Assert.Equal(100, sb.Length);
}

[Fact]
public void HashSet_elimina_duplicados()
{
    var set = new HashSet<int> { 1, 1, 2, 3 };
    Assert.Equal(3, set.Count);
}

💡 Memoria y rendimiento

• string inmutable: cada concatenación crea un nuevo objeto — O(n²) en bucles
• StringBuilder usa buffer interno que crece exponencialmente — O(n) en bucles
• String interning: literales iguales comparten la misma memoria
• Colecciones genéricas no generan boxing; las no genéricas sí

✅ Buenas prácticas

• ✅ Usa StringBuilder para múltiples concatenaciones en bucles
• ✅ Prefiere List<T> sobre arrays cuando el tamaño puede cambiar
• ⚠️ No modifiques cadenas en bucles grandes — usa StringBuilder
• ❌ No uses ArrayList, Hashtable — siempre prefiere las versiones genéricas

🏗️ Metodología

• Texto dinámico: StringBuilder para logs, generación de HTML/CSV
• Datos fijos: arrays (tamaño conocido) o ReadOnlySpan<T> para máximo rendimiento
• Lookups frecuentes: Dictionary<K,V> para búsqueda por clave
• Unicidad: HashSet<T> para eliminar duplicados

🔗 Para saber más

• Microsoft — String building
• Microsoft — Collections

POO: clases, interfaces, abstract, sealed, records y structs

¿Qué es?

C# es un lenguaje orientado a objetos con herencia simple de clases e implementación múltiple de interfaces. Soporta clases, structs, records (C# 9+), abstract y sealed para controlar la jerarquía.

🔗 Microsoft — Classes

Sintaxis básica

// Clase con herencia simple
public class Animal { public string Nombre { get; init; } public virtual string HacerSonido() => "..."; }
public class Perro : Animal { public override string HacerSonido() => "Guau"; }

// Interfaz — múltiples implementaciones
public interface IVolador { void Volar(); }
public class Pato : IVolador, INadador { public void Volar() { } public void Nadar() { } }

// Abstract — no instanciable, obliga a implementar
public abstract class Forma { public abstract double Area(); }
public sealed class Circulo : Forma { public double Radio { get; } public override double Area() => Math.PI * Radio * Radio; }

// Record — inmutable, equality por valor (C# 9+)
public record Persona(string Nombre, int Edad);
var p2 = new Persona("Ana", 30) with { Edad = 31 };

// Struct — value type, copia por valor
public readonly struct Coordenadas(double lat, double lon);

🧪 Cómo probarlo

[Fact]
public void Record_equality_por_valor()
{
    var p1 = new Persona("Ana", 30);
    var p2 = new Persona("Ana", 30);
    Assert.Equal(p1, p2);  // True — records comparan por valor
}

[Fact]
public void Clase_sealed_no_puede_heredarse()
{
    var c = new Circulo(5);
    Assert.Equal(Math.PI * 25, c.Area(), precision: 10);
}

💡 Memoria y rendimiento

• record genera Equals/GetHashCode/ToString automáticamente — sin reflexión en runtime
• sealed en métodos permite devirtualización (inline) por el JIT
• struct no genera presión de GC pero se copia al pasar como parámetro
• abstract no tiene overhead directo — solo marca métodos como virtual

✅ Buenas prácticas

• ✅ Usa record para DTOs, eventos, y datos inmutables
• ✅ Usa sealed en clases que no deben heredarse — mejora rendimiento
• ⚠️ No crees jerarquías profundas (>3 niveles) — prefiere composición
• ❌ No uses struct para objetos >16 bytes — la copia es cara

🏗️ Metodología

• Modelos de datos: record (inmutable, value equality)
• Servicios: class con interfaces (dependencias inyectables)
• Configuración: record con init properties
• Hot paths: readonly struct para datos pequeños

🔗 Para saber más

• Microsoft — Records
• Microsoft — Interfaces

Propiedades y fields

¿Qué es?

Las propiedades encapsulan campos con getters/setters. C# ofrece auto-propiedades, init-only setters y required properties. Son la forma canónica de exponer datos en una clase.

🔗 Microsoft — Properties

Sintaxis básica

public class Producto
{
    private decimal _precio;                          // Field privado
    public string Nombre { get; set; }                // Auto-propiedad
    public string Codigo { get; }                     // Solo init en constructor
    public DateTime FechaCreacion { get; init; }      // Init-only (C# 9+)
    public required string SKU { get; init; }         // Required (C# 11)
    public decimal PrecioConIVA => Precio * 1.21m;    // Calculada

    public decimal Precio
    {
        get => _precio;
        set => _precio = value >= 0 ? value 
            : throw new ArgumentException("El precio no puede ser negativo");
    }
}

🧪 Cómo probarlo

[Fact]
public void Propiedad_con_validacion_lanza_excepcion()
{
    var p = new Producto { Nombre = "Test", Precio = 10 };
    Assert.Throws<ArgumentException>(() => p.Precio = -1);
}

💡 Memoria y rendimiento

• Auto-propiedades se compilan a fields con get/set — sin overhead
• Init-only setters se verifican en compilación, no en runtime
• required se valida en compilación con análisis de flujo

✅ Buenas prácticas

• ✅ Usa auto-propiedades para la mayoría de casos
• ✅ Prefiere init sobre set para inmutabilidad
• ⚠️ No agregues lógica pesada en getters — los consumidores no lo esperan
• ❌ No expongas campos públicos — siempre usa propiedades

🏗️ Metodología

• DTOs: auto-propiedades con init
• Entidades: propiedades con lógica de validación
• Config: required properties para asegurar inicialización completa

Delegados, eventos y lambdas

¿Qué es?

Los delegados son types que definen firmas de métodos. Los eventos notifican cambios a suscriptores. Las lambdas son funciones anónimas. C# ofrece delegados predefinidos como Func<>, Action<> y Predicate<>.

🔗 Microsoft — Delegates

Sintaxis básica

// Delegado y lambdas
Func<int, int, int> sumar = (a, b) => a + b;
Action<string> log = msg => Console.WriteLine(msg);
Predicate<int> esPar = x => x % 2 == 0;

// Evento
public class Sensor
{
    public event EventHandler<double>? TemperaturaExcedida;
    private double _temperatura;
    public double Temperatura
    {
        get => _temperatura;
        set { _temperatura = value; if (value > 50) TemperaturaExcedida?.Invoke(this, value); }
    }
}

// Lambda static — no captura variables (C# 9)
Func<int, int, int> sumStatic = static (a, b) => a + b;

🧪 Cómo probarlo

[Fact]
public void Evento_se_dispara_cuando_se_supera_limite()
{
    var sensor = new Sensor();
    double temp = 0;
    sensor.TemperaturaExcedida += (_, t) => temp = t;
    sensor.Temperatura = 55;
    Assert.Equal(55, temp);
}

[Fact]
public void Lambda_static_no_captura_variables()
{
    Func<int, int> f = static x => x * x;
    Assert.Equal(25, f(5));
}

💡 Memoria y rendimiento

• Delegados son reference types — alocan en heap
• Eventos son multicast delegates — mantienen lista de invocación
• Lambdas que capturan variables locales alocan un closure object
• Lambda static (C# 9) evita closure allocation

✅ Buenas prácticas

• ✅ Usa EventHandler<TEventArgs> en vez de delegados personalizados para eventos
• ✅ Prefiere lambda static cuando no captures variables
• ⚠️ No suscribas eventos sin desuscribir — memory leaks
• ❌ No pases lambdas como Expression<> si solo necesitas delegados

🏗️ Metodología

• Notificaciones: eventos con EventHandler<T>
• Callbacks: Func<>/Action<> como parámetros
• Filtros: Predicate<T> o Func<T, bool>
• Hot paths: lambda static para evitar allocations repetidos

LINQ (Language Integrated Query)

¿Qué es?

LINQ permite consultar colecciones, bases de datos y XML con sintaxis integrada en C#. Soporta method syntax (fluent) y query syntax (SQL-like). Todas las operaciones son lazy evaluation hasta que se materializan con ToList()/ToArray().

🔗 Microsoft — LINQ

Sintaxis básica

var nums = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Method syntax (fluent)
var result = nums.Where(n => n % 2 == 0).Select(n => n * 10).OrderByDescending(n => n).Take(3).ToList();

// Query syntax (SQL-like)
var result2 = from n in nums where n % 2 == 0 orderby n descending select n * 10;

// Operadores clave
.Where(n => n > 5).Select(n => new { Valor = n, Cuadrado = n * n })
.Skip(5).Take(5).Chunk(3)
.OrderBy(p => p.Nombre).ThenByDescending(p => p.Edad)
.Count().Sum(p => p.Precio).Average().Aggregate((a, b) => a + b)
.Any(p => p.Edad > 18).All(p => p.Activo).Contains(42)
.Distinct().Union(otra).Intersect(otra).Except(otra)
.GroupBy(p => p.Categoria).Select(g => new { Categoria = g.Key, Total = g.Sum(p => p.Precio) })

// Lazy evaluation
var query = nums.Where(n => n > 3);    // NO se ejecuta aquí
var list = query.ToList();             // Aquí se materializa

🧪 Cómo probarlo

[Fact]
public void LINQ_filtra_y_ordena()
{
    int[] nums = [3, 1, 4, 1, 5];
    var result = nums.Where(n => n > 2).OrderByDescending(n => n).ToList();
    Assert.Equal([5, 4, 3], result);
}

💡 Memoria y rendimiento

• Lazy evaluation evita crear colecciones intermedias innecesarias
• Cada materialización re-ejecuta la query — llama a ToList() una vez y cachea
• Select no aloca hasta materializar
• Operaciones como Count() sin filtro son O(1) para List<T>/arrays

✅ Buenas prácticas

• ✅ Materializa con ToList()/ToArray() si vas a iterar múltiples veces
• ✅ Usa Any() en vez de Count() > 0 para verificar existencia
• ⚠️ No abuses de LINQ en hot paths — foreach explícito es más rápido
• ❌ No llames ToList() antes de filtrar — rompe lazy evaluation

Genéricos, constraints, covarianza/contravarianza

¿Qué es?

Los genéricos permiten definir tipos y métodos parametrizados por tipo. Las constraints restringen qué tipos pueden usarse. Covarianza (out) permite usar tipos derivados; contravarianza (in) permite usar tipos base.

🔗 Microsoft — Generics

Sintaxis básica

// Clase genérica
public class Repositorio<T>
{
    private readonly List<T> _items = [];
    public void Agregar(T item) => _items.Add(item);
    public T Obtener(int index) => _items[index];
}

// Constraints
// where T : class | struct | new() | BaseClass | IInterface | notnull | unmanaged | Enum | Delegate
public class Fabrica<T> where T : new()
{
    public T Crear() => new T();
}

// Covarianza (out): IEnumerable<string> → IEnumerable<object>
IEnumerable<string> cadenas = ["hola"];
IEnumerable<object> objetos = cadenas;

// Contravarianza (in): Action<object> → Action<string>
Action<object> accionObj = obj => Console.WriteLine(obj);
Action<string> accionStr = accionObj;

🧪 Cómo probarlo

[Fact]
public void Repositorio_generico_funciona_con_cualquier_tipo()
{
    var repo = new Repositorio<int>();
    repo.Agregar(42);
    Assert.Equal(42, repo.Obtener(0));
}

💡 Memoria y rendimiento

• Los genéricos se especializan por tipo en JIT — sin boxing ni casting
• Cada tipo cerrado (ej. List<int>) genera código nativo separado
• struct como genérico no aloca en heap si el contenedor es stack-only

✅ Buenas prácticas

• ✅ Usa genéricos para evitar duplicar código con diferentes tipos
• ✅ Documenta constraints con where cláusulas explícitas
• ⚠️ No uses object como parámetro — prefiere genéricos con constraints
• ❌ No especialices genéricos con demasiados tipos cerrados — crece el código nativo

async/await, Task, ValueTask, IAsyncEnumerable

¿Qué es?

async/await permite escribir código asíncrono que no bloquea hilos. Task representa una operación en curso. ValueTask es un struct que evita allocations para resultados síncronos. IAsyncEnumerable<T> permite streams asíncronos con await foreach.

🔗 Microsoft — Async/await

Sintaxis básica

// async/await básico
public async Task<string> ObtenerDatosAsync(string url)
{
    using var client = new HttpClient();
    return await client.GetStringAsync(url);
}

// ValueTask — evita allocation si el resultado es síncrono
public ValueTask<int> ObtenerValorAsync(string key)
{
    if (_cache.TryGetValue(key, out int valor))
        return new ValueTask<int>(valor);   // Sin allocation
    return new ValueTask<int>(CalcularAsync(key));
}

// Múltiples tareas concurrentes
var tareas = Enumerable.Range(0, 10).Select(i => ObtenerDatosAsync($"https://api.example.com/{i}"));
string[] resultados = await Task.WhenAll(tareas);

// Cancelación
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(3));
await Task.Delay(5000, cts.Token);  // Lanza OperationCanceledException

// IAsyncEnumerable<T> — streams asíncronos
public async IAsyncEnumerable<int> GenerarAsync()
{
    for (int i = 0; i < 10; i++) { await Task.Delay(100); yield return i; }
}
await foreach (int num in GenerarAsync()) Console.WriteLine(num);

🧪 Cómo probarlo

[Fact]
public async Task Async_metodo_completa_correctamente()
{
    string result = await ObtenerDatosAsync("https://example.com");
    Assert.NotNull(result);
}

[Fact]
public async Task Cancelacion_lanza_excepcion()
{
    var cts = new CancellationTokenSource();
    cts.Cancel();
    await Assert.ThrowsAsync<OperationCanceledException>(() => 
        Task.Delay(5000, cts.Token));
}

💡 Memoria y rendimiento

• async/await compila a una máquina de estados (state machine) en struct — sin thread
• ValueTask evita allocation de Task cuando el resultado es síncrono
• Task.WhenAll es más eficiente que esperar secuencialmente
• Cada await puede devolver el hilo al pool si la operación no está completa

✅ Buenas prácticas

• ✅ Usa *Async en toda I/O (red, disco, BD) — nunca bloquees con .Result
• ✅ Pasa CancellationToken a todos los métodos async
• ⚠️ No hagas Task.WhenAll con miles de tareas — usa Parallel.ForEachAsync
• ❌ No uses async void excepto en event handlers — las excepciones son inmanejables

Pattern matching

¿Qué es?

El pattern matching permite comprobar la forma de un valor (tipo, propiedades, posición) y extraer datos en una sola expresión. Evolucionó desde C# 7 con type patterns hasta C# 11 con list patterns.

🔗 Microsoft — Pattern matching

Sintaxis básica

object valor = 42;

// Type pattern
if (valor is int entero) Console.WriteLine(entero);

// Switch expression
string desc = valor switch
{
    int i when i > 0 => $"Entero positivo: {i}",
    string s => $"Cadena: {s}",
    null => "Nulo",
    _ => "Otro"
};

// Property pattern
if (valor is string { Length: > 5 } texto) Console.WriteLine($"Largo: {texto}");

// List patterns (C# 11)
int[] nums = [1, 2, 3, 4, 5];
var res = nums switch
{
    [1, 2, .. var resto] => $"Empieza con 1,2, luego {resto.Length} más",
    [var primero, .., var ultimo] => $"Primero: {primero}, último: {ultimo}",
    [] => "Vacía"
};

// Relational patterns (C# 9+)
string Nota(int p) => p switch
{
    >= 90 => "Sobresaliente",
    >= 70 => "Notable",
    >= 50 => "Aprobado",
    < 50 => "Suspenso"
};

🧪 Cómo probarlo

[Theory]
[InlineData(95, "Sobresaliente")]
[InlineData(75, "Notable")]
[InlineData(55, "Aprobado")]
[InlineData(30, "Suspenso")]
public void Pattern_matching_en_notas(int puntuacion, string esperado)
{
    string nota = puntuacion switch
    {
        >= 90 => "Sobresaliente",
        >= 70 => "Notable",
        >= 50 => "Aprobado",
        < 50 => "Suspenso"
    };
    Assert.Equal(esperado, nota);
}

💡 Memoria y rendimiento

• Pattern matching compila a código eficiente — tablas de salto cuando es posible
• Switch expression con patrones es tan rápida como if/else manual
• List patterns tienen overhead mínimo — el compilador optimiza

✅ Buenas prácticas

• ✅ Usa pattern matching para simplificar if/else + cast verbose
• ✅ Prefiere switch expression para múltiples condiciones de tipo
• ⚠️ No hagas pattern matching en objetos grandes en hot paths
• ❌ No uses pattern matching como sustituto de polimorfismo bien diseñado

Nullable reference types

¿Qué es?

Desde C# 8, los tipos referencia pueden ser nullable (string?) o non-nullable (string). El compilador analiza el flujo para prevenir NullReferenceException en tiempo de compilación.

🔗 Microsoft — Nullable reference types

Sintaxis básica

#nullable enable
public class Usuario
{
    public string Nombre { get; set; }   // No nullable
    public string? Email { get; set; }   // Nullable
}

string? texto = ObtenerTexto();
int? longitud = texto?.Length;           // ?. condicional
string saludo = texto ?? "default";      // ?? coalescing
texto ??= "valor";                       // ??= asignación (C# 8+)

void Procesar(string? cadena)
{
    if (cadena is null) return;
    Console.WriteLine(cadena.Length);     // Compilador sabe que no es null
}

// Null-forgiving operator
string nombre = ObtenerNombre()!;         // "Confía en mí, no es null"

🧪 Cómo probarlo

[Fact]
public void Null_coalescing_devuelve_default_cuando_null()
{
    string? texto = null;
    Assert.Equal("default", texto ?? "default");
}

Extension methods y partial classes

¿Qué es?

Los extension methods añaden métodos a tipos existentes sin modificar el tipo original. Son métodos estáticos en clases estáticas con el primer parámetro marcado con this. Las partial classes dividen la definición de una clase en múltiples archivos.

🔗 Microsoft — Extension Methods

Sintaxis básica

// Extension method
public static class StringExtensions
{
    public static bool EsPalindromo(this string texto) { /* ... */ }
    public static string Truncar(this string texto, int maxLength) => 
        texto?.Length > maxLength ? texto[..maxLength] + "..." : texto;
}

// Uso
"Anita lava la tina".EsPalindromo();  // True

// Partial class
// Archivo 1: Persona.Part1.cs
public partial class Persona { public string Nombre { get; set; } }
// Archivo 2: Persona.Part2.cs
public partial class Persona { public override string ToString() => Nombre; }

🧪 Cómo probarlo

[Fact]
public void Extension_method_funciona_en_null()
{
    string? nula = null;
    Assert.Null(nula.Truncar(5));  // Maneja null internamente
}

Top-level statements, global usings y file-scoped namespaces

¿Qué es?

C# 9+ introdujo top-level statements (programa sin class/Main), C# 10+ global usings (importan en todo el proyecto) y file-scoped namespaces (sin llaves). Simplifican drásticamente el boilerplate.

🔗 Microsoft — Top-level statements

Sintaxis básica

// Program.cs — sin class, sin Main
using System;
var numeros = new[] { 1, 2, 3 };
Console.WriteLine(numeros.Sum());
static string Saludar(string nombre) => $"Hola {nombre}";

// GlobalUsings.cs — aplica a TODO el proyecto
global using System;
global using System.Linq;

// File-scoped namespace (C# 10+)
namespace MiApp.Modelos;
public class Usuario { }

🧪 Cómo probarlo

// En proyectos de test, ImplicitUsings ya incluye System, LINQ, etc.
[Fact]
public void Top_level_statements_son_equivalentes()
{
    // El comportamiento es idéntico a tener Program.Main
    Assert.True(true);
}

Source generators (metaprogramación en compilación)

¿Qué es?

Los source generators (C# 9+) son piezas de código que se ejecutan durante la compilación para generar código fuente adicional. Son la alternativa moderna a T4 templates y Reflection pesada. El compilador Roslyn los invoca automáticamente.

🔗 Microsoft — Source Generators

Sintaxis básica

[Generator]
public class HelloGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context) { }
    public void Execute(GeneratorExecutionContext context)
    {
        context.AddSource("HelloWorld.g.cs", """
            namespace GeneratedCode;
            public static class HelloWorld
            {
                public static string GetMessage() => "Generado en compilación!";
            }
        """);
    }
}

// Source generators famosos
// System.Text.Json — serializadores sin reflexión
// Regex source generator (C# 11+)
public partial class EmailValidator
{
    [GeneratedRegex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$")]
    public static partial Regex EmailRegex();
}

🧪 Cómo probarlo

[Fact]
public void Source_generated_regex_es_valida()
{
    Assert.True(EmailValidator.EmailRegex().IsMatch("test@example.com"));
    Assert.False(EmailValidator.EmailRegex().IsMatch("invalido"));
}

💡 Memoria y rendimiento

• Source generators eliminan reflexión y compilación en runtime — ideales para NativeAOT
• El regex source generator compila el patrón en build time, no en runtime
• Cero overhead en runtime — el código generado es estático

✅ Buenas prácticas

• ✅ Usa [GeneratedRegex] en vez de new Regex() para patrones fijos
• ✅ Para serialización de alto rendimiento, usa JsonSerializerContext
• ⚠️ No generes código que podría escribirse fácilmente a mano
• ❌ No uses source generators para lógica de negocio — son para infraestructura

Sistema de archivos y serialización

File, Directory y Path

¿Qué es?

El espacio System.IO proporciona clases para operar sobre archivos y directorios. File y Directory ofrecen métodos estáticos para operaciones rápidas. FileInfo y DirectoryInfo son útiles para múltiples operaciones sobre el mismo recurso. Path manipula rutas de forma multiplataforma.

🔗 Microsoft — System.IO

Sintaxis básica

using System.IO;

// File — estático
string contenido = File.ReadAllText("archivo.txt");
File.WriteAllText("salida.txt", "Hola Mundo");
File.Copy("origen.txt", "destino.txt", overwrite: true);
bool existe = File.Exists("archivo.txt");

// FileInfo — instancia
var fi = new FileInfo("archivo.txt");
Console.WriteLine($"{fi.Name}, {fi.Length} bytes");

// Directory — estático
string[] txts = Directory.GetFiles("./", "*.txt");
Directory.CreateDirectory("MisDatos");

// DirectoryInfo — instancia
var di = new DirectoryInfo("./");
foreach (var f in di.GetFiles("*.cs"))
    Console.WriteLine(f.Name);

// Path — rutas multiplataforma
string combo = Path.Combine("carpeta", "sub", "archivo.txt");
string ext = Path.GetExtension("archivo.txt");
string tempFile = Path.GetTempFileName();

🧪 Cómo probarlo

[Fact]
public void File_Write_read_roundtrip()
{
    var path = Path.GetTempFileName();
    File.WriteAllText(path, "Hola pruebas");
    var content = File.ReadAllText(path);
    Assert.Equal("Hola pruebas", content);
    File.Delete(path);
}

[Fact]
public void Path_combine_unixa_separator()
{
    string result = Path.Combine("a", "b", "c.txt");
    Assert.Equal("a/b/c.txt", result);
}

💡 Memoria y rendimiento

• File.ReadAllText carga todo el archivo en memoria — no apto para archivos >100 MB
• File.ReadLines (deferred) itera línea a línea sin cargar todo
• FileInfo cachea metadatos en la primera llamada — usa Refresh() si cambia externamente
• Path.Combine es barato — usa el separador del SO automáticamente

✅ Buenas prácticas

• ✅ Usa Path.Combine en vez de concatenar cadenas con "/" o "\\" manualmente
• ✅ Prefiere File.ReadLines para archivos grandes en vez de ReadAllText
• ⚠️ No asumas rutas fijas — usa Environment.GetFolderPath para carpetas del sistema
• ❌ No guardes archivos temporales sin limpiarlos — usa Path.GetTempFileName y elimínalos

🏗️ Metodología

• Configuración: almacena rutas en configuración (appsettings.json), nunca hardcodees
• Logs: escribe a ApplicationData o Logs/ con rotación de archivos
• Uploads: sanitiza nombres, limita tamaño, guarda fuera de wwwroot
• Pruebas: usa Path.GetTempPath() para archivos temporales que se limpian después

🔗 Para saber más

• Microsoft — File and Stream I/O

Streams: lectura, escritura y async I/O

¿Qué es?

Un Stream es una abstracción de una secuencia de bytes. FileStream, MemoryStream y GZipStream son tipos comunes. Los streams soportan operaciones síncronas y asíncronas (ReadAsync/WriteAsync). StreamReader/StreamWriter añaden capa de texto.

🔗 Microsoft — Streams

Sintaxis básica

// StreamReader — texto línea a línea
using var reader = new StreamReader("archivo.txt");
string? linea;
while ((linea = await reader.ReadLineAsync()) != null)
    Console.WriteLine(linea);

// StreamWriter — escritura de texto
using var writer = new StreamWriter("salida.txt", append: true);
await writer.WriteLineAsync("Nueva línea");

// FileStream — binario
using var fs = new FileStream("datos.bin", FileMode.OpenOrCreate);
byte[] buffer = new byte[4096];
int bytesRead = await fs.ReadAsync(buffer);

// BinaryReader/Writer — tipos primitivos
using var bw = new BinaryWriter(File.Open("datos.bin", FileMode.Create));
bw.Write(42); bw.Write(3.14); bw.Write("Hola");

// Async file helpers
await File.WriteAllTextAsync("archivo.txt", "contenido");
string texto = await File.ReadAllTextAsync("archivo.txt");

🧪 Cómo probarlo

[Fact]
public async Task Stream_escribe_y_lee_texto()
{
    var path = Path.GetTempFileName();
    await File.WriteAllTextAsync(path, "línea 1\nlínea 2");
    var lines = await File.ReadAllLinesAsync(path);
    Assert.Equal(2, lines.Length);
    File.Delete(path);
}

[Fact]
public void MemoryStream_funciona_sin_archivo()
{
    using var ms = new MemoryStream();
    using var writer = new StreamWriter(ms);
    writer.Write("en memoria");
    writer.Flush();
    Assert.True(ms.Length > 0);
}

💡 Memoria y rendimiento

• Operaciones async evitan bloquear el thread de UI — críticas en apps gráficas
• FileStream tiene buffer interno (4 KB por defecto) — ajusta con FileStreamOptions
• MemoryStream trabaja en RAM — útil para tests y transformaciones en memoria
• CopyToAsync optimiza la copia entre streams sin buffers intermedios grandes

✅ Buenas prácticas

• ✅ Siempre usa using o await using para streams — liberan handles del SO
• ✅ Usa métodos *Async en servidores web y UI — evitas thread pool starvation
• ⚠️ No mezcles Read y ReadAsync en el mismo stream — resultados impredecibles
• ❌ No llames Dispose manualmente si usas using

🏗️ Metodología

• Archivos pequeños (<10 MB): ReadAllText/WriteAllText (simple)
• Archivos grandes: FileStream con buffer o ReadLines (deferred)
• Streams en red/API: siempre async para no bloquear
• Transformaciones: encadena streams (GZipStream sobre FileStream)

🔗 Para saber más

• Microsoft — Async file I/O

FileSystemWatcher y compresión

¿Qué es?

FileSystemWatcher monitoriza cambios en archivos/directorios y dispara eventos. System.IO.Compression proporciona compresión ZIP, GZip y Deflate sin dependencias externas.

🔗 Microsoft — FileSystemWatcher

Sintaxis básica

using var watcher = new FileSystemWatcher("./")
{
    NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite,
    Filter = "*.txt",
    EnableRaisingEvents = true
};
watcher.Created += (s, e) => Console.WriteLine($"Creado: {e.Name}");
watcher.Changed += (s, e) => Console.WriteLine($"Modificado: {e.Name}");

// ZIP
using var archivo = ZipFile.Open("backup.zip", ZipArchiveMode.Create);
archivo.CreateEntryFromFile("datos.txt", "datos.txt");
ZipFile.ExtractToDirectory("backup.zip", "./restaurado");

// GZip
using var original = File.OpenRead("grande.txt");
using var comprimido = File.Create("grande.gz");
using var gzip = new GZipStream(comprimido, CompressionMode.Compress);
await original.CopyToAsync(gzip);

🧪 Cómo probarlo

[Fact]
public void Zip_crea_y_extrae_archivo()
{
    var src = Path.GetTempFileName();
    var zip = Path.GetTempFileName() + ".zip";
    File.WriteAllText(src, "contenido");
    using (var a = ZipFile.Open(zip, ZipArchiveMode.Create))
        a.CreateEntryFromFile(src, "inner.txt");
    Assert.True(new FileInfo(zip).Length > 0);
    File.Delete(src); File.Delete(zip);
}

💡 Memoria y rendimiento

• FileSystemWatcher usa eventos del SO — no consume CPU hasta que hay cambios
• GZipStream comprime ≈100 MB/s en CPU moderna; DeflateStream similar sin checksum
• ZIP añade overhead de cabeceras (~1 KB por archivo)

✅ Buenas prácticas

• ✅ Limita NotifyFilter a lo necesario para reducir eventos duplicados
• ✅ Comprime logs rotados tras N días para ahorrar espacio
• ⚠️ FileSystemWatcher puede perder eventos si el buffer interno (64 KB) se llena
• ❌ No confíes en el orden de eventos — bufferiza cambios antes de procesar

🏗️ Metodología

• Backups: ZIP con CreateEntryFromFile y fecha en el nombre
• Watch de directorio: procesa eventos con un buffer de tiempo (debounce 500ms)
• Logs: comprime con GZip tras rotación diaria

🔗 Para saber más

• Microsoft — ZipFile class

Serialización: JSON, CSV y YAML

¿Qué es?

La serialización convierte objetos a formato textual/binario para almacenamiento o transmisión. System.Text.Json es el serializador oficial para JSON (desde .NET Core 3.0). CsvHelper y YamlDotNet son librerías externas para CSV y YAML.

🔗 Microsoft — System.Text.Json

Sintaxis básica

using System.Text.Json;

public record Producto(string Nombre, decimal Precio, int Stock);

// Serializar
var producto = new Producto("Laptop", 999.99m, 10);
var options = new JsonSerializerOptions
{
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
string json = JsonSerializer.Serialize(producto, options);

// Deserializar
var deserializado = JsonSerializer.Deserialize<Producto>(json);

// JsonDocument — acceso sin tipado
using var doc = JsonDocument.Parse(json);
string nombre = doc.RootElement.GetProperty("nombre").GetString()!;

// Source generator — cero reflexión
[JsonSerializable(typeof(Producto[]))]
partial class AppJsonContext : JsonSerializerContext { }

dotnet add package CsvHelper

using CsvHelper;
using System.Globalization;

var records = new List<Producto> { new("Laptop", 999.99m, 10) };
using var writer = new StreamWriter("productos.csv");
using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteRecords(records);

dotnet add package YamlDotNet

using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

var serializer = new SerializerBuilder()
    .WithNamingConvention(CamelCaseNamingConvention.Instance)
    .Build();
string yaml = serializer.Serialize(producto);

🧪 Cómo probarlo

[Fact]
public void Json_deserializa_correctamente()
{
    string json = """{"nombre":"Laptop","precio":999.99,"stock":10}""";
    var prod = JsonSerializer.Deserialize<Producto>(json);
    Assert.Equal("Laptop", prod!.Nombre);
}

[Fact]
public void Source_generator_no_usa_reflexion()
{
    var prod = new Producto("Test", 1, 1);
    var json = JsonSerializer.Serialize(prod, AppJsonContext.Default.Producto);
    Assert.NotNull(json);
}

💡 Memoria y rendimiento

• System.Text.Json es ~50% más rápido que Newtonsoft.Json y con menos allocations
• Source generators eliminan reflexión y JIT compilation — ideales para NativeAOT
• Utf8JsonReader y Utf8JsonWriter trabajan directamente sobre UTF-8 sin decodificar

✅ Buenas prácticas

• ✅ Usa JsonNamingPolicy.CamelCase para APIs REST
• ✅ Para alto rendimiento, usa JsonSerializerContext (source generators)
• ⚠️ No serialices tipos circulares sin configuración de referencia
• ❌ No compartas JsonSerializerOptions entre hilos sin inmutabilidad

🏗️ Metodología

• APIs REST: System.Text.Json con camelCase + [JsonIgnore] en propiedades sensibles
• Config: JSON con WriteIndented = true para legibilidad humana
• Bulk data: CSV con CsvHelper; YAML para configs complejas

🔗 Para saber más

• System.Text.Json — How to
• CsvHelper docs
• YamlDotNet GitHub

Algoritmos y estructuras de datos

Ordenación y búsqueda

¿Qué es?

La ordenación organiza elementos según un criterio de comparación. Array.Sort usa Introsort (QuickSort + HeapSort + InsertionSort), O(n log n) promedio. BinarySearch requiere datos ordenados y es O(log n). LINQ ofrece OrderBy/ThenBy con ordenación estable.

🔗 Microsoft — Array.Sort

Sintaxis básica

int[] arr = [5, 3, 8, 1, 9, 2, 7, 4, 6];

// Introsort
Array.Sort(arr);
Array.Sort(arr, (a, b) => b.CompareTo(a));  // Descendente

// LINQ — estable
var ordenado = arr.OrderBy(x => x).ToArray();
var compuesto = personas
    .OrderBy(p => p.Nombre)
    .ThenByDescending(p => p.Edad);

// Búsqueda binaria — array debe estar ordenado
int index = Array.BinarySearch(arr, 7);

// Búsqueda secuencial con LINQ
var encontrado = arr.FirstOrDefault(n => n > 5);
var rango = arr.Where(n => n > 3 && n < 11).ToList();

// IComparer personalizado
class ComparadorInverso : IComparer<int>
{
    public int Compare(int x, int y) => y.CompareTo(x);
}
Array.Sort(arr, new ComparadorInverso());