Patrón Facade

import re


# ───── El subsistema: varias clases, cada una con su trabajo ─────
class Validador:
    def dni_valido(self, dni):
        if not re.fullmatch(r"\d{8}[A-Z]", dni):
            return False
        return "TRWAGMYFPDXBNJZSQVHLCKE"[int(dni[:8]) % 23] == dni[8]


class Plazas:
    def __init__(self):
        self._libres = {"DAM": 2, "DAW": 1}

    def reservar(self, ciclo):
        if self._libres.get(ciclo, 0) == 0:
            return False
        self._libres[ciclo] -= 1
        return True


class Expedientes:
    def __init__(self):
        self._siguiente = 1

    def crear(self, nombre, dni, ciclo):
        numero = f"EXP-{self._siguiente:03d}"
        self._siguiente += 1
        return numero


class Correo:
    def enviar(self, destino, texto):
        print(f"  Correo a {destino}: {texto}")


class SecretariaFacade:
    """La fachada: una sola puerta, sencilla, para una operación que usa todo el subsistema."""
    def __init__(self):
        self._validador = Validador()
        self._plazas = Plazas()
        self._expedientes = Expedientes()
        self._correo = Correo()

    def matricular(self, nombre, dni, ciclo):
        if not self._validador.dni_valido(dni):
            print(f"  DNI no válido: {dni}")
            return False
        if not self._plazas.reservar(ciclo):
            print(f"  No quedan plazas en {ciclo}")
            return False
        expediente = self._expedientes.crear(nombre, dni, ciclo)
        self._correo.enviar(nombre, f"matriculado en {ciclo} con el expediente {expediente}")
        return True


secretaria = SecretariaFacade()   # el cliente solo conoce la fachada
for nombre, dni, ciclo in [("Ana", "12345678Z", "DAW"), ("Luis", "12345678A", "DAM"), ("Marta", "00000000T", "DAW")]:
    print(f"Matrícula de {nombre}:")
    print("  Hecha" if secretaria.matricular(nombre, dni, ciclo) else "  Rechazada")

// ───── El subsistema: varias clases, cada una con su trabajo ─────
class Validador {
    dniValido(dni) {
        if (!/^\d{8}[A-Z]$/.test(dni)) return false;
        return "TRWAGMYFPDXBNJZSQVHLCKE"[Number(dni.slice(0, 8)) % 23] === dni[8];
    }
}

class Plazas {
    #libres = new Map([["DAM", 2], ["DAW", 1]]);
    reservar(ciclo) {
        const quedan = this.#libres.get(ciclo) ?? 0;
        if (quedan === 0) return false;
        this.#libres.set(ciclo, quedan - 1);
        return true;
    }
}

class Expedientes {
    #siguiente = 1;
    crear(nombre, dni, ciclo) { return `EXP-${String(this.#siguiente++).padStart(3, "0")}`; }
}

class Correo {
    enviar(destino, texto) { console.log(`  Correo a ${destino}: ${texto}`); }
}

/** La fachada: una sola puerta, sencilla, para una operación que usa todo el subsistema. */
class SecretariaFacade {
    #validador = new Validador();
    #plazas = new Plazas();
    #expedientes = new Expedientes();
    #correo = new Correo();

    matricular(nombre, dni, ciclo) {
        if (!this.#validador.dniValido(dni)) {
            console.log(`  DNI no válido: ${dni}`);
            return false;
        }
        if (!this.#plazas.reservar(ciclo)) {
            console.log(`  No quedan plazas en ${ciclo}`);
            return false;
        }
        const expediente = this.#expedientes.crear(nombre, dni, ciclo);
        this.#correo.enviar(nombre, `matriculado en ${ciclo} con el expediente ${expediente}`);
        return true;
    }
}

const secretaria = new SecretariaFacade();   // el cliente solo conoce la fachada
for (const [nombre, dni, ciclo] of [["Ana", "12345678Z", "DAW"], ["Luis", "12345678A", "DAM"], ["Marta", "00000000T", "DAW"]]) {
    console.log(`Matrícula de ${nombre}:`);
    console.log(secretaria.matricular(nombre, dni, ciclo) ? "  Hecha" : "  Rechazada");
}

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

// ───── El subsistema: varias clases, cada una con su trabajo ─────
class Validador {
    public bool DniValido(string dni) {
        if (!Regex.IsMatch(dni, @"^\d{8}[A-Z]
quot;)) return false;
        return "TRWAGMYFPDXBNJZSQVHLCKE"[int.Parse(dni[..8]) % 23] == dni[8];
    }
}

class Plazas {
    private readonly Dictionary<string, int> libres = new() { ["DAM"] = 2, ["DAW"] = 1 };
    public bool Reservar(string ciclo) {
        int quedan = libres.GetValueOrDefault(ciclo, 0);
        if (quedan == 0) return false;
        libres[ciclo] = quedan - 1;
        return true;
    }
}

class Expedientes {
    private int siguiente = 1;
    public string Crear(string nombre, string dni, string ciclo) => 
quot;EXP-{siguiente++:000}";
}

class Correo {
    public void Enviar(string destino, string texto) => Console.WriteLine(
quot;  Correo a {destino}: {texto}");
}

// La fachada: una sola puerta, sencilla, para una operación que usa todo el subsistema.
class SecretariaFacade {
    private readonly Validador validador = new();
    private readonly Plazas plazas = new();
    private readonly Expedientes expedientes = new();
    private readonly Correo correo = new();

    public bool Matricular(string nombre, string dni, string ciclo) {
        if (!validador.DniValido(dni)) {
            Console.WriteLine(
quot;  DNI no válido: {dni}");
            return false;
        }
        if (!plazas.Reservar(ciclo)) {
            Console.WriteLine(
quot;  No quedan plazas en {ciclo}");
            return false;
        }
        string expediente = expedientes.Crear(nombre, dni, ciclo);
        correo.Enviar(nombre, 
quot;matriculado en {ciclo} con el expediente {expediente}");
        return true;
    }
}

class Program {
    static void Main() {
        var secretaria = new SecretariaFacade();   // el cliente solo conoce la fachada
        var solicitudes = new[] { ("Ana", "12345678Z", "DAW"), ("Luis", "12345678A", "DAM"), ("Marta", "00000000T", "DAW") };
        foreach (var (nombre, dni, ciclo) in solicitudes) {
            Console.WriteLine(
quot;Matrícula de {nombre}:");
            Console.WriteLine(secretaria.Matricular(nombre, dni, ciclo) ? "  Hecha" : "  Rechazada");
        }
    }
}

<?php
// ───── El subsistema: varias clases, cada una con su trabajo ─────
class Validador {
    public function dniValido(string $dni): bool {
        if (!preg_match('/^\d{8}[A-Z]$/', $dni)) return false;
        return "TRWAGMYFPDXBNJZSQVHLCKE"[intval(substr($dni, 0, 8)) % 23] === $dni[8];
    }
}

class Plazas {
    private array $libres = ["DAM" => 2, "DAW" => 1];
    public function reservar(string $ciclo): bool {
        $quedan = $this->libres[$ciclo] ?? 0;
        if ($quedan === 0) return false;
        $this->libres[$ciclo] = $quedan - 1;
        return true;
    }
}

class Expedientes {
    private int $siguiente = 1;
    public function crear(string $nombre, string $dni, string $ciclo): string {
        return sprintf("EXP-%03d", $this->siguiente++);
    }
}

class Correo {
    public function enviar(string $destino, string $texto): void { echo "  Correo a $destino: $texto\n"; }
}

/** La fachada: una sola puerta, sencilla, para una operación que usa todo el subsistema. */
class SecretariaFacade {
    private Validador $validador;
    private Plazas $plazas;
    private Expedientes $expedientes;
    private Correo $correo;

    public function __construct() {
        $this->validador = new Validador();
        $this->plazas = new Plazas();
        $this->expedientes = new Expedientes();
        $this->correo = new Correo();
    }

    public function matricular(string $nombre, string $dni, string $ciclo): bool {
        if (!$this->validador->dniValido($dni)) {
            echo "  DNI no válido: $dni\n";
            return false;
        }
        if (!$this->plazas->reservar($ciclo)) {
            echo "  No quedan plazas en $ciclo\n";
            return false;
        }
        $expediente = $this->expedientes->crear($nombre, $dni, $ciclo);
        $this->correo->enviar($nombre, "matriculado en $ciclo con el expediente $expediente");
        return true;
    }
}

$secretaria = new SecretariaFacade();   // el cliente solo conoce la fachada
foreach ([["Ana", "12345678Z", "DAW"], ["Luis", "12345678A", "DAM"], ["Marta", "00000000T", "DAW"]] as [$nombre, $dni, $ciclo]) {
    echo "Matrícula de $nombre:\n";
    echo $secretaria->matricular($nombre, $dni, $ciclo) ? "  Hecha" : "  Rechazada", "\n";
}

from pathlib import Path

# Path es una fachada: lee o escribe un fichero entero en una línea
lineas = Path("notas.csv").read_text(encoding="utf-8").splitlines()
Path("informe.txt").write_text("Hecho", encoding="utf-8")

# requests es una fachada sobre http.client, sockets, SSL, cookies y redirecciones
import requests
alumnos = requests.get("https://api.ejemplo.com/alumnos", timeout=10).json()

// fetch es una fachada sobre XMLHttpRequest: una llamada en lugar de configurar el objeto paso a paso
const alumnos = await (await fetch("/api/alumnos")).json();

// Sin la fachada:
const xhr = new XMLHttpRequest();
xhr.open("GET", "/api/alumnos");
xhr.responseType = "json";
xhr.onload = () => console.log(xhr.response);
xhr.send();

// File es una fachada: lee o escribe un fichero entero sin abrir flujos a mano
string[] lineas = File.ReadAllLines("notas.csv");
File.WriteAllText("informe.txt", "Hecho");

// En ASP.NET Core, el controlador llama a un servicio (la fachada) que coordina
// repositorios, correo y pagos: public IActionResult Comprar(...) => Ok(_pedidos.Comprar(...));

<?php
// file_get_contents es una fachada: abre, lee y cierra en una llamada (también URLs)
$lineas = file("notas.csv", FILE_IGNORE_NEW_LINES);
file_put_contents("informe.txt", "Hecho");

// En Laravel las «facades» son otra cosa (accesos estáticos al contenedor), pero los servicios
// de una aplicación son fachadas: el controlador llama a $pedidos->comprar(...) y nada más.