martes, 23 de junio de 2026

Patrones de diseño en .NET

Los patrones de diseño son: soluciones habituales a problemas comunes en el diseño de software.

Cada patrón es como un plano que se puede personalizar para resolver un problema de diseño particular de tu código.

La siguiente imagen muestra los patrones de diseño en C#.

Patrones de diseño en .NET (C#)

Podemos ver tres tipos y sus divisiones.

  • Patrones creacionales: proporcionan varios mecanismos de creación de objetos que incrementan la flexibilidad y la reutilización del código existente. 
  • Patrones estructurales: estructurales explican cómo ensamblar objetos y clases en estructuras más grandes, a la vez que se mantiene la flexibilidad y eficiencia de estas estructuras. 
  • Patrones de comportamiento: los que tratan con algoritmos y la asignación de responsabilidades entre objetos.

Patrones Creacionales (Creational Patterns)

Factory method

Permite crear familias de objetos relacionados sin especificar sus clases concretas.

Ejemplo:

// Producto abstracto
public abstract class Documento
{
    public abstract void Mostrar();
}

// Productos concretos
public class PDF : Documento
{
    public override void Mostrar() => Console.WriteLine("Mostrando documento PDF");
}

public class Word : Documento
{
    public override void Mostrar() => Console.WriteLine("Mostrando documento Word");
}

// Creador abstracto
public abstract class CreadorDocumento
{
    public abstract Documento CrearDocumento();
}

// Creador concreto
public class CreadorPDF : CreadorDocumento
{
    public override Documento CrearDocumento() => new PDF();
}

public class CreadorWord : CreadorDocumento
{
    public override Documento CrearDocumento() => new Word();
}

// Uso del patrón
class Program
{
    static void Main()
    {
        CreadorDocumento creador = new CreadorPDF();
        Documento doc = creador.CrearDocumento();
        doc.Mostrar();

        creador = new CreadorWord();
        doc = creador.CrearDocumento();
        doc.Mostrar();
    }
}

Abstract factory

Permite crear familias de objetos relacionados sin especificar sus clases concretas.

Ejemplo:

// Productos abstractos
public interface ISilla
{
    void Sentarse();
}

public interface IMesa
{
    void Usar();
}

// Productos concretos
public class SillaModerna : ISilla
{
    public void Sentarse() => Console.WriteLine("Sentado en una silla moderna.");
}

public class MesaModerna : IMesa
{
    public void Usar() => Console.WriteLine("Usando una mesa moderna.");
}

public class SillaClasica : ISilla
{
    public void Sentarse() => Console.WriteLine("Sentado en una silla clásica.");
}

public class MesaClasica : IMesa
{
    public void Usar() => Console.WriteLine("Usando una mesa clásica.");
}

// Fábrica abstracta
public interface IFabricaMuebles
{
    ISilla CrearSilla();
    IMesa CrearMesa();
}

// Fábricas concretas
public class FabricaModerna : IFabricaMuebles
{
    public ISilla CrearSilla() => new SillaModerna();
    public IMesa CrearMesa() => new MesaModerna();
}

public class FabricaClasica : IFabricaMuebles
{
    public ISilla CrearSilla() => new SillaClasica();
    public IMesa CrearMesa() => new MesaClasica();
}

// Uso del patrón
class Program
{
    static void Main()
    {
        IFabricaMuebles fabrica = new FabricaModerna();
        ISilla silla = fabrica.CrearSilla();
        IMesa mesa = fabrica.CrearMesa();

        silla.Sentarse();
        mesa.Usar();

        fabrica = new FabricaClasica();
        silla = fabrica.CrearSilla();
        mesa = fabrica.CrearMesa();

        silla.Sentarse();
        mesa.Usar();
    }
}

Builder

Permite construir objetos complejos paso a paso. Este patrón permite generar diferentes tipos y representaciones de un objeto utilizando el mismo código de construcción.

Ejemplo:

// Producto complejo
public class Computadora
{
    public string CPU { get; set; }
    public string RAM { get; set; }
    public string Almacenamiento { get; set; }

    public void Mostrar()
    {
        Console.WriteLine($"CPU: {CPU}, RAM: {RAM}, Almacenamiento: {Almacenamiento}");
    }
}

// Builder abstracto
public interface IBuilderComputadora
{
    void ConstruirCPU();
    void ConstruirRAM();
    void ConstruirAlmacenamiento();
    Computadora ObtenerComputadora();
}

// Builder concreto
public class BuilderComputadoraGaming : IBuilderComputadora
{
    private Computadora computadora = new Computadora();

    public void ConstruirCPU() => computadora.CPU = "Intel Core i9";
    public void ConstruirRAM() => computadora.RAM = "32 GB";
    public void ConstruirAlmacenamiento() => computadora.Almacenamiento = "1 TB SSD";

    public Computadora ObtenerComputadora() => computadora;
}

public class BuilderComputadoraOficina : IBuilderComputadora
{
    private Computadora computadora = new Computadora();

    public void ConstruirCPU() => computadora.CPU = "Intel Core i5";
    public void ConstruirRAM() => computadora.RAM = "8 GB";
    public void ConstruirAlmacenamiento() => computadora.Almacenamiento = "500 GB HDD";

    public Computadora ObtenerComputadora() => computadora;
}

// Director
public class Director
{
    public void Construir(IBuilderComputadora builder)
    {
        builder.ConstruirCPU();
        builder.ConstruirRAM();
        builder.ConstruirAlmacenamiento();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        Director director = new Director();

        IBuilderComputadora builderGaming = new BuilderComputadoraGaming();
        director.Construir(builderGaming);
        Computadora pcGaming = builderGaming.ObtenerComputadora();
        pcGaming.Mostrar();

        IBuilderComputadora builderOficina = new BuilderComputadoraOficina();
        director.Construir(builderOficina);
        Computadora pcOficina = builderOficina.ObtenerComputadora();
        pcOficina.Mostrar();
    }
}

Prototype

Te permite copiar objetos existentes sin que tu código dependa de sus clases.

Ejemplo:

using System;

// Interfaz Prototype
public interface IFigura
{
    IFigura Clonar();
    void Mostrar();
}

// Clase concreta
public class Circulo : IFigura
{
    public int Radio { get; set; }

    public Circulo(int radio)
    {
        Radio = radio;
    }

    public IFigura Clonar()
    {
        // Clonación superficial
        return new Circulo(this.Radio);
    }

    public void Mostrar()
    {
        Console.WriteLine($"Círculo con radio: {Radio}");
    }
}

public class Cuadrado : IFigura
{
    public int Lado { get; set; }

    public Cuadrado(int lado)
    {
        Lado = lado;
    }

    public IFigura Clonar()
    {
        return new Cuadrado(this.Lado);
    }

    public void Mostrar()
    {
        Console.WriteLine($"Cuadrado con lado: {Lado}");
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        Circulo c1 = new Circulo(10);
        Circulo c2 = (Circulo)c1.Clonar();

        c1.Mostrar();
        c2.Mostrar();

        Cuadrado q1 = new Cuadrado(5);
        Cuadrado q2 = (Cuadrado)q1.Clonar();

        q1.Mostrar();
        q2.Mostrar();
    }
}

Singleton

Permite garantizar que una clase tenga una sola instancia, a la vez que proporciona un punto de acceso global a dicha instancia.

Ejemplo:

using System;

public sealed class Configuracion
{
    // Instancia única (lazy initialization con thread-safety)
    private static readonly Lazy<Configuracion> instancia =
        new Lazy<Configuracion>(() => new Configuracion());

    // Propiedad pública para acceder a la instancia
    public static Configuracion Instancia => instancia.Value;

    // Propiedades de ejemplo
    public string NombreAplicacion { get; private set; }

    // Constructor privado para evitar instanciación externa
    private Configuracion()
    {
        NombreAplicacion = "MiAplicacion v1.0";
    }

    // Método de ejemplo
    public void Mostrar()
    {
        Console.WriteLine($"Configuración cargada: {NombreAplicacion}");
    }
}

class Program
{
    static void Main()
    {
        // Acceder a la única instancia
        Configuracion c1 = Configuracion.Instancia;
        c1.Mostrar();

        // Intentar obtener otra instancia devuelve la misma
        Configuracion c2 = Configuracion.Instancia;
        Console.WriteLine(Object.ReferenceEquals(c1, c2)); // True
    }
}

Patrones Estructurales (Structural Patterns)

Adapter

Permite que objetos con interfaces incompatibles colaboren.

Ejemplo:

using System;

// Interfaz esperada por el cliente
public interface IReproductorAudio
{
    void Reproducir(string archivo);
}

// Clase existente con una interfaz diferente
public class ServicioMp3
{
    public void PlayMp3(string nombreArchivo)
    {
        Console.WriteLine($"Reproduciendo archivo MP3: {nombreArchivo}");
    }
}

// Adaptador que traduce entre la interfaz esperada y la clase existente
public class AdaptadorMp3 : IReproductorAudio
{
    private readonly ServicioMp3 servicioMp3;

    public AdaptadorMp3(ServicioMp3 servicio)
    {
        servicioMp3 = servicio;
    }

    public void Reproducir(string archivo)
    {
        // Traduce la llamada
        servicioMp3.PlayMp3(archivo);
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        // Cliente espera trabajar con IReproductorAudio
        IReproductorAudio reproductor = new AdaptadorMp3(new ServicioMp3());

        reproductor.Reproducir("cancion.mp3");
    }
}

Facade

Proporciona una interfaz simplificada para una biblioteca, un marco de trabajo o cualquier otro conjunto complejo de clases.

Ejemplo:

using System;

// Subsistemas
public class DVDPlayer
{
    public void Encender() => Console.WriteLine("DVD Player encendido");
    public void Reproducir() => Console.WriteLine("Reproduciendo DVD...");
}

public class Proyector
{
    public void Encender() => Console.WriteLine("Proyector encendido");
    public void ApagarLuces() => Console.WriteLine("Luces apagadas para la proyección");
}

public class SistemaSonido
{
    public void Encender() => Console.WriteLine("Sistema de sonido encendido");
    public void AjustarVolumen(int nivel) => Console.WriteLine($"Volumen ajustado a {nivel}");
}

// Facade
public class HomeTheaterFacade
{
    private DVDPlayer dvd;
    private Proyector proyector;
    private SistemaSonido sonido;

    public HomeTheaterFacade(DVDPlayer dvd, Proyector proyector, SistemaSonido sonido)
    {
        this.dvd = dvd;
        this.proyector = proyector;
        this.sonido = sonido;
    }

    public void VerPelicula()
    {
        Console.WriteLine("Preparando el sistema para ver la película...");
        proyector.Encender();
        proyector.ApagarLuces();
        sonido.Encender();
        sonido.AjustarVolumen(10);
        dvd.Encender();
        dvd.Reproducir();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        DVDPlayer dvd = new DVDPlayer();
        Proyector proyector = new Proyector();
        SistemaSonido sonido = new SistemaSonido();

        HomeTheaterFacade homeTheater = new HomeTheaterFacade(dvd, proyector, sonido);
        homeTheater.VerPelicula();
    }
}

Brigde

Permite dividir una clase grande o un conjunto de clases estrechamente relacionadas en dos jerarquías separadas —abstracción e implementación— que pueden desarrollarse independientemente una de la otra.

Ejemplo:

using System;

// Implementador
public interface IDispositivo
{
    void Encender();
    void Apagar();
}

// Implementaciones concretas
public class Televisor : IDispositivo
{
    public void Encender() => Console.WriteLine("Televisor encendido");
    public void Apagar() => Console.WriteLine("Televisor apagado");
}

public class Radio : IDispositivo
{
    public void Encender() => Console.WriteLine("Radio encendida");
    public void Apagar() => Console.WriteLine("Radio apagada");
}

// Abstracción
public abstract class ControlRemoto
{
    protected IDispositivo dispositivo;

    protected ControlRemoto(IDispositivo dispositivo)
    {
        this.dispositivo = dispositivo;
    }

    public abstract void BotonEncender();
    public abstract void BotonApagar();
}

// Abstracción refinada
public class ControlBasico : ControlRemoto
{
    public ControlBasico(IDispositivo dispositivo) : base(dispositivo) { }

    public override void BotonEncender() => dispositivo.Encender();
    public override void BotonApagar() => dispositivo.Apagar();
}

// Uso del patrón
class Program
{
    static void Main()
    {
        IDispositivo tv = new Televisor();
        ControlRemoto controlTv = new ControlBasico(tv);

        controlTv.BotonEncender();
        controlTv.BotonApagar();

        IDispositivo radio = new Radio();
        ControlRemoto controlRadio = new ControlBasico(radio);

        controlRadio.BotonEncender();
        controlRadio.BotonApagar();
    }
}

Composite

Permite componer objetos en estructuras de árbol y luego trabajar con estas estructuras como si fueran objetos individuales.

Ejemplo:

using System;
using System.Collections.Generic;

// Componente
public abstract class MenuComponent
{
    public abstract void Mostrar();
}

// Hoja (Leaf)
public class Plato : MenuComponent
{
    private string nombre;

    public Plato(string nombre)
    {
        this.nombre = nombre;
    }

    public override void Mostrar()
    {
        Console.WriteLine($"Plato: {nombre}");
    }
}

// Compuesto (Composite)
public class Menu : MenuComponent
{
    private string nombre;
    private List<MenuComponent> elementos = new List<MenuComponent>();

    public Menu(string nombre)
    {
        this.nombre = nombre;
    }

    public void Agregar(MenuComponent componente)
    {
        elementos.Add(componente);
    }

    public override void Mostrar()
    {
        Console.WriteLine($"Menú: {nombre}");
        foreach (var elemento in elementos)
        {
            elemento.Mostrar();
        }
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        // Crear platos
        Plato sopa = new Plato("Sopa de verduras");
        Plato pasta = new Plato("Pasta al pesto");
        Plato postre = new Plato("Tiramisú");

        // Crear menú principal
        Menu menuPrincipal = new Menu("Menú Principal");
        menuPrincipal.Agregar(sopa);
        menuPrincipal.Agregar(pasta);

        // Crear menú de postres
        Menu menuPostres = new Menu("Menú de Postres");
        menuPostres.Agregar(postre);

        // Agregar menú de postres al menú principal
        menuPrincipal.Agregar(menuPostres);

        // Mostrar todo
        menuPrincipal.Mostrar();
    }
}

Proxy

Permite proporcionar un sustituto o marcador de posición para otro objeto. Un proxy controla el acceso al objeto original, lo que permite realizar alguna acción antes o después de que la solicitud llegue al objeto original.

Ejemplo:

using System;

// Interfaz común
public interface IImagen
{
    void Mostrar();
}

// Clase real (objeto pesado)
public class ImagenReal : IImagen
{
    private string archivo;

    public ImagenReal(string archivo)
    {
        this.archivo = archivo;
        CargarDesdeDisco();
    }

    private void CargarDesdeDisco()
    {
        Console.WriteLine($"Cargando imagen desde disco: {archivo}");
    }

    public void Mostrar()
    {
        Console.WriteLine($"Mostrando imagen: {archivo}");
    }
}

// Proxy
public class ProxyImagen : IImagen
{
    private string archivo;
    private ImagenReal imagenReal;

    public ProxyImagen(string archivo)
    {
        this.archivo = archivo;
    }

    public void Mostrar()
    {
        // Carga diferida: solo se crea la imagen real cuando se necesita
        if (imagenReal == null)
        {
            imagenReal = new ImagenReal(archivo);
        }
        imagenReal.Mostrar();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        IImagen imagen = new ProxyImagen("foto_vacaciones.jpg");

        // La imagen aún no se carga desde disco
        Console.WriteLine("Proxy creado, aún no se carga la imagen...");

        // Se carga y muestra solo cuando se necesita
        imagen.Mostrar();
    }
}

Patrones de comportamiento (Behavioral Patterns)

Command

Convierte una solicitud en un objeto independiente que contiene toda la información sobre la misma. Esta transformación permite pasar solicitudes como argumentos de un método, retrasar o poner en cola la ejecución de una solicitud y admitir operaciones que no se pueden deshacer.

Ejemplo:

using System;

// Interfaz Command
public interface ICommand
{
    void Ejecutar();
}

// Receptor
public class Luz
{
    public void Encender() => Console.WriteLine("La luz está encendida");
    public void Apagar() => Console.WriteLine("La luz está apagada");
}

// Comandos concretos
public class EncenderLuzCommand : ICommand
{
    private Luz luz;

    public EncenderLuzCommand(Luz luz)
    {
        this.luz = luz;
    }

    public void Ejecutar()
    {
        luz.Encender();
    }
}

public class ApagarLuzCommand : ICommand
{
    private Luz luz;

    public ApagarLuzCommand(Luz luz)
    {
        this.luz = luz;
    }

    public void Ejecutar()
    {
        luz.Apagar();
    }
}

// Invocador
public class ControlRemoto
{
    private ICommand comando;

    public void SetComando(ICommand comando)
    {
        this.comando = comando;
    }

    public void PresionarBoton()
    {
        comando.Ejecutar();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        Luz sala = new Luz();

        ICommand encender = new EncenderLuzCommand(sala);
        ICommand apagar = new ApagarLuzCommand(sala);

        ControlRemoto control = new ControlRemoto();

        control.SetComando(encender);
        control.PresionarBoton(); // La luz está encendida

        control.SetComando(apagar);
        control.PresionarBoton(); // La luz está apagada
    }
}

Observer

Permite definir un mecanismo de suscripción para notificar a varios objetos sobre cualquier evento que ocurra en el objeto que están observando.

Ejemplo:

using System;
using System.Collections.Generic;

// Interfaz del observador
public interface IObservador
{
    void Actualizar(float temperatura);
}

// Sujeto
public class EstacionClima
{
    private List<IObservador> observadores = new List<IObservador>();
    private float temperatura;

    public void Registrar(IObservador observador)
    {
        observadores.Add(observador);
    }

    public void Remover(IObservador observador)
    {
        observadores.Remove(observador);
    }

    public void SetTemperatura(float nuevaTemperatura)
    {
        temperatura = nuevaTemperatura;
        Notificar();
    }

    private void Notificar()
    {
        foreach (var obs in observadores)
        {
            obs.Actualizar(temperatura);
        }
    }
}

// Observadores concretos
public class PantallaCelular : IObservador
{
    public void Actualizar(float temperatura)
    {
        Console.WriteLine($"[Celular] Temperatura actual: {temperatura}°C");
    }
}

public class PantallaPC : IObservador
{
    public void Actualizar(float temperatura)
    {
        Console.WriteLine($"[PC] Temperatura actual: {temperatura}°C");
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        EstacionClima estacion = new EstacionClima();

        IObservador celular = new PantallaCelular();
        IObservador pc = new PantallaPC();

        estacion.Registrar(celular);
        estacion.Registrar(pc);

        estacion.SetTemperatura(25.5f);
        estacion.SetTemperatura(30.0f);
    }
}

Strategy

Permite definir una familia de algoritmos, colocar cada uno de ellos en una clase separada y hacer que sus objetos sean intercambiables.

Ejemplo:

using System;

// Estrategia (Strategy)
public interface IPago
{
    void Pagar(double monto);
}

// Estrategias concretas
public class PagoTarjeta : IPago
{
    public void Pagar(double monto)
    {
        Console.WriteLine($"Pagando {monto} con tarjeta de crédito.");
    }
}

public class PagoPayPal : IPago
{
    public void Pagar(double monto)
    {
        Console.WriteLine($"Pagando {monto} con PayPal.");
    }
}

public class PagoEfectivo : IPago
{
    public void Pagar(double monto)
    {
        Console.WriteLine($"Pagando {monto} en efectivo.");
    }
}

// Contexto
public class CarritoCompras
{
    private IPago estrategiaPago;

    public void SetEstrategiaPago(IPago estrategia)
    {
        estrategiaPago = estrategia;
    }

    public void ProcesarCompra(double monto)
    {
        if (estrategiaPago == null)
        {
            Console.WriteLine("No se ha definido una estrategia de pago.");
            return;
        }
        estrategiaPago.Pagar(monto);
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        CarritoCompras carrito = new CarritoCompras();

        carrito.SetEstrategiaPago(new PagoTarjeta());
        carrito.ProcesarCompra(500);

        carrito.SetEstrategiaPago(new PagoPayPal());
        carrito.ProcesarCompra(300);

        carrito.SetEstrategiaPago(new PagoEfectivo());
        carrito.ProcesarCompra(150);
    }
}

State

Permite que un objeto altere su comportamiento cuando cambia su estado interno. Parece como si el objeto hubiera cambiado de clase.

Ejemplo:

using System;

// Interfaz Estado
public interface IEstadoCafe
{
    void PresionarBoton();
}

// Estados concretos
public class EstadoSinMoneda : IEstadoCafe
{
    public void PresionarBoton()
    {
        Console.WriteLine("Inserta una moneda primero.");
    }
}

public class EstadoConMoneda : IEstadoCafe
{
    public void PresionarBoton()
    {
        Console.WriteLine("Preparando café...");
    }
}

// Contexto
public class MaquinaCafe
{
    private IEstadoCafe estado;

    public MaquinaCafe()
    {
        estado = new EstadoSinMoneda();
    }

    public void InsertarMoneda()
    {
        Console.WriteLine("Moneda insertada.");
        estado = new EstadoConMoneda();
    }

    public void PresionarBoton()
    {
        estado.PresionarBoton();
        // Después de servir café, vuelve al estado inicial
        estado = new EstadoSinMoneda();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        MaquinaCafe maquina = new MaquinaCafe();

        maquina.PresionarBoton(); // Inserta una moneda primero
        maquina.InsertarMoneda(); // Moneda insertada
        maquina.PresionarBoton(); // Preparando café...
        maquina.PresionarBoton(); // Inserta una moneda primero
    }
}

Template Method

Define el esqueleto de un algoritmo en la superclase, pero permite que las subclases anulen pasos específicos del algoritmo sin cambiar su estructura.

Ejemplo:

using System;

// Clase abstracta con el método plantilla
public abstract class BebidaCaliente
{
    // Método plantilla
    public void Preparar()
    {
        HervirAgua();
        PrepararInfusion();
        ServirEnTaza();
        AgregarExtras();
    }

    private void HervirAgua()
    {
        Console.WriteLine("Hirviendo agua...");
    }

    private void ServirEnTaza()
    {
        Console.WriteLine("Sirviendo en la taza...");
    }

    // Métodos abstractos que las subclases deben implementar
    protected abstract void PrepararInfusion();
    protected abstract void AgregarExtras();
}

// Subclase concreta: Té
public class Te : BebidaCaliente
{
    protected override void PrepararInfusion()
    {
        Console.WriteLine("Colocando bolsita de té...");
    }

    protected override void AgregarExtras()
    {
        Console.WriteLine("Agregando limón.");
    }
}

// Subclase concreta: Café
public class Cafe : BebidaCaliente
{
    protected override void PrepararInfusion()
    {
        Console.WriteLine("Agregando café molido al filtro...");
    }

    protected override void AgregarExtras()
    {
        Console.WriteLine("Agregando azúcar y leche.");
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        BebidaCaliente te = new Te();
        Console.WriteLine("Preparando té:");
        te.Preparar();

        Console.WriteLine();

        BebidaCaliente cafe = new Cafe();
        Console.WriteLine("Preparando café:");
        cafe.Preparar();
    }
}

Visitor

Permite separar los algoritmos de los objetos sobre los que operan.

Ejemplo:

using System;
using System.Collections.Generic;

// Interfaz del Visitor
public interface IVisitor
{
    void VisitarCirculo(Circulo circulo);
    void VisitarCuadrado(Cuadrado cuadrado);
}

// Elemento abstracto
public interface IFigura
{
    void Aceptar(IVisitor visitor);
}

// Elementos concretos
public class Circulo : IFigura
{
    public int Radio { get; set; }

    public Circulo(int radio)
    {
        Radio = radio;
    }

    public void Aceptar(IVisitor visitor)
    {
        visitor.VisitarCirculo(this);
    }
}

public class Cuadrado : IFigura
{
    public int Lado { get; set; }

    public Cuadrado(int lado)
    {
        Lado = lado;
    }

    public void Aceptar(IVisitor visitor)
    {
        visitor.VisitarCuadrado(this);
    }
}

// Visitor concreto: calcular área
public class VisitorArea : IVisitor
{
    public void VisitarCirculo(Circulo circulo)
    {
        double area = Math.PI * circulo.Radio * circulo.Radio;
        Console.WriteLine($"Área del círculo: {area}");
    }

    public void VisitarCuadrado(Cuadrado cuadrado)
    {
        double area = cuadrado.Lado * cuadrado.Lado;
        Console.WriteLine($"Área del cuadrado: {area}");
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        List<IFigura> figuras = new List<IFigura>
        {
            new Circulo(5),
            new Cuadrado(4)
        };

        IVisitor visitorArea = new VisitorArea();

        foreach (var figura in figuras)
        {
            figura.Aceptar(visitorArea);
        }
    }
}

Chain of Responsibility

Permite que las solicitudes se transmitan a través de una cadena de manejadores. Al recibir una solicitud, cada manejador decide si la procesa o la pasa al siguiente manejador de la cadena.

Ejemplo:

using System;

// Interfaz Handler
public abstract class Aprobador
{
    protected Aprobador siguiente;

    public void SetSiguiente(Aprobador aprobador)
    {
        siguiente = aprobador;
    }

    public abstract void ProcesarSolicitud(double monto);
}

// Handlers concretos
public class Jefe : Aprobador
{
    public override void ProcesarSolicitud(double monto)
    {
        if (monto <= 1000)
        {
            Console.WriteLine($"Jefe aprueba gasto de {monto}.");
        }
        else if (siguiente != null)
        {
            siguiente.ProcesarSolicitud(monto);
        }
    }
}

public class Gerente : Aprobador
{
    public override void ProcesarSolicitud(double monto)
    {
        if (monto <= 5000)
        {
            Console.WriteLine($"Gerente aprueba gasto de {monto}.");
        }
        else if (siguiente != null)
        {
            siguiente.ProcesarSolicitud(monto);
        }
    }
}

public class Director : Aprobador
{
    public override void ProcesarSolicitud(double monto)
    {
        if (monto <= 20000)
        {
            Console.WriteLine($"Director aprueba gasto de {monto}.");
        }
        else
        {
            Console.WriteLine($"Solicitud de {monto} requiere junta directiva.");
        }
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        // Crear la cadena de responsabilidad
        Aprobador jefe = new Jefe();
        Aprobador gerente = new Gerente();
        Aprobador director = new Director();

        jefe.SetSiguiente(gerente);
        gerente.SetSiguiente(director);

        // Probar solicitudes
        jefe.ProcesarSolicitud(500);    // Jefe aprueba
        jefe.ProcesarSolicitud(3000);   // Gerente aprueba
        jefe.ProcesarSolicitud(15000);  // Director aprueba
        jefe.ProcesarSolicitud(50000);  // Junta directiva
    }
}

Memento

Permite guardar y restaurar el estado anterior de un objeto sin revelar los detalles de su implementación.

Ejemplo:

using System;
using System.Collections.Generic;

// Memento: guarda el estado
public class Memento
{
    public string Estado { get; }

    public Memento(string estado)
    {
        Estado = estado;
    }
}

// Originator: crea y restaura mementos
public class EditorTexto
{
    public string Texto { get; set; }

    public Memento Guardar()
    {
        return new Memento(Texto);
    }

    public void Restaurar(Memento memento)
    {
        Texto = memento.Estado;
    }
}

// Caretaker: administra los mementos
public class Historial
{
    private Stack<Memento> estados = new Stack<Memento>();

    public void Agregar(Memento memento)
    {
        estados.Push(memento);
    }

    public Memento Deshacer()
    {
        return estados.Pop();
    }
}

// Uso del patrón
class Program
{
    static void Main()
    {
        EditorTexto editor = new EditorTexto();
        Historial historial = new Historial();

        editor.Texto = "Versión 1";
        historial.Agregar(editor.Guardar());

        editor.Texto = "Versión 2";
        historial.Agregar(editor.Guardar());

        editor.Texto = "Versión 3";
        Console.WriteLine($"Texto actual: {editor.Texto}");

        // Deshacer
        editor.Restaurar(historial.Deshacer());
        Console.WriteLine($"Después de deshacer: {editor.Texto}");

        editor.Restaurar(historial.Deshacer());
        Console.WriteLine($"Después de deshacer otra vez: {editor.Texto}");
    }
}

Importancia de los patrones de diseño

  • Ayudan a resolver problemas comunes de forma probada y reutilizable, además hacen que el código sea más limpio, flexible y profesional.
  • Mejoran la organización del código.
  • Facilitan el mantenimiento y la escalabilidad.
  • Promueven buenas prácticas de desarrollo.
  • Permiten que otros desarrolladores entiendan más rápido el sistema.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://comunidadcityjavamex.blogspot.com/2026/06/java-tip-32-patrones-de-diseno-en-java.html
https://refactoring.guru/design-patterns/csharp


miércoles, 17 de junio de 2026

Programando en C# no. 15: ASP .NET Core

Recordemos lo que es .NET:

".NET es una plataforma de desarrollo gratuita, multiplataforma y de código abierto para crear diversos tipos de aplicaciones".
"Con .NET, puedes usar múltiples lenguajes, editores y bibliotecas para desarrollar aplicaciones web, móviles, de escritorio, juegos, IoT y mucho más".

En entregas pasadas vimos una comparativa entre Spring Boot y ASP .NET Core. Ahora veremos cómo crear una aplicación sencilla usando ésta tecnología.

Nos enfocaremos en las API mínimas para ASP.NET Core.

Las API mínimas son un enfoque simplificado para crear API HTTP rápidas con ASP.NET Core.

Puedes crear endpoints REST completamente funcionales con un mínimo de código y configuración. Evita el uso de la estructura tradicional y los controladores innecesarios declarando de forma fluida las rutas y acciones de la API.

API mínima en ASP .NET Core

Las API mínimas están diseñadas para crear API HTTP con dependencias mínimas. Son ideales para microservicios y aplicaciones que desean incluir solo los archivos, las características y las dependencias mínimas en ASP .NET Core.

Ventajas de ASP .NET Core:

  • Serialización sencilla: ASP.NET se diseñó para experiencias web modernas. Los puntos de conexión serializan automáticamente las clases en JSON con el formato correcto de serie. No se necesita ninguna configuración especial. Puede personalizar la serialización para los puntos de conexión que tienen requisitos únicos. 
  • Autenticación y autorización: para la seguridad, los puntos de conexión de API tienen compatibilidad integrada con tokens web JSON (JWT) estándar del sector. La autorización basada en directivas ofrece la flexibilidad necesaria para definir reglas de control de acceso eficaces en el código. 
  • Enrutamiento junto con el código: ASP.NET permite definir rutas y verbos alineados con el código mediante atributos. Los datos de la ruta de acceso de la solicitud, la cadena de consulta y el cuerpo de la solicitud se enlazan automáticamente a parámetros de método. 
  • HTTPS de forma predeterminada: HTTPS es una parte importante de las API web modernas y profesionales. Se basa en el cifrado de un extremo a otro para proporcionar privacidad y ayudar a garantizar que las llamadas API no se intercepten ni se modifiquen entre el cliente y el servidor.

Creando una minimal API con .NET

1. Abrimos una terminal y tecleamos:

$ dotnet --version
$ dotnet --list-sdks

Con esto obtenemos la versión de ``dotnet`` y los SDKs instalados.

2. Creamos un sencillo proyecto webapi:

$ dotnet new webapi -o MyApiSimple
$ cd MyApiSimple

Esto creará el proyecto tipo webapi y nos ubicará en el directorio principal del proyecto.

3. Modificamos el contenido del programa principal para que tenga solo lo necesario.

Program.cs

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/hola",()=> Results.Ok("alive"));

app.Run();

4. Modificamos el archivo ``MyApiSimple.http``:

@MyApiSimple_HostAddress = http://localhost:5058

GET {{MyApiSimple_HostAddress}}/hola/
Accept: application/json

###

El archivo de configuración ``MyApiSimple.csproj`` lucirá así:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.1" />
  </ItemGroup>

</Project>

5. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/hola

Si todo va bien, entonces mostrará el siguiente mensaje:

alive

Continuemos.

Consumiendo una API

Lo siguiente a realizar es consumir una API externa. En este caso la del sitio: https://api.chucknorris.io/

Será una aplicación modular por lo que nuestro proyecto lucirá de esta manera:

MyApiSimple/
│
├── Program.cs
├── Services/
│   └── ChuckService.cs
├── Models/
│   └── ChuckJoke.cs

1. Crearemos una clase sencilla en el directorio Models:

ChuckJoke.cs

namespace MyApiSimple.Models
{
    public class ChuckJoke
    {
        public string? value { get; set; }
    }
}

Esta clase representa la respuesta JSON de la API.

2. Ahora crearemos la clase tipo service en el directorio Services:

ChuckService.cs

using System.Text.Json;
using MyApiSimple.Models;

namespace MyApiSimple.Services
{
    public class ChuckService
    {
        private readonly HttpClient _httpClient;

        public ChuckService(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<ChuckJoke?> GetRandomJokeAsync()
        {
            var url = "https://api.chucknorris.io/jokes/random?category=food";

            var response = await _httpClient.GetAsync(url);

            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            var content = await response.Content.ReadAsStringAsync();

            return JsonSerializer.Deserialize<ChuckJoke>(content);
        }
    }
}

Esta clase tipo service nos ayudará a encapsular la llamada HTTP.

3. Modificamos la clase principal, registrando el servicio y definiendo los endpoints:

Program.cs

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddHttpClient<ChuckService>();

var app = builder.Build();

app.MapGet("/hola", () => Results.Ok("alive"));


app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    if (joke == null)
    {
        return Results.Problem("Error al obtener el chiste");
    }

    return Results.Ok(joke);
});

app.Run();

4. Modificamos el archivo ``MyApiSimple.http``:

@MyApiSimple_HostAddress = http://localhost:5058

GET {{MyApiSimple_HostAddress}}/hola/
Accept: application/json


GET {{MyApiSimple_HostAddress}}/joke
Accept: application/json

###

5. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/joke

Si todo va bien, entonces mostrará algún mensaje (aleatorio):

{
"value": "Most tough men eat nails for breakfast. Chuck Norris does all of his grocery shopping at Home Depot."
}

Agregaremos Swagger.

6. Modificamos el programa ``Program.cs``:

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient<ChuckService>();
builder.Services.AddOpenApi(); 

var app = builder.Build();


if (app.Environment.IsDevelopment())
{
    app.MapOpenApi(); 
}

app.MapGet("/hola", () => Results.Ok("alive"))
   .WithName("Hola")
   .WithOpenApi();

app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    if (joke == null)
    {
        return Results.Problem("Error al obtener el chiste");
    }

    return Results.Ok(joke);
})
.WithName("GetJoke")
.WithOpenApi();

app.Run();

7. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Abrimos un navegador en la ruta: http://localhost:5058/openapi/v1.json

Esto es para ver el OpenAPI JSON, cuya salida será:

{
"openapi": "3.1.1",
"info": {
"title": "MyApiSimple | v1",
"version": "1.0.0"
},
"servers": [
{
"url": "http://localhost:5058/"
}
],
"paths": {
"/hola": {
"get": {
"tags": [
"MyApiSimple"
],
"operationId": "Hola",
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/joke": {
"get": {
"tags": [
"MyApiSimple"
],
"operationId": "GetJoke",
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"tags": [
{
"name": "MyApiSimple"
}
]
}

8. Agregar Swagger UI:

$ dotnet add package Swashbuckle.AspNetCore

9. Modificaremos el programa principal:

Program.cs

using MyApiSimple.Services;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddHttpClient<ChuckService>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();


if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapGet("/hola", () => Results.Ok("alive"))
   .WithName("Hola");

app.MapGet("/joke", async (ChuckService chuckService) =>
{
    var joke = await chuckService.GetRandomJokeAsync();

    return joke is not null 
        ? Results.Ok(joke)
        : Results.Problem("Error al obtener el chiste");
})
.WithName("GetJoke");

app.Run();

10. Construimos y ejecutamos:

$ dotnet build
$ dotnet run

Si todo va bien, abrimos el navegador en la ruta: http://localhost:5058/swagger

Lucirá de esta manera:

¡Hemos creado un proyecto WebApi con ASP .NET Core!

Continuaremos en próximas entregas hablando de este tema.

Enlaces:

https://codemonkeyjunior.blogspot.com/2019/05/crear-una-aplicacion-web-con-asp-net.html
https://codemonkeyjunior.blogspot.com/2025/11/el-roadmap-para-ser-desarrollador-c.html
https://codemonkeyjunior.blogspot.com/2025/11/asp-net-core-vs-spring-boot-cual-elegir.html
https://codemonkeyjunior.blogspot.com/2025/11/programando-en-c-no-12-asp-net-core.html
https://codemonkeyjunior.blogspot.com/2025/12/equivalencias-entre-un-proyecto-spring.html
https://dotnet.microsoft.com/en-us/learn/back-end-web-dev
https://www.ibm.com/mx-es/think/topics/api-endpoint
https://www.arsys.es/blog/guia-completa-para-el-diseno-de-restful-api-conceptos-y-mejores-practicas
https://robertdelwood.medium.com/learning-api-documentation-with-chuck-norris-jokes-1414435fb84e

martes, 16 de junio de 2026

Lo que es un agente de IA

En pocas palabras, un agente de IA es una herramienta capaz de automatizar tareas y servirse de otras aplicaciones para desempeñar actividades más complejas o elaboradas.

Estos sistemas autónomos pueden razonar, planificar y ejecutar acciones usando modelos de inteligencia artificial y herramientas externas.

En este blog ya hemos hablado de OpenClaw, un agente de IA de código abierto que actúa como un asistente personal avanzado. Además de OpenCode, un agente de codificación IA de código abierto.

En 2026, los principales agentes y plataformas de IA incluyen ChatGPT, Claude, Gemini, Perplexity, Midjourney, GitHub Copilot y nuevas propuestas como OpenClaw, Claude Cowork y OpenAI Frontier.

Los agentes de IA actúan de manera autónoma para cumplir objetivos, combinando:

  • Razonamiento (decidir qué hacer). 
  • Planificación (organizar pasos). 
  • Acción (usar herramientas, APIs o interactuar con usuarios).

La diferencia entre un chatbot y un agente de IA es que mientras un chatbot responde preguntas, un agente puede tomar decisiones, ejecutar tareas y coordinar múltiples recursos.

Comparativa entre agentes IA

Observemos la siguiente tabla:

Agente/Plataforma Tipo Fortalezas Ideal para
ChatGPT (OpenAI) Asistente conversacional Versatilidad, plugins, memoria Uso general, escritura, código
Claude (Anthropic) Asistente con contexto largo Manejo de documentos extensos, análisis profundo Profesionales, investigación
Gemini (Google) Multimodal integrado Conexión con ecosistema Google, búsqueda avanzada Productividad, integración empresarial
Perplexity Computer Agente en la nube Investigación con fuentes verificables Profesionales sin perfil técnico
Midjourney / DALL-E 3 Generadores de imágenes Creatividad visual, arte digital Diseño, marketing
GitHub Copilot Asistente de programación Autocompletado, sugerencias de código Desarrolladores
OpenClaw Agente personal self-hosted Control local, bajo costo Makers, usuarios avanzados
Claude Cowork Agente desktop con plugins Integración empresarial Equipos corporativos
OpenAI Frontier Plataforma enterprise Seguridad y escalabilidad Grandes empresas, sectores regulados
Kimi K2.5 Modelo multimodal Procesamiento masivo, swarm agents Investigación avanzada

Agentes IA y el Vibe Coding

En este blog hemos hablado de algunos aspectos positivos y negativos de las herramientas IA.

Un profesional puede servirse de estás herramientas para automatizar procesos y mejorar su productividad.

Una persona no profesional puede creer que se convertirá en profesional debido a ilusión que ofrece el uso de éstas.

Las empresas actualmente cuentan con licencias para sus empleados pues consideran que mejorará la productividad (y sus ingresos).

Hoy en día existen herramientas IA (agentes) especializados en investigación, programación, diseño, productividad y automatización.

Consideraciones y riesgos

Algunas cosas a tomar en consideración pueden ser:

  • Privacidad: Los agentes que operan en la nube requieren políticas claras de seguridad (ej. OpenAI Frontier cumple con SOC 2 e ISO 27001). 
  • Costo: Algunos agentes son gratuitos (self-hosted), pero los empresariales pueden costar cientos de dólares al mes. 
  • Madurez tecnológica: Herramientas como PicoClaw aún están en desarrollo y pueden ser inestables.

Hemos visto lo que es un agente de IA. Como se diferencian de un chatbot y las consideraciones en cuanto a la seguridad.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://learn.microsoft.com/es-es/shows/ai-agents-for-beginners/
https://blogthinkbig.com/agentes-de-ia-rapidos-sencillos-automatizar-tareas
https://codemonkeyjunior.blogspot.com/2026/02/opencode-un-agente-para-escribir-codigo.html
https://opencode.ai/
https://codemonkeyjunior.blogspot.com/2026/01/claude-code-un-nuevo-enfoque-de-la.html
https://codemonkeyjunior.blogspot.com/2026/05/vibe-coding-cuando-el-programador-es-un.html

¿Qué lenguaje de programación debes aprender en un mundo con IA?

Las herramientas de IA están matando, literalmente, a la programación. Cualquiera con un Github Copilot, DeepSeek, Chat GPT, etc. pu...

Etiquetas

Archivo del blog