Optimus Agency | Desarrollo Web Profesional

Capítulo 1 — Fundamentos10 lecciones

Hello World → top-level → variables → I/O → conversión → operadores → strings → errores → Calculadora

Paso 1
Hello, World — your first C# program
Every language has its tradition: the first program you write prints "Hello, World" to the screen. In C# this single lin…
Empezar lección
Paso 2
using directives, namespaces, and comments
The .NET Base Class Library is huge. Thousands of types live inside it — Console, Math, DateTime, File, Random, List, Di…
Empezar lección
Paso 3
Variables and the string type
A variable is a named slot in memory that holds a value. Once you've named the slot, you can read the value, change it, …
Empezar lección
Paso 4
Console input — talking to the user
So far our programs have been monologues — we print, the user reads. A program that takes input is a conversation. C# gi…
Empezar lección
Paso 5
Numeric types — int, double, decimal, char
Strings are great for text, but most programs eventually have to count, measure, or calculate. C# gives you a precise me…
Empezar lección
Paso 6
Type conversion — cast, Parse, Convert, TryParse
C# is strict about types. You can't assign a double to an int by accident, and you can't add a string to a number. That …
Empezar lección
Paso 7
Operators, math, and the order of evaluation
Arithmetic in C# uses the same operators you've seen since school: + (plus), - (minus), * (times), / (divide), and % (mo…
Empezar lección
Paso 8
String formatting — interpolation, escapes, raw strings
We've already met the workhorse — interpolation: $"Hello, {name}!". You can do more than splice variables. Anything insi…
Empezar lección
Paso 9
Compile-time vs runtime errors
C# code has to pass through two gates before it does anything useful. The first gate is the compiler — it checks that yo…
Empezar lección
Paso 10
Capstone — the Addition Calculator
Time to combine the chapter. The Addition Calculator is a small program that reads two numbers from the user, validates …
Empezar lección

Capítulo 2 — Control de flujo y decisiones10 lecciones

booleanos → if/else → operadores lógicos → cadenas else-if → anidado + scope → ternario → switch → switch expression → decisiones con strings → Quiz App

Capítulo 3 — Loops y arreglos10 lecciones

intro a loops → for → while → do-while → break/continue → arrays → iterar (for/foreach) → multidimensional → jagged → simulador Rocket Launch

Capítulo 4 — Métodos10 lecciones

intro a métodos → void/return → parámetros → multi-params → overloading → defaults + named → ref/out/in → expression-bodied (=>) → recursión → simulador del clima

Capítulo 5 — Clases y objetos10 lecciones

intro a clases → fields → constructores → propiedades (auto/full/computadas) → métodos de instancia → modificadores de acceso → readonly/const/init → miembros estáticos → encadenado de constructores → BankAccount

Capítulo 6 — Herencia y polimorfismo10 lecciones

intro a herencia (IS-A) → base/derivada + protected → virtual/override → keyword base → clases abstractas → cadenas de constructores : base(...) → sealed → interfaces → polimorfismo → Shape Zoo

Capítulo 7 — Colecciones10 lecciones

intro a colecciones → List<T> básicos → Contains/Sort/Reverse → lambdas + predicados → LINQ Where/Any/Select → Dictionary<K,V> → ContainsKey/TryGetValue → HashSet<T> → tuplas + desestructuración → Inventory Tracker

Capítulo 8 — Excepciones10 lecciones

intro a excepciones → try/catch → múltiples catch + filtros → finally → throw + rethrow → tipos built-in → excepciones personalizadas → mejores prácticas → using + IDisposable → Resource Pool

Capítulo 9 — Generics en profundidad10 lecciones

intro a generics → clase genérica Box<T> → métodos genéricos + inferencia → multi-parámetros → constraints (where) → interfaces genéricas → IEnumerable/ICollection/IList → Action/Func/Predicate → default(T) + varianza → Typed Bag

Capítulo 10 — Delegates y eventos10 lecciones

intro a delegates → instancias + lambdas → multicast +=/-= + invocation list → delegates como parámetros → keyword event + pub/sub → EventHandler<T> + EventArgs custom → fire seguro (?.Invoke + copia thread) → event vs campo delegate → patrón observer → Stock Monitor

Capítulo 11 — Expresiones regulares10 lecciones

intro a regex → literales + anclas (^, $, \b) → clases de caracteres (\d \w \s + corchetes) → cuantificadores (* + ? {n,m} + lazy) → grupos + alternación → grupos nombrados + backreferences → clase Regex (IsMatch/Match/Matches + opciones) → Replace/Split + MatchEvaluator → lookarounds (?=, ?!, ?<=, ?<!) → Log Parser

Capítulo 12 — Programación asíncrona10 lecciones

intro a async → Task + Task<T> → keywords async/await → continuations + máquina de estados → Task.WhenAll / WhenAny → excepciones async → CancellationToken → Task.FromResult + CompletedTask → pitfalls (async void, deadlocks) → Download Aggregator

Capítulo 13 — Structs, Enums y Records10 lecciones

tipos por valor vs referencia → definir un struct → struct vs class (trampa del struct mutable) → enums → enums [Flags] → structs readonly/inmutables → records (igualdad por valor) → expresiones with + desestructuración → matriz de decisión record/class/struct → capstone Vector2D

Capítulo 14 — Fechas, Horas y Duraciones10 lecciones

DateTime (ticks + Kind) → Now/Today/UtcNow + constructores → componentes (DayOfWeek/DayOfYear) → TimeSpan (componente vs Total) → aritmética (Add*, fecha − fecha) → formato (InvariantCulture) → parseo (Parse/TryParse/ParseExact) → comparación y ordenamiento → DateTimeOffset y UTC → Planificador de Eventos

Capítulo 16 — Texto, JSON y Streams10 lecciones

StringBuilder (append/insert, sin copias) → cirugía de strings Split/Join/Substring/Pad → StringReader/StringWriter (TextReader/TextWriter) → serializar JSON (System.Text.Json) → Deserialize<T> + sin distinguir mayúsculas → JsonSerializerOptions (camelCase, indentado, omitir nulls) → DOM con JsonDocument/JsonElement → parsear y construir CSV a mano → MemoryStream + codificación UTF-8 (bytes↔texto) → capstone procesador de config y órdenes JSON

LINQ en profundidad10 lecciones

Consulta, proyecta, agrupa, une y agrega cualquier colección — y domina la ejecución diferida.

Hilos y Concurrencia10 lecciones

Ejecuta codigo en paralelo sin corromper tus datos: hilos, locks, Interlocked, Tasks, bucles Parallel, colecciones concurrentes, primitivas de coordinacion y tuberias productor/consumidor.

C# moderno y coincidencia de patrones10 lecciones

Tipos de referencia anulables, los operadores de null y todo el arsenal de coincidencia de patrones — de tipo, de propiedad, relacionales, lógicos, de tupla, de lista y posicionales — culminando en un intérprete de comandos basado en patrones.

Pruebas y TDD10 lecciones

Construye un arnés de aserciones a mano, aprende Arrange-Act-Assert y el ciclo rojo-verde-refactor, prueba casos límite y excepciones, aísla unidades con dobles de prueba, y termina aplicando TDD a un conversor de números romanos tras un mini runner de pruebas que totaliza los resultados.

Codigo Limpio y SOLID10 lecciones

Refactoriza codigo con malos olores hacia disenos limpios y flexibles: clausulas de guarda, Extraer Metodo y los cinco principios SOLID, preservando el comportamiento.

Algoritmos y Big-O10 lecciones

Mide como escala tu codigo: tasas de crecimiento Big-O, busqueda y ordenamiento, recursion y memoizacion, compromisos entre estructuras de datos, y tiempo contra espacio — culminando en un taller de two-sum que compara O(n^2) ingenuo con O(n) optimo.

Memoria, Spans y Rendimiento10 lecciones

Stack vs heap, el GC generacional, IDisposable, boxing, Span<T>, stackalloc, asignaciones de strings y cómo medir para escribir código con pocas asignaciones.

Reflexión, atributos y metadatos10 lecciones

Inspecciona tipos en tiempo de ejecución, construye e invoca miembros dinámicamente, diseña atributos personalizados y crea motores guiados por atributos — y aceléralos con caché.

Iteradores, yield y secuencias personalizadas10 lecciones

Domina la evaluación perezosa: construye secuencias con yield, compón operadores estilo LINQ, transmite de forma asíncrona y evita las trampas de la ejecución diferida.

C# Funcional10 lecciones

Funciones puras, lambdas de primera clase, composición, inmutabilidad, Result/Option, pattern matching y LINQ como caja de herramientas funcional.

Igualdad, Comparación y Ordenamiento10 lecciones

Toma el control de lo que significa 'lo mismo' y 'va primero': ==, Equals/GetHashCode, IEquatable, IComparable, comparadores, igualdad de records y las trampas que muerden.

Globalización, Cultura y Formato10 lecciones

CultureInfo, cadenas de formato de números/fechas/moneda, parseo y operaciones de cadenas según la cultura, IFormattable y la regla de usar siempre InvariantCulture para datos de máquina.

Números y matemáticas10 lecciones

Rangos de enteros y desbordamiento silencioso, checked vs unchecked, la realidad del punto flotante, dinero con decimal, estrategias de redondeo, la clase Math, operaciones de bits, BigInteger y parseo robusto.

Colecciones en Profundidad10 lecciones

Más allá de List y Dictionary: pilas, colas, listas enlazadas, colecciones ordenadas y de prioridad, vistas de solo lectura, inmutabilidad y cómo elegir el contenedor correcto.

Patrones de Diseño en C#10 lecciones

Los patrones clásicos de la Gang of Four contados en C# moderno e idiomático: Strategy, Factory, Builder, Singleton, Observer, Decorator, Adapter y Command — con Func/Action en lugar de ceremonia de interfaces, y el criterio para saber cuándo NO usarlos.

Parsing y un mini-intérprete10 lecciones

Construye un intérprete de expresiones funcional: tokenizador, parser de descenso recursivo, AST y un lenguaje calculadora con variables.

Genéricos Avanzados10 lecciones

Varianza, restricciones avanzadas, matemática genérica (INumber<T>), miembros estáticos abstractos e IParsable<T> — la maquinaria profunda detrás del código reutilizable y con seguridad de tipos.

Capítulo 33 — Máquinas de Estado y Flujos de Trabajo10 lecciones

qué es una FSM (estados/eventos/transiciones) → función de transición con enum + switch → tablas data-driven Dictionary<(State,Event),State> → transiciones con guardas + acciones de efecto secundario → rechazar eventos ilegales → estados como jerarquía de records sealed → hooks de entrada/salida + registro de transiciones → estados jerárquicos + historial → trampas de las FSM (explosión de estados, sopa de booleanos, transiciones faltantes) → capstone de motor de flujo de pedidos

Modelado de Dominio10 lecciones

Modela el dominio con tipos para que los estados ilegales sean irrepresentables

Capítulo 35 — APIs web con ASP.NET Core10 lecciones

el pipeline de peticiones → Minimal APIs → routing y binding de parámetros → inyección de dependencias y lifetimes → middleware → model binding y validación → controllers vs minimal → códigos de estado, results y ProblemDetails → configuración y auth → capstone Catalog Web API

Capítulo 36 — Entity Framework Core10 lecciones

qué es un ORM → DbContext y entidades → configurar el modelo (anotaciones vs Fluent API) → migraciones → consultas con LINQ (IQueryable → SQL) → CRUD y el change tracker → relaciones → carga de datos relacionados (Include / N+1) → tracking y rendimiento → capstone de modelo de datos

Capítulo 37 — C# en la nube y distribuido10 lecciones

el Generic Host → configuración y el patrón Options → logging (ILogger) → servicios en segundo plano → IHttpClientFactory → resiliencia (reintentos, circuit breaker, timeout) → gRPC → SignalR en tiempo real → mensajería y colas → capstone de worker service resiliente

Capítulo 38 — UI web interactiva con Blazor10 lecciones

qué es Blazor → componentes Razor → data binding (@bind) → manejo de eventos (EventCallback) → ciclo de vida del componente → render y estado → formularios y validación → modelos de render (Server / WebAssembly / Auto) → interop con JavaScript → capstone de componente interactivo

Capítulo 39 — Apps de escritorio con WPF y MVVM10 lecciones

qué es WPF → fundamentos de XAML → paneles de layout → controles y el modelo de contenido → propiedades de dependencia → data binding + INotifyPropertyChanged → el patrón MVVM → ICommand / RelayCommand → ObservableCollection y plantillas → capstone de app MVVM

Capítulo 40 — Desarrollo de juegos con Unity y C#10 lecciones

qué es Unity → el ciclo de vida de MonoBehaviour → GameObjects y componentes → vectores y transforms → manejo de input → física y colisiones → prefabs e instanciación → Time.deltaTime y movimiento → estado del juego y UI → capstone de juego arcade

Domina C# desde cero

Hello, World — your first C# program

using directives, namespaces, and comments

Variables and the string type

Console input — talking to the user

Numeric types — int, double, decimal, char

Type conversion — cast, Parse, Convert, TryParse

Operators, math, and the order of evaluation

String formatting — interpolation, escapes, raw strings

Compile-time vs runtime errors

Capstone — the Addition Calculator

Booleans and comparison operators

if and else — choosing a path

Logical operators — AND, OR, NOT

else if — multi-branch decisions

Nested conditions and variable scope

The ternary operator — one-line conditionals

The switch statement — discrete cases

Switch expressions — C# 8's cleaner form

String methods that drive decisions

Capstone — the Little Quiz App

Why loops exist — the four flavors in C#

The for loop — counting with intent

while loops — condition-driven iteration

do-while — run first, ask later

break and continue — escape hatches

Arrays — fixed-size collections of one type

Walking an array — for, foreach, and Length

Multidimensional arrays — grids in one block

Jagged arrays — arrays of arrays

Capstone — the Rocket Launch simulator

Methods — naming a piece of work

Return types — void vs producing a value

Parameters — passing data into methods

Multiple parameters — order and types matter

Method overloading — same name, different signatures

Default values and named arguments

ref, out, in — explicit parameter passing

Expression-bodied members — the => shortcut

Recursion — methods that call themselves

Capstone — the Weather Simulator

Classes & objects — the noun in OOP

Fields — the state each object carries

Constructors — building a valid instance

Properties — fields with manners

Methods on a class — behaviour bound to state

public, private, protected, internal — who can touch what

readonly, const, init — locking down values

static — class-level state and helpers

Multiple constructors — overloading and chaining

Capstone — the BankAccount class

Inheritance — building on what you already have

Base and derived — what gets inherited

virtual and override — polymorphic methods

base — extending, not replacing

abstract classes — bases you can't instantiate

Constructor inheritance — : base(args)

sealed — closing the hierarchy

Interfaces — contracts without implementation

Polymorphism — one shape, many implementations

Capstone — the Shape Zoo

Collections — beyond fixed-size arrays

List<T> — dynamic, ordered, indexable

List operations — Contains, IndexOf, Sort, Reverse

Lambdas and predicates — code as data

LINQ basics — Where, Any, Select, Count

Dictionary<K, V> — key-driven lookup

ContainsKey, TryGetValue, Remove — defensive dictionary code

HashSet<T> — unique items, fast Contains

Tuples — returning multiple values cleanly

Capstone — the Inventory Tracker

Exceptions — when something goes wrong at runtime

try / catch — handling failures gracefully

Multiple catches — handle different failures differently

finally — code that always runs

Throwing exceptions — signalling failure deliberately

The common built-in exception types

Custom exception types — speaking your domain

Exception best practices — when NOT to catch

using + IDisposable — guaranteed cleanup