Skip to content

12. Programación web

12.1. Descripción general

12.1.1. Protocolos de Internet

Aquí presentamos una introducción a los protocolos de comunicación de Internet, también conocidos como la familia de protocolos TCP/IP (Transmission Control Protocol / Internet Protocol), llamada así por los dos protocolos principales. Conviene que el lector tenga una idea general del funcionamiento de las redes —y en particular de los protocolos TCP/IP— antes de abordar el desarrollo de aplicaciones distribuidas. El curso de 2008 incluía un extracto traducido de la guía de administración «Lan Workplace for DOS» de Novell (principios de la década de 1990). Hemos conservado su estructura y su espíritu, pero lo hemos actualizado: la Internet de 2026 ya no es del todo la de 1990.

El concepto general de crear una red de computadoras heterogéneas surge de investigaciones realizadas por la DARPA (Defense Advanced Research Projects Agency) en Estados Unidos. La DARPA desarrolló el conjunto de protocolos conocido como TCP/IP, que permite que máquinas heterogéneas se comuniquen entre sí. Estos protocolos se probaron en una red llamada ARPAnet, red que más tarde se convirtió en Internet (ARPAnet adoptó TCP/IP el 1 de enero de 1983). Los protocolos TCP/IP definen formatos y reglas de transmisión y recepción que son independientes de la arquitectura de red y del hardware utilizado.

La red diseñada por la DARPA y gestionada por los protocolos TCP/IP es una red de conmutación de paquetes. Una red de este tipo transmite la información en pequeños fragmentos llamados paquetes. Así, si una computadora transmite un archivo grande, este se dividirá en pequeños fragmentos que se envían por la red para ser reensamblados en el destino. TCP/IP define el formato de estos paquetes, incluyendo en particular:

  • el origen del paquete;
  • su destino;
  • su longitud;
  • su tipo.

Los protocolos de Internet se describen en documentos públicos llamados RFC (Request for Comments), publicados por el IETF (Internet Engineering Task Force) y disponibles en www.rfc-editor.org. Citaremos algunos de estos documentos a lo largo de este capítulo.

12.1.2. El modelo OSI

Los protocolos TCP/IP siguen en general el modelo de red abierta conocido como OSI (Open Systems Interconnection Reference Model), definido por la ISO (International Organization for Standardization). Este modelo describe una red ideal en la que la comunicación entre máquinas puede representarse mediante un modelo de siete capas:

Image

Cada capa recibe servicios de la capa inferior y ofrece sus propios servicios a la capa superior. Supongamos que dos aplicaciones ubicadas en máquinas distintas, A y B, quieren comunicarse: lo hacen en la capa de Aplicación. No necesitan conocer todos los detalles del funcionamiento de la red: cada aplicación entrega la información que desea transmitir a la capa inferior, la capa de Presentación. Por lo tanto, la aplicación solo necesita conocer las reglas de interfaz con la capa de Presentación. Una vez que la información está en la capa de Presentación, esta la transmite según otras reglas a la capa de Sesión, y así sucesivamente, hasta que la información llega al medio físico y se transmite físicamente a la máquina de destino. Allí, sufrirá el proceso inverso al que sufrió en la máquina emisora.

En cada capa, el proceso emisor encargado de enviar la información la envía a un proceso receptor de la otra máquina que pertenece a la misma capa. Lo hace según ciertas reglas conocidas como el protocolo de la capa. La comunicación real desciende a través de las capas de la máquina A, atraviesa la red física y luego asciende por las capas de la máquina B; sin embargo, cada capa percibe que se comunica directamente con la capa correspondiente de la otra máquina.

Las funciones de las diferentes capas son las siguientes:

Capa
Función
Física
Asegura la transmisión de bits sobre un medio físico (cable de cobre, cable de fibra óptica, ondas de radio). En este nivel, las consideraciones clave incluyen la codificación de la información en señales y el método de transmisión.
Enlace de datos
Abstrae las características físicas de la capa Física. Divide la información en tramas, detecta (y a veces corrige) los errores de transmisión y gestiona el acceso al medio compartido.
Red
Gestiona la ruta que debe seguir la información enviada por la red. Esto se llama enrutamiento: determinar la ruta que la información debe tomar para llegar a su destino.
Transporte
Permite la comunicación entre dos aplicaciones, mientras que las capas anteriores solo permitían la comunicación entre máquinas. Uno de los servicios que ofrece esta capa es la multiplexación: la capa de transporte utiliza un único enlace de red (de máquina a máquina) para transmitir datos que pertenecen a varias aplicaciones.
Sesión
Ofrece servicios que permiten a una aplicación abrir y mantener una sesión de trabajo en una máquina remota.
Presentación
Estandariza la representación de los datos entre diferentes máquinas. Los datos de la máquina A son «formateados» por la capa de Presentación de la máquina A según un formato estándar antes de enviarse por la red. Una vez que llegan a la capa de Presentación de la máquina de destino B —que los reconoce por su formato estándar—, los datos se reformatean para que la aplicación de la máquina B pueda reconocerlos.
Aplicación
En este nivel se encuentran aplicaciones generalmente cercanas al usuario, como el correo electrónico, la Web o la transferencia de archivos.

12.1.3. El modelo TCP/IP

El modelo OSI es un modelo de referencia que nunca se implementó tal cual. La familia de protocolos TCP/IP, que se ha convertido en el estándar, está organizada en solo cuatro capas:

Image

Las capas de Sesión y de Presentación no existen como tales en TCP/IP: sus funciones, cuando son necesarias, las asumen las propias aplicaciones o protocolos intermedios como TLS (cifrado de los intercambios de datos), que se inserta entre TCP y la aplicación.

La capa de acceso a la red

En las redes de área local, la tecnología dominante hoy en día es Ethernet para las conexiones por cable y Wi-Fi (estándares IEEE 802.11) para las conexiones inalámbricas. El curso de 2008 también trataba Token Ring, una tecnología que ya no se utiliza.

Ethernet es el nombre que recibe una tecnología de red de área local de conmutación de paquetes inventada en Xerox a principios de la década de 1970 y estandarizada por Xerox, Intel y Digital Equipment en 1980, y posteriormente por el IEEE (estándar 802.3). La Ethernet original consistía en un cable coaxial al que se conectaban todas las máquinas (topología de bus), con una velocidad de transmisión de 10 megabits por segundo:

Image

Era una red de difusión: una máquina transmisora enviaba por el cable información que incluía la dirección de la máquina de destino; todas las máquinas conectadas la recibían y solo el destinatario previsto la conservaba. Como varias máquinas podían decidir transmitir al mismo tiempo, había que detectar las colisiones: este era el método Carrier Sense Multiple Access/Collision Detect (CSMA/CD). Cada transmisor escuchaba el cable antes de transmitir (CSMA) y, mientras transmitía, verificaba que lo que circulaba por el cable fuera efectivamente lo que había transmitido; de lo contrario, se había producido una colisión (CD): cada uno dejaba de transmitir y volvía a intentarlo tras un retardo aleatorio.

La Ethernet moderna ha evolucionado considerablemente: los dispositivos se conectan mediante cables de par trenzado o de fibra óptica a un conmutador (switch), que dirige cada trama al puerto específico del destinatario. Las conexiones son full-duplex (transmisión y recepción simultáneas): ya no hay colisiones y CSMA/CD ha quedado obsoleto. Las velocidades típicas van de 1 a 10 gigabits por segundo, y mucho más en los centros de datos.

Lo que no ha cambiado es el direccionamiento de 48 bits: cada tarjeta de red tiene una dirección, llamada dirección física o dirección MAC (Media Access Control), generalmente escrita como seis bytes hexadecimales (por ejemplo, [00:1A:2B:3C:4D:5E]). Es incorporada a la tarjeta por el fabricante pero, contrariamente a lo que se afirmaba en el curso de 2008, puede modificarse por software: los sistemas operativos actuales incluso usan direcciones MAC aleatorias en las redes Wi-Fi para evitar que un dispositivo sea rastreado de una red a otra.

La capa de Internet (capa de red)

En esta capa se encuentran los siguientes protocolos:

Protocolo
Función
IP (Internet Protocol)
entrega paquetes entre dos nodos de la red, en la versión 4 (IPv4) o 6 (IPv6)
ICMP (Internet Control Message Protocol)
facilita la comunicación entre el programa del protocolo IP de una máquina y el de otra máquina. Es, por lo tanto, un protocolo de intercambio de mensajes de control dentro del propio protocolo IP
ARP (Address Resolution Protocol)
asocia la dirección IP de una máquina con la dirección física de la máquina (en IPv6, esta función la cumple el protocolo NDP, Neighbor Discovery Protocol)

El curso de 2008 también mencionaba RARP (Reverse Address Resolution Protocol), que realizaba la asociación inversa. Hace mucho que está obsoleto en favor de DHCP, del que hablaremos más adelante.

La capa de transporte

Esta capa incluye los siguientes protocolos:

Protocolo
Función
TCP (Transmission Control Protocol)
asegura la entrega confiable y ordenada de la información entre dos aplicaciones
UDP (User Datagram Protocol)
realiza una entrega no confiable de la información entre dos aplicaciones

El protocolo QUIC (2021), en el que se basa HTTP/3, es un protocolo de transporte confiable y cifrado construido sobre UDP.

La capa de aplicación

Aquí encontramos diversos protocolos, que detallaremos un poco más adelante:

Protocolo
Función
HTTP, HTTPS (HyperText Transfer Protocol)
El protocolo de la Web: un cliente (navegador, aplicación) solicita recursos a un servidor web. HTTPS es HTTP cifrado mediante TLS
DNS (Domain Name System)
convierte el nombre de una máquina en una dirección IP
SMTP (Simple Mail Transfer Protocol)
permite el envío de correos electrónicos
POP3, IMAP
permiten leer el correo electrónico almacenado en un servidor
SSH (Secure Shell)
permite conectarse a una máquina remota y ejecutar comandos en ella, mediante cifrado. Reemplazó a TELNET, que cumplía la misma función sin cifrado
FTP (File Transfer Protocol), SFTP
permiten la transferencia de archivos
DHCP (Dynamic Host Configuration Protocol)
permite que una máquina obtenga automáticamente su dirección IP y su configuración de red

12.1.4. Cómo funcionan los protocolos de Internet

Las aplicaciones desarrolladas en el entorno TCP/IP suelen usar varios de los protocolos de este entorno. Un programa de aplicación se comunica con la capa más alta de los protocolos. Esta capa pasa la información a la capa inferior, y así sucesivamente, hasta que llega al medio físico. Allí, la información se transfiere físicamente a la máquina receptora, donde atravesará las mismas capas, esta vez en orden inverso, hasta llegar a la aplicación destinataria de la información enviada. El siguiente diagrama muestra el recorrido de la información:

Image

Veamos un ejemplo: una aplicación que envía un archivo a otra máquina mediante TCP.

  • La aplicación entrega una secuencia de bytes que se debe transmitir a la capa de transporte;
  • la capa de transporte divide esta secuencia de bytes en segmentos TCP y agrega al comienzo de cada segmento un encabezado que contiene, entre otras cosas, los números de puerto de origen y de destino, así como un número de secuencia. Los segmentos se pasan a la capa de red, que se rige por el protocolo IP;
  • La capa IP crea un paquete que encapsula el segmento TCP recibido. En el encabezado de este paquete coloca las direcciones IP de las máquinas de origen y de destino. También determina la dirección física de la máquina a la que debe entregarse el paquete (la propia máquina de destino o un enrutador). El paquete completo se pasa a la capa de acceso a la red, es decir, a la tarjeta de red que conecta la máquina con la red física;
  • allí, el paquete IP se encapsula a su vez en una trama física y se envía a su destinatario por el medio;
  • En la máquina de destino, la capa de acceso a la red realiza el proceso inverso: desencapsula el paquete IP de la trama física y lo pasa a la capa IP;
  • la capa IP verifica que el paquete sea válido: calcula una suma de verificación de su encabezado, que debe coincidir con la que figura en el encabezado del paquete. Si no es así, el paquete se descarta;
  • si el paquete se considera válido, la capa IP desencapsula el segmento TCP que contiene y lo pasa hacia arriba, a la capa de transporte;
  • la capa TCP también verifica una suma de verificación del segmento. Si es correcta, envía un acuse de recibo a la máquina de origen; de lo contrario, el segmento se ignora (y el origen lo reenviará);
  • Mediante los números de secuencia, la capa TCP reordena los segmentos en el orden correcto;
  • a la capa TCP solo le queda transmitir la porción de datos de los segmentos a la aplicación de destino, identificada por el número de puerto de destino.

12.1.5. Problemas de direccionamiento en Internet

Un nodo de red puede ser una computadora, una impresora, un teléfono, un dispositivo conectado; en realidad, cualquier cosa que pueda comunicarse mediante los protocolos TCP/IP. Cada nodo tiene una dirección física cuyo formato depende del tipo de red. En una red Ethernet o Wi-Fi, la dirección física se codifica con 6 bytes.

La dirección de Internet (IP) de un nodo es una dirección lógica: es independiente del hardware y de la red utilizada. En IPv4, es una dirección de 4 bytes que identifica a la vez una red y un nodo de esa red. Suele representarse como cuatro números (los valores de los cuatro bytes) separados por un punto. Por ejemplo, en 2008, la dirección de la máquina llamada «Lagaffe» de la Facultad de Ciencias de Angers era 193.49.144.1, y la de la máquina llamada «Liny» era 193.49.144.9. De esto se podía deducir que la dirección de la red local era 193.49.144.0 y que podía haber hasta 254 nodos en esa red.

Como las direcciones IP son independientes de la red física, una computadora de la red A puede comunicarse con una computadora de la red B sin preocuparse por el tipo de red en que esta se encuentra: solo necesita conocer su dirección IP. El protocolo IP de cada red se encarga de la conversión entre direcciones IP y direcciones físicas, en ambos sentidos.

Todas las direcciones IP públicas deben ser únicas. Su asignación sigue una estructura jerárquica: la IANA (Internet Assigned Numbers Authority) distribuye bloques de direcciones a cinco registros regionales, entre ellos el RIPE NCC para Europa, que los redistribuyen a operadores y grandes organizaciones. Estas entidades las asignan luego a sus clientes. El administrador de una red que ha recibido el bloque de 193.49.144.0 a 193.49.144.255 puede asignar las direcciones de 193.49.144.1 a 193.49.144.254 como mejor le parezca. El curso de 2008 indicaba que en Francia, el INRIA era el responsable de asignar las direcciones; hace mucho que ya no es así.

12.1.5.1. Clases de direcciones IP y notación CIDR

Una dirección IPv4 es una secuencia de 4 bytes escrita como I1.I2.I3.I4, que en realidad contiene dos datos:

  • la dirección de la red (los bits más significativos);
  • la dirección de un nodo dentro de esa red (los bits menos significativos).

Originalmente, el tamaño de estos dos campos lo determinaba el valor del primer byte. Las direcciones IP se dividían en tres clases principales:

Clase
Primer byte
Red / Nodo
Número de redes y de nodos
A
1 a 126 (bit más significativo 0)
R1.N1.N2.N3: red de 1 byte (7 bits significativos), nodo de 3 bytes
126 redes de 2²⁴ - 2 nodos (aproximadamente 16 millones)
B
128 a 191 (bits más significativos 10)
R1.R2.N1.N2: red de 2 bytes (14 bits significativos), nodo de 2 bytes
2¹⁴ = 16 384 redes de 2¹⁶ - 2 = 65 534 nodos
C
192 a 223 (bits más significativos 110)
R1.R2.R3.N1: red de 3 bytes (21 bits significativos), nodo de 1 byte
2²¹ redes (aproximadamente 2 millones) con 254 nodos

Como la dirección de la máquina Lagaffe es 193.49.144.1, el byte más significativo es 193, que en binario es 11000001: la red era una red de clase C.

Esta clasificación resultó ser demasiado rígida: una organización con 300 máquinas debía usar una red de clase B, desperdiciando más de 65 000 direcciones. Desde 1993 (RFC 1518 y 1519), las clases se abandonaron en favor del enrutamiento sin clases (CIDR, Classless Inter-Domain Routing). El límite entre la parte de red y la parte de host puede fijarse en cualquier bit; se indica mediante la longitud del prefijo de red, después de una barra:

  • 193.49.144.0/24: los primeros 24 bits designan la red y los últimos 8 bits designan el nodo. Esta red contiene las direcciones de 193.49.144.0 a 193.49.144.255;
  • 10.0.0.0/8: una red con 2²⁴ direcciones;
  • 192.168.1.0/26: una red de 2⁶ = 64 direcciones, que van de 192.168.1.0 a 192.168.1.63.

Todavía se utiliza la notación antigua de la máscara de subred, que expresa lo mismo: el prefijo /24 corresponde a la máscara 255.255.255.0. Los términos «clase A, B, C» siguen siendo de uso común, pero ya no corresponden a ningún mecanismo real.

12.1.5.2. Direcciones reservadas, direcciones privadas y NAT

Ciertas direcciones tienen un propósito específico:

  • una dirección cuya parte de host está formada enteramente por 0 se refiere a la red misma: 193.49.144.0 es la dirección de la red 193.49.144.0/24;
  • una dirección cuya parte de host está formada enteramente por 1 es una dirección de difusión (broadcast): 193.49.144.255 se refiere a todos los hosts de la red 193.49.144.0/24. Por lo tanto, estas dos direcciones no pueden asignarse a un nodo: una red /24 con 256 direcciones ofrece solo 254 direcciones utilizables;
  • las direcciones 127.0.0.0/8, y en la práctica 127.0.0.1, son direcciones de bucle local (loopback): una máquina las usa para referirse a sí misma sin pasar por la red. El nombre [localhost] está asociado a ellas;
  • los bloques 10.0.0.0/8, 172.16.0.0/12 y 192.168.0.0/16 (RFC 1918) están reservados para redes privadas: pueden usarse libremente dentro de una empresa o un hogar, pero no se enrutan en Internet;
  • los bloques 192.0.2.0/24, 198.51.100.0/24 y 203.0.113.0/24 (RFC 5737) están reservados para documentación y ejemplos.

La cantidad de direcciones IPv4 (2³², es decir, poco más de 4000 millones) es insuficiente para todas las máquinas conectadas. El conjunto central de direcciones de la IANA se agotó en 2011 y el del RIPE NCC en 2019. La escasez se sorteó mediante la traducción de direcciones de red (NAT, Network Address Translation): los dispositivos de un hogar tienen direcciones privadas (como 192.168.1.x), y el enrutador que los conecta a Internet las «traduce» a su propia dirección pública única. La solución a largo plazo es IPv6.

12.1.5.3. Direcciones IPv6

IPv6 (RFC 2460 en 1998, ahora RFC 8200) codifica las direcciones con 128 bits, lo que da 2¹²⁸ direcciones posibles (aproximadamente 3,4 × 10³⁸), de modo que ya no hay que preocuparse por la escasez. Una dirección IPv6 se escribe como ocho grupos de cuatro dígitos hexadecimales separados por dos puntos:

2001:0db8:0000:0000:8a2e:0000:0370:7334

Los ceros iniciales de cada grupo pueden omitirse, y una única secuencia de grupos de ceros puede reemplazarse por [::]. Por lo tanto, la dirección anterior se escribe como [2001:db8::8a2e:0:370:7334]. La dirección de bucle local, equivalente a 127.0.0.1, es [::1]. En una URL, una dirección IPv6 se coloca entre corchetes para no confundir sus dos puntos con los que preceden al puerto: [http://[::1]:8080/].

IPv6 introduce otras simplificaciones: el encabezado del paquete tiene longitud fija, la configuración automática de direcciones está incorporada de forma predeterminada y la traducción de direcciones NAT ya no es necesaria. Su adopción ha sido lenta, pero una parte significativa y creciente del tráfico de Internet ya circula por IPv6 (Google, por ejemplo, publica la proporción de sus usuarios que acceden mediante IPv6), y los principales proveedores de acceso franceses lo ofrecen a sus abonados. Ambas versiones coexisten: la mayoría de las máquinas tienen direcciones IPv4 e IPv6 (esto se denomina «doble pila», dual stack), y los programas deben poder manejar ambas.

12.1.5.4. Protocolos de conversión entre direcciones IP y direcciones físicas

Hemos visto que cuando se transmiten datos de una máquina a otra, al pasar por la capa IP se encapsulan en paquetes. Estos paquetes tienen la siguiente forma:

Image

Por lo tanto, el paquete IP contiene las direcciones IP de las máquinas de origen y de destino. Cuando este paquete se transmite a la capa encargada de enviarlo por la red física, se agrega información adicional para formar la trama física que finalmente se enviará por la red. Por ejemplo, el formato de una trama en una red Ethernet es el siguiente:

Image

Los primeros 8 bytes (preámbulo) sirven para la sincronización; el campo de 2 bytes que precede a los datos indica, en la forma más común de la trama Ethernet, el tipo de protocolo transportado (IPv4, IPv6, ARP…) en lugar de la longitud del paquete. En la trama final, figuran las direcciones físicas de las máquinas de origen y de destino (en la trama real, la dirección de destino precede a la de origen, a diferencia del orden mostrado en el diagrama). ¿Cómo se obtienen?

La máquina emisora, que conoce la dirección IP de la máquina con la que desea comunicarse, obtiene la dirección física de esa máquina mediante el protocolo ARP (Address Resolution Protocol):

  • envía un tipo especial de paquete, llamado paquete ARP, que contiene la dirección IP de la máquina cuya dirección física se busca. También incluye su propia dirección IP, así como su dirección física;
  • este paquete se envía a todos los nodos de la red local (difusión);
  • estos nodos reconocen la naturaleza especial del paquete. El nodo que reconoce su dirección IP en el paquete responde enviando su dirección física al emisor. Puede hacerlo porque encontró en el paquete la dirección IP y la dirección física del emisor;
  • Así, el emisor recibe la dirección física que buscaba. La almacena en una caché para poder usarla más adelante si hay que enviar otros paquetes al mismo destinatario.

En IPv6, el mismo servicio lo proporciona el protocolo NDP (Neighbor Discovery Protocol), que se basa en mensajes ICMPv6.

Queda una pregunta: ¿cómo conoce una máquina su propia dirección IP? Puede especificarse en un archivo de configuración de la máquina; esta sigue siendo la práctica habitual en los servidores. Sin embargo, cuando un administrador necesita reorganizar la red, modificar uno por uno los archivos de configuración de cada máquina es tedioso y propenso a errores. El curso de 2008 presentaba el protocolo RARP, mediante el cual una máquina solicitaba su dirección IP a un servidor a partir de su dirección física. Fue reemplazado por DHCP (Dynamic Host Configuration Protocol, RFC 2131): al iniciarse, la máquina difunde una solicitud por la red; un servidor (como un enrutador doméstico o un servidor dedicado en una empresa) le asigna una dirección por un tiempo limitado (una concesión o lease), junto con el resto de su configuración: prefijo de red, dirección del enrutador y direcciones de los servidores DNS. Entonces, al administrador le basta con configurar el servidor DHCP. En IPv6, un dispositivo también puede construir su propia dirección a partir del prefijo anunciado por el enrutador (autoconfiguración SLAAC).

12.1.6. La capa de red, llamada capa IP, de Internet

El protocolo IP define el formato que deben tener los paquetes y cómo deben tratarse al enviarse o recibirse. Este tipo particular de paquete se llama datagrama IP. Ya hemos hablado de él:

Image

Lo importante es que, además de los datos que se van a transmitir, el datagrama IP contiene las direcciones IP de las máquinas de origen y de destino. De este modo, la máquina de destino sabe quién le envía un mensaje.

A diferencia de una trama de red, cuya longitud está determinada por las características físicas de la red por la que viaja, la longitud del datagrama IP la fija el software y, por lo tanto, será la misma en distintas redes físicas. Hemos visto que, al descender de la capa de red a la capa física, el datagrama IP se encapsula en una trama física.

Las tramas físicas viajan de nodo en nodo hacia su destino, que puede no estar en la misma red física que la máquina emisora. Por lo tanto, el paquete IP puede encapsularse sucesivamente en distintas tramas físicas en los nodos que conectan dos redes de tipos diferentes. También es posible que el paquete IP sea demasiado grande para encapsularse en una trama física (la carga útil de una trama Ethernet está limitada a 1500 bytes). En IPv4, el nodo donde ocurre este problema divide entonces el paquete IP en fragmentos, que solo se reensamblarán en su destino final. En IPv6, los enrutadores ya no fragmentan los paquetes: corresponde al emisor determinar el tamaño máximo aceptado a lo largo de la ruta y ajustar en consecuencia el tamaño de sus paquetes.

12.1.6.1. Enrutamiento

El enrutamiento es el método para dirigir los paquetes IP hacia su destino. Hay dos métodos: el enrutamiento directo y el enrutamiento indirecto.

Enrutamiento directo

El enrutamiento directo se refiere a la transmisión de un paquete IP directamente del emisor al destinatario dentro de la misma red:

  • la máquina que envía un datagrama IP tiene la dirección IP del destinatario;
  • obtiene la dirección física del destinatario mediante el protocolo ARP, o de su caché si esa dirección ya se obtuvo;
  • envía el paquete por la red a esa dirección física.

Enrutamiento indirecto

El enrutamiento indirecto se refiere a la transmisión de un paquete IP a un destino ubicado en una red distinta de aquella a la que pertenece el emisor. En este caso, las partes de «red» de las direcciones IP de las máquinas de origen y de destino son diferentes; la máquina de origen lo detecta comparando la dirección de destino con su propio prefijo de red. Entonces envía el paquete a un nodo especial llamado enrutador, que conecta la red local con otras redes y cuya dirección IP conoce la máquina de origen (esto se llama puerta de enlace predeterminada; que normalmente proporciona DHCP). Un enrutador está conectado al menos a dos redes y tiene una dirección IP en cada una de ellas:

Image

En nuestro ejemplo anterior:

  • La red n.º 1 tiene la dirección 193.49.144.0/24 y la red n.º 2 tiene la dirección 193.49.145.0/24;
  • dentro de la red n.º 1, el enrutador tiene la dirección 193.49.144.6, y dentro de la red n.º 2, tiene la dirección 193.49.145.3.

La función del enrutador es tomar el paquete IP que recibe, contenido en una trama física de la red n.º 1, y colocarlo en una trama física que pueda viajar por la red n.º 2. Si la dirección IP de destino del paquete está en la red n.º 2, el enrutador le enviará el paquete directamente; de lo contrario, lo enviará a otro enrutador que conecte la red n.º 2 con la red n.º 3, y así sucesivamente. Los enrutadores de Internet intercambian constantemente información sobre las redes a las que pueden llegar (protocolos de enrutamiento como BGP entre operadores) para construir sus tablas de enrutamiento.

12.1.6.2. Mensajes de error y de control

También en la capa de red, y por lo tanto al mismo nivel que el protocolo IP, se encuentra el protocolo ICMP (Internet Control Message Protocol). Se usa para enviar mensajes sobre el funcionamiento interno de la red: nodo inalcanzable, paquete que ha atravesado demasiados enrutadores, etc. Los mensajes ICMP se encapsulan en paquetes IP y se envían por la red. Las capas IP de los distintos nodos toman las medidas apropiadas según los mensajes ICMP que reciben. Así, una aplicación nunca ve estos problemas propios de la red. Los comandos [ping] (que envían mensajes ICMP «Echo Request» y esperan mensajes «Echo Reply») y [traceroute] / [tracert] (que muestran los enrutadores atravesados) se basan en ICMP.

12.1.7. La capa de transporte: los protocolos UDP y TCP

12.1.7.1. El protocolo UDP: User Datagram Protocol

El protocolo UDP permite un intercambio no confiable de datos entre dos puntos; es decir, no se garantiza que un paquete llegue con éxito a su destino, ni el orden en que llegan los paquetes. La aplicación, si lo desea, puede encargarse de ello por sí misma; por ejemplo, esperando un acuse de recibo después de enviar un mensaje antes de enviar el siguiente.

Hasta ahora, a nivel de red, hemos hablado de las direcciones IP de las máquinas. Sin embargo, en una misma máquina pueden coexistir simultáneamente diferentes procesos, y todos ellos pueden comunicarse entre sí. Por lo tanto, al enviar un mensaje, hay que especificar no solo la dirección IP de la máquina de destino, sino también el «nombre» del proceso de destino. Este nombre es en realidad un número de 16 bits (de 1 a 65 535), llamado número de puerto. Ciertos números están reservados para aplicaciones estándar: el puerto 53 para DNS, el 80 para HTTP, el 443 para HTTPS, el 25 para SMTP, etc. Los puertos inferiores a 1024 se denominan «bien conocidos»; en Linux, se requieren privilegios especiales para abrir un servicio en alguno de ellos. Los ejemplos de este capítulo usan puertos de los rangos 27100–27199 y 27200–27299.

Los paquetes manejados por el protocolo UDP se denominan datagramas. Tienen la siguiente forma:

Image

Estos datagramas se encapsulan en paquetes IP y luego en tramas físicas. UDP se usa cuando la velocidad es más importante que la confiabilidad, o cuando la aplicación gestiona por sí misma la pérdida de paquetes: DNS (una pregunta, una respuesta), la transmisión de audio y video en directo, los juegos en línea y el protocolo QUIC de HTTP/3.

12.1.7.2. El protocolo TCP: Transmission Control Protocol

Para comunicaciones seguras, el protocolo UDP es insuficiente: el desarrollador de la aplicación debe crear por sí mismo un protocolo que asegure que los paquetes se encaminen correctamente. El protocolo TCP evita estos problemas. Sus características son las siguientes:

  • El proceso que desea transmitir datos primero establece una conexión con el proceso que recibirá la información que está a punto de transmitir. Esta conexión se establece entre un puerto de la máquina emisora y un puerto de la máquina receptora mediante un intercambio de tres segmentos (SYN, SYN-ACK, ACK: el «saludo de tres vías», three-way handshake). Así se crea un circuito virtual entre los dos puertos, que quedará reservado exclusivamente para los dos procesos que establecieron la conexión;
  • todos los bytes transmitidos por el proceso de origen llegan a su destino en el orden en que se transmitieron, lo cual el protocolo UDP no garantiza, ya que los paquetes pueden seguir rutas distintas;
  • La información transmitida es continua: es un flujo de bytes. El proceso transmisor envía la información a su propio ritmo. Esta información no se envía necesariamente de inmediato: el protocolo TCP puede esperar hasta tener suficientes datos para enviar. Los datos se colocan en una estructura llamada segmento TCP. Una vez lleno este segmento, se transmite a la capa IP, donde se encapsula en un paquete IP. Una consecuencia importante para el programador: una «línea» enviada de una sola vez puede llegar en varios fragmentos, y varias líneas pueden llegar juntas. Corresponde a la aplicación identificar los límites de sus mensajes (para ello usaremos el carácter de fin de línea);
  • Cada segmento enviado por el protocolo TCP está numerado. El protocolo TCP receptor verifica que recibe los segmentos en secuencia. Por cada segmento recibido correctamente, envía un acuse de recibo al emisor;
  • si, transcurrido cierto tiempo, el protocolo TCP que envió un segmento no recibe un acuse de recibo, retransmite el segmento en cuestión, garantizando así la calidad del servicio de entrega de la información;
  • El circuito virtual establecido entre los dos procesos que se comunican es full-duplex: la información puede circular en ambos sentidos de forma simultánea. Así, el proceso de destino puede enviar acuses de recibo incluso mientras el proceso de origen continúa enviando información. Esto permite, por ejemplo, que el protocolo TCP de origen envíe varios segmentos sin esperar los acuses de recibo. Si, transcurrido cierto tiempo, se da cuenta de que no ha recibido el acuse de recibo de un segmento determinado, el n.º n, reanudará la transmisión de segmentos a partir de ese punto;
  • TCP también regula su velocidad de transmisión de datos para evitar saturar al receptor (control de flujo) o a la red (control de congestión).

12.1.8. La capa de aplicación

Por encima de los protocolos UDP y TCP existen diversos protocolos estándar:

TELNET y SSH

TELNET permite que un usuario de la máquina A se conecte a la máquina B (a menudo llamada máquina host) como si tuviera un terminal conectado a esa máquina. TELNET se basa en TCP. Sus intercambios de datos, incluidas las contraseñas, se transmiten en texto plano: ha sido reemplazado por SSH (Secure Shell), que ofrece el mismo servicio de forma cifrada y que también se utiliza para la transferencia segura de archivos (SFTP, SCP) y para crear túneles. En 2008, el programa cliente [telnet] seguía siendo una herramienta cómoda para comunicarse “manualmente” con un servidor TCP: veremos cómo reemplazarlo.

FTP (File Transfer Protocol)

Este protocolo permite el intercambio de archivos entre dos máquinas remotas, así como operaciones sobre archivos, como la creación de directorios. Se basa en el protocolo TCP. Al igual que TELNET, transmite las contraseñas en texto plano; está siendo abandonado en favor de SFTP y HTTPS.

TFTP (Trivial File Transfer Protocol)

Este protocolo es una variante simplificada de FTP. Se basa en el protocolo UDP. Todavía se utiliza para arrancar máquinas a través de la red.

DNS (Domain Name System)

Cuando un usuario desea intercambiar información con una máquina remota, debe conocer la dirección IP de esa máquina. Resulta mucho más cómodo designar una máquina por un nombre que por su dirección IP. Esto plantea el problema de la unicidad de los nombres: hay miles de millones de máquinas interconectadas. Se podría imaginar una autoridad centralizada que asignara los nombres, pero sería muy engorroso. El control de los nombres se ha distribuido en dominios. Cada dominio está gestionado por una organización que tiene plena libertad para elegir los nombres dentro de su dominio. Así, las máquinas de Francia suelen pertenecer al dominio [fr], gestionado por AFNIC (INRIA lo gestionó hasta la creación de AFNIC en 1997). Para simplificar aún más las cosas, el control se distribuye todavía más: se crean dominios dentro del dominio [fr]. Por ejemplo, la Universidad de Angers posee el dominio [univ-angers.fr]; el departamento que lo administra tiene plena libertad para nombrar las computadoras de la red de la universidad y para crear subdominios.

El nombre completo de una máquina (FQDN, Fully Qualified Domain Name) especifica la jerarquía de dominios a la que pertenece, de lo más específico a lo más general: [www.univ-angers.fr]. Dentro de un dominio, a menudo se pueden usar nombres relativos, que el sistema completa automáticamente.

Por lo tanto, una aplicación puede referirse a una máquina por su nombre. Sin embargo, en última instancia aún es necesario obtener la dirección IP de esa máquina. Supongamos que se desea establecer comunicación desde la máquina A hacia la máquina B:

  • La máquina A consulta primero un archivo local de correspondencias ([/etc/hosts] en Linux y macOS, [C:\Windows\System32\drivers\etc\hosts] en Windows), y luego su caché;
  • de lo contrario, consulta al servidor DNS, cuya dirección figura en su configuración (generalmente proporcionada por DHCP). Envía una solicitud DNS que contiene el nombre de la máquina buscada. Si el servidor consultado conoce la respuesta o la tiene en caché, devuelve la dirección IP correspondiente a la máquina A. De lo contrario, consulta a su vez —a partir de los servidores raíz— a los servidores responsables del dominio [fr], luego de [univ-angers.fr], y así sucesivamente, hasta obtener la respuesta, que luego se retransmitirá hasta la máquina A.

El dominio DNS asocia diversos tipos de registros a un nombre: A (dirección IPv4), AAAA (dirección IPv6), CNAME (alias de otro nombre), MX (servidores de correo del dominio), etc.

HTTP y HTTPS (HyperText Transfer Protocol)

Este es el protocolo de la Web, y por mucho el más utilizado hoy en día: no solo por los navegadores, sino también por las aplicaciones que intercambian datos (los servicios web que se tratan en el próximo capítulo). Lo examinaremos en detalle. HTTPS es HTTP transmitido por una conexión cifrada mediante TLS (Transport Layer Security); esta es actualmente la forma estándar de la Web.

SMTP, POP3 e IMAP

SMTP sirve para enviar correos electrónicos, mientras que POP3 e IMAP sirven para leer los correos almacenados en un servidor. También los trataremos.

XDR, RPC, NFS

El curso de 2008 también abordaba tres protocolos definidos por Sun Microsystems: XDR (eXternal Data Representation), que especifica una representación de datos estándar e independiente de la máquina; RPC (Remote Procedure Call), un protocolo de llamada a procedimientos remotos basado en XDR; NFS (Network File System), que permite que una máquina “vea” el sistema de archivos de otra máquina y se basa en RPC. NFS sigue en uso en el mundo Unix. El concepto de llamada a procedimientos remotos ha sido adoptado por numerosos sucesores; hoy en día, entre ellos se encuentran los servicios web REST (basados en HTTP) y gRPC (basado en HTTP/2).

12.1.9. Conclusión

En esta introducción hemos presentado algunas de las principales características de los protocolos de Internet. Para profundizar en este campo, el lector puede consultar la obra de referencia de Douglas Comer, “Internetworking with TCP/IP, Volume 1” (Pearson, 6.ª edición) —cuyas ediciones anteriores se tradujeron al francés—, así como las RFC citadas en este capítulo. En cuanto a HTTP, la documentación de Mozilla en developer.mozilla.org/en-US/docs/Web/HTTP es una excelente introducción.

12.2. Las clases de .NET para la gestión de direcciones IP

Una máquina en Internet se identifica mediante una dirección IP, que puede adoptar dos formas:

  • IPv4: codificada en 32 bits y representada por una cadena de la forma "I1.I2.I3.I4", donde In es un número entre 0 y 255;
  • IPv6: codificada en 128 bits y representada por una cadena de ocho grupos de dígitos hexadecimales separados por dos puntos, como "2001:db8::8a2e:370:7334". El curso de 2008 anunciaba que no utilizaría direcciones IPv6; hoy en día esto ya no es posible: nuestros programas las aceptarán.

Una máquina también puede identificarse mediante un nombre. Este nombre no es obligatorio, ya que las aplicaciones siempre utilizan, en última instancia, las direcciones IP de las máquinas. Los nombres están ahí para facilitar la vida de los usuarios: es más fácil pedirle a un navegador la URL [https://learn.microsoft.com] que la URL formada a partir de una de las direcciones IP de este sitio, la cual, por cierto, cambia según el lugar desde el que se hace la solicitud.

Una máquina puede tener varias direcciones IP: una dirección de loopback, una dirección por cada red a la que esté conectada, y direcciones IPv4 e IPv6.

En .NET, una dirección IP puede representarse de dos maneras:

  • como una cadena "I1.I2.I3.I4" o "2001:db8::1";
  • como un objeto de tipo [IPAddress] (espacio de nombres [System.Net]).

La clase IPAddress

Entre los métodos M, las propiedades P y los campos estáticos F de la clase [IPAddress] se encuentran los siguientes:

Miembro
Tipo
Función
AddressFamily AddressFamily
P
familia de la dirección IP. El tipo [AddressFamily] (espacio de nombres [System.Net.Sockets]) es una enumeración cuyos dos valores actuales son [AddressFamily.InterNetwork] (IPv4) y [AddressFamily.InterNetworkV6] (IPv6)
static IPAddress Any
F
la dirección IPv4 0.0.0.0. Cuando un servicio se asocia a esta dirección, acepta clientes en todas las direcciones IPv4 de la máquina
static IPAddress Loopback
F
la dirección de loopback 127.0.0.1. Un servicio asociado a esta dirección acepta únicamente clientes ubicados en la misma máquina que él
static IPAddress Broadcast
F
la dirección de difusión (broadcast) 255.255.255.255 ([IPAddress.None] tiene el mismo valor)
static IPAddress IPv6Any, IPv6Loopback
F
los equivalentes en IPv6 de [Any] (::) y [Loopback] (::1)
static IPAddress Parse(string ipString)
M
convierte una cadena IPv4 o IPv6 en un objeto [IPAddress]; lanza una [FormatException] si la cadena no es una dirección IP
static bool TryParse(string ipString, out IPAddress address)
M
Igual que el anterior, pero devuelve [false] en lugar de lanzar una excepción
static bool IsLoopback(IPAddress address)
M
devuelve [true] si la dirección es una dirección de loopback (127.x.y.z o ::1)
byte[] GetAddressBytes()
M
devuelve los bytes de la dirección (4 en IPv4, 16 en IPv6)
string ToString()
M
devuelve la dirección en su forma textual estándar

Otros dos tipos complementan a [IPAddress]:

  • [IPEndPoint] representa un punto de conexión: una dirección IP y un número de puerto. Sus propiedades [Address] y [Port] proporcionan estos dos datos; el método estático [IPEndPoint.Parse] analiza una cadena como "127.0.0.1:27100" o "[::1]:27100";
  • [IPNetwork] (desde .NET 8) representa una red en notación CIDR, como 193.49.144.0/24. Su método [Contains] determina si una dirección pertenece a la red.

El programa [internet-01.cs] ilustra estos tres tipos:

using System.Net;
using System.Net.Sockets;

// las clases IPAddress, IPEndPoint e IPNetwork

// direcciones IPv4 e IPv6, correctas o no
string[] addresses = ["193.49.144.1", "127.0.0.1", "192.168.1", "::1",
    "2001:db8::8a2e:370:7334", "256.1.1.1", "machine"];
foreach (string str in addresses)
{
    // TryParse: no hay excepción si la cadena no es una dirección IP
    if (IPAddress.TryParse(str, out IPAddress? address))
    {
        string family = address.AddressFamily == AddressFamily.InterNetwork ? "IPv4" : "IPv6";
        string bytes = Convert.ToHexString(address.GetAddressBytes());
        int nbBytes = address.GetAddressBytes().Length;
        bool loopback = IPAddress.IsLoopback(address);
        Console.WriteLine($"[{str}] -> {address} ({family}, {nbBytes} bytes: {bytes}, loopback: {loopback})");
    }
    else
    {
        Console.WriteLine($"[{str}] is not an IP address");
    }
}

// Parse lanza una excepción si la cadena es incorrecta
try
{
    IPAddress.Parse("256.1.1.1");
}
catch (FormatException ex)
{
    Console.WriteLine($"Parse(\"256.1.1.1\"): {ex.GetType().Name} : {ex.Message}");
}

// algunas direcciones predefinidas
Console.WriteLine($"Any={IPAddress.Any}, Loopback={IPAddress.Loopback}, Broadcast={IPAddress.Broadcast}");
Console.WriteLine($"IPv6Any={IPAddress.IPv6Any}, IPv6Loopback={IPAddress.IPv6Loopback}");

// un endpoint = una dirección IP + un puerto
var point = new IPEndPoint(IPAddress.Loopback, 27100);
Console.WriteLine($"IPEndPoint: {point} (address={point.Address}, port={point.Port})");
var point6 = IPEndPoint.Parse("[::1]:27100");
Console.WriteLine($"IPv6 IPEndPoint: {point6} (address={point6.Address}, port={point6.Port})");

// una red en notación CIDR: dirección de red / longitud del prefijo
var network = IPNetwork.Parse("193.49.144.0/24");
string[] machines = ["193.49.144.1", "193.49.145.3"];
foreach (string str in machines)
{
    Console.WriteLine($"{str} belongs to {network}: {network.Contains(IPAddress.Parse(str))}");
}

Resultados:

> dotnet run internet-01.cs
[193.49.144.1] -> 193.49.144.1 (IPv4, 4 bytes: C1319001, loopback: False)
[127.0.0.1] -> 127.0.0.1 (IPv4, 4 bytes: 7F000001, loopback: True)
[192.168.1] -> 192.168.0.1 (IPv4, 4 bytes: C0A80001, loopback: False)
[::1] -> ::1 (IPv6, 16 bytes: 00000000000000000000000000000001, loopback: True)
[2001:db8::8a2e:370:7334] -> 2001:db8::8a2e:370:7334 (IPv6, 16 bytes: 20010DB80000000000008A2E03707334, loopback: False)
[256.1.1.1] is not an IP address
[machine] is not an IP address
Parse("256.1.1.1"): FormatException : An invalid IP address was specified.
Any=0.0.0.0, Loopback=127.0.0.1, Broadcast=255.255.255.255
IPv6Any=::, IPv6Loopback=::1
IPEndPoint: 127.0.0.1:27100 (address=127.0.0.1, port=27100)
IPv6 IPEndPoint: [::1]:27100 (address=::1, port=27100)
193.49.144.1 belongs to 193.49.144.0/24: True
193.49.145.3 belongs to 193.49.144.0/24: False

Comentarios:

  • línea 7: una expresión de colección inicializa el arreglo de cadenas que se van a analizar;
  • línea 12: [TryParse] devuelve [true] si la cadena es una dirección IPv4 o IPv6 y, en ese caso, asigna el objeto [IPAddress] resultante a la variable [address]. El tipo que admite valores nulos [IPAddress?] indica que esta variable toma el valor [null] cuando el análisis falla;
  • línea 14: la propiedad [AddressFamily] distingue entre las dos versiones de IP;
  • línea 15: [GetAddressBytes] devuelve los bytes de la dirección, que [Convert.ToHexString] muestra en hexadecimal. Se observa (línea 2 de los resultados) que 193.49.144.1 está formada por los cuatro bytes C1, 31, 90, 01, y (línea 5) que ::1 está formada por 15 bytes en cero seguidos de un byte con valor 1;
  • Línea 4 de los resultados: una sorpresa. La cadena "192.168.1" fue aceptada y convertida en 192.168.0.1. [TryParse] acepta, en efecto, las formas abreviadas históricas de las direcciones IPv4 (en cuyo caso el último número ocupa todos los bytes restantes). Por lo tanto, para verificar que una entrada es una dirección IPv4 completa, también hay que comprobar que contenga cuatro números;
  • línea 6: la dirección IPv6 se vuelve a mostrar en su forma compacta estandarizada. El prefijo 2001:db8::/32 está reservado para documentación, al igual que 192.0.2.0/24 en IPv4;
  • líneas 27–31: [IPAddress.Parse] genera una [FormatException] para la cadena “256.1.1.1” (256 no cabe en un solo byte). Como en todo el curso, el mensaje de la excepción está en inglés (.NET no ofrece una traducción al francés);
  • línea 41: un objeto [IPEndPoint] asocia una dirección y un puerto. Su visualización (línea 12 de los resultados) tiene la forma dirección:puerto; en IPv6 (línea 13), la dirección se encierra entre corchetes;
  • línea 47: una red en notación CIDR. Las líneas 14–15 de los resultados muestran que 193.49.144.1 pertenece a la red 193.49.144.0/24 y que 193.49.145.3 (la dirección del enrutador de nuestro diagrama, en su segunda red) no pertenece a ella. Esta es exactamente la prueba que realiza una máquina para elegir entre enrutamiento directo e indirecto.

La clase Dns

La correspondencia entre la dirección IP y el nombre de la máquina la gestiona DNS. Los métodos estáticos de la clase [Dns] (espacio de nombres [System.Net]) permiten consultarlo:

Método
Función
Task<IPHostEntry> GetHostEntryAsync(string hostNameOrAddress)
Devuelve un objeto [IPHostEntry] a partir del nombre de una máquina o de una dirección IP en forma de cadena. Lanza una [SocketException] si no se encuentra la máquina
Task<IPHostEntry> GetHostEntryAsync(IPAddress address)
Igual que el anterior, pero a partir de un objeto [IPAddress]
Task<IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress)
devuelve únicamente las direcciones IP de la máquina
string GetHostName()
devuelve el nombre de la máquina en la que se ejecuta el programa

Cada uno de estos métodos asíncronos tiene una versión síncrona ([GetHostEntry], [GetHostAddresses]), que se utilizaba en el curso de 2008. Una solicitud DNS puede tardar varias decenas de milisegundos, o incluso varios segundos si un servidor no responde: como vimos en el capítulo sobre programación asíncrona, es preferible no bloquear un hilo mientras se espera.

Un objeto [IPHostEntry] encapsula direcciones IP, alias y el nombre de una máquina:

Propiedad
Tipo
Función
IPAddress[] AddressList
P
arreglo de direcciones IP de la máquina
string[] Aliases
P
otros nombres de la máquina conocidos por el sistema (a menudo vacío)
string HostName
P
el nombre principal de la máquina

El programa [internet-02.cs] muestra el nombre de la máquina en la que se ejecuta y luego lista de forma interactiva las correspondencias entre el nombre de la máquina y las direcciones IP:

using System.Net;
using System.Net.Sockets;

// muestra el nombre de la máquina local
// y luego da información de forma interactiva sobre las máquinas de la red
// identificadas por un nombre o una dirección IP

// máquina local
Console.WriteLine($"Local machine = {Dns.GetHostName()}");

// preguntas y respuestas interactivas
while (true)
{
    // entrada del nombre o de la dirección IP de la máquina buscada
    Console.Write("Machine looked for (nothing to stop): ");
    string machine = (Console.ReadLine() ?? "").Trim().ToLower();
    // ¿terminó?
    if (machine == "")
    {
        break;
    }
    try
    {
        // consulta (asíncrona) al DNS
        IPHostEntry entry = await Dns.GetHostEntryAsync(machine);
        // el nombre de la máquina
        Console.WriteLine($"Machine: {entry.HostName}");
        // sus direcciones IP
        Console.WriteLine($"IP addresses: {string.Join(", ", entry.AddressList.Select(ip => ip.ToString()))}");
        // sus posibles alias
        if (entry.Aliases.Length != 0)
        {
            Console.WriteLine($"Aliases: {string.Join(", ", entry.Aliases)}");
        }
    }
    catch (SocketException ex)
    {
        // no se encontró la máquina
        Console.WriteLine($"Unable to find the machine [{machine}]: {ex.SocketErrorCode} ({ex.Message})");
    }
}

Resultados:

> dotnet run internet-02.cs
Local machine = vm
Machine looked for (nothing to stop): localhost
Machine: localhost
IP addresses: 127.0.0.1
Machine looked for (nothing to stop): vm
Machine: vm
IP addresses: 127.0.0.1, 192.0.2.2
Machine looked for (nothing to stop): 127.0.0.1
Machine: localhost
IP addresses: 127.0.0.1
Machine looked for (nothing to stop): ::1
Unable to find the machine [::1]: HostNotFound (Name or service not known)
Machine looked for (nothing to stop): xx
Unable to find the machine [xx]: HostNotFound (Name or service not known)
Machine looked for (nothing to stop): 

Comentarios:

  • línea 9: el nombre de la máquina local. Nuestra máquina de pruebas es una máquina virtual Linux llamada [vm]; para el lector, este será, por supuesto, el nombre de su propia computadora;
  • línea 25: la consulta DNS asíncrona. Si el nombre (o la dirección) es desconocido, se lanza una [SocketException]; su propiedad [SocketErrorCode] (línea 39) indica la naturaleza del error mediante una enumeración, que es más fácil de evaluar que el mensaje;
  • línea 29: las direcciones IP de la máquina se combinan en una sola cadena mediante [string.Join], después de convertirlas en cadenas con [Select] (LINQ).

Los resultados merecen algunos comentarios. Dependen de la configuración de la máquina: no espere obtener exactamente los mismos resultados en su propio sistema.

  • Línea 4: el nombre [localhost] corresponde a la dirección de loopback 127.0.0.1. En una máquina donde IPv6 está activo, también se obtendría ::1;
  • Línea 8: el nombre de la máquina corresponde a dos direcciones: la dirección de loopback y la dirección de su interfaz de red. En una máquina Windows llamada PC y conectada a un enrutador, normalmente se obtendría una dirección privada de la forma 192.168.x.y y una o más direcciones IPv6;
  • línea 9: dada una dirección IP, [GetHostEntryAsync] realiza una búsqueda “inversa” y devuelve el nombre asociado a la dirección;
  • línea 13: la búsqueda inversa de ::1 falló porque el archivo [/etc/hosts] de nuestra máquina de pruebas no asocia ningún nombre a esta dirección, y allí no hay ninguna interfaz IPv6 activa. En Windows, se devolvería el nombre de la máquina;
  • línea 15: el nombre [xx] es desconocido. El mensaje de la excepción proviene aquí de la biblioteca del sistema Linux; sería diferente en Windows, pero [SocketErrorCode] equivale a [HostNotFound] en ambos casos.

En una máquina conectada a Internet, también se puede consultar un nombre público como [learn.microsoft.com]. En general, esto devuelve un nombre principal distinto del nombre solicitado (el sitio es servido por una red de distribución de contenido y el nombre solicitado es un alias DNS) junto con direcciones que varían según la ubicación y el momento de la solicitud. No reproducimos este resultado, ya que nuestra máquina de pruebas no tiene acceso a Internet.

12.3. Fundamentos de la programación web

12.3.1. Visión general

Consideremos la comunicación entre dos máquinas remotas, A y B:

Image

Cuando una aplicación AppA de la máquina A desea comunicarse con una aplicación AppB de la máquina B en Internet, debe conocer varias cosas:

  • la dirección IP o el nombre de la máquina B;
  • el número de puerto utilizado por la aplicación AppB. Esto se debe a que la máquina B puede alojar muchas aplicaciones que funcionan en Internet. Cuando recibe información de la red, debe saber a qué aplicación está destinada. Las aplicaciones de la máquina B acceden a la red a través de interfaces llamadas puertos de comunicación. El número de puerto de destino está contenido en el segmento recibido por la máquina B para que pueda entregarse a la aplicación correcta;
  • los protocolos de comunicación que entiende la máquina B. En nuestro estudio, utilizaremos únicamente los protocolos TCP/IP;
  • el protocolo de comunicación que admite la aplicación AppB. En efecto, las máquinas A y B “conversarán” entre sí. Lo que se digan estará encapsulado en los protocolos TCP/IP. Sin embargo, cuando la aplicación AppB, al final de la cadena, recibe la información enviada por la aplicación AppA, debe poder interpretarla. Es análogo a una situación en la que dos personas, A y B, se comunican por teléfono: su conversación se transporta por la línea telefónica, pero si A habla francés y B no entiende ese idioma, A y B no podrán mantener una conversación con sentido. Por lo tanto, las dos aplicaciones que se comunican deben ponerse de acuerdo sobre el tipo de comunicación que utilizarán. Por ejemplo, la comunicación con un servidor web no es la misma que con un servidor de correo: estos dos servicios no aceptan los mismos comandos. Tienen protocolos de comunicación diferentes.

12.3.2. Características del protocolo TCP

Aquí nos centraremos únicamente en las comunicaciones de red que utilizan el protocolo de transporte TCP. Repasemos sus características clave para los programadores:

  • Primero se establece una conexión entre un puerto de la máquina cliente y un puerto de la máquina servidor. Se identifica mediante cuatro datos: la dirección IP y el puerto del cliente, y la dirección IP y el puerto del servidor;
  • la conexión transporta dos flujos de bytes, uno en cada sentido (full-duplex). Los bytes llegan en el orden en que fueron transmitidos, sin pérdida ni duplicación;
  • TCP no conoce el concepto de mensaje: corresponde al protocolo de comunicación de la aplicación delimitar las solicitudes y las respuestas (mediante un salto de línea, una longitud especificada, el cierre de la conexión, etc.);
  • Una de las dos partes cierra la conexión; la otra lo detecta cuando llega al final del flujo de lectura.

12.3.3. La relación cliente-servidor

La comunicación por Internet suele ser asimétrica: la máquina A inicia una conexión para solicitar un servicio a la máquina B. Especifica que desea establecer una conexión con el servicio SB1 de la máquina B. La máquina B acepta o rechaza la solicitud. Si la acepta, la máquina A puede enviar sus solicitudes al servicio SB1. Estas solicitudes deben cumplir con el protocolo de comunicación que entiende el servicio SB1. Se establece así un diálogo de solicitud-respuesta entre la máquina A, llamada máquina cliente, y la máquina B, llamada máquina servidor. Uno de los dos interlocutores cerrará la conexión.

12.3.4. Arquitectura del cliente

La arquitectura de un programa de red que solicita los servicios de una aplicación servidor será la siguiente:

open the connection with the SB1 service of machine B
if successful then
    while not finished
        prepare a request
        send it to machine B
        wait for and retrieve the response
        process it
    end while
end if
close the connection

12.3.5. Arquitectura del servidor

La arquitectura de un programa que ofrece servicios será la siguiente:

1
2
3
4
5
6
open the service on the local machine
while the service is open
    listen for connection requests on a port called the listening port
    when there is a request, accept it and have the resulting connection
        (service connection) handled by another task
end while

El programa servidor trata de manera diferente la solicitud inicial de conexión de un cliente y sus solicitudes posteriores de servicio. El programa que escucha no presta el servicio por sí mismo: si lo hiciera, dejaría de escuchar las solicitudes de conexión mientras el servicio estuviera en curso, y los demás clientes no serían atendidos. Por lo tanto, procede de otra manera: en cuanto se recibe una solicitud de conexión en el puerto de escucha y esta se acepta, el servidor crea una tarea encargada de prestar el servicio solicitado por el cliente a través de la conexión de servicio que acaba de establecerse. Esto permite atender a varios clientes al mismo tiempo:

Image

El curso de 2008 afirmaba que la conexión de servicio utilizaba, en el lado del servidor, otro puerto elegido al azar. Esto es incorrecto: todas las conexiones de servicio utilizan el puerto de escucha del servidor; se distinguen entre sí por la dirección y el puerto del cliente, que son diferentes. Lo veremos en la salida de nuestro servidor de eco.

Una tarea de servicio tendrá la siguiente estructura:

1
2
3
4
5
6
while the service has not been fully provided
    wait for a request on the service connection
    when there is one, build the response
    send the response over the service connection
end while
close the service connection

12.4. Exploración de los protocolos de comunicación de Internet

12.4.1. Introducción

Cuando un cliente se conecta a un servidor, se establece un diálogo entre ambos. La naturaleza de este diálogo constituye lo que se denomina el protocolo de comunicación del servidor. Entre los protocolos de Internet más comunes se encuentran los siguientes:

  • HTTP: HyperText Transfer Protocol, el protocolo de comunicación con un servidor web (servidor HTTP);
  • SMTP: Simple Mail Transfer Protocol, el protocolo de comunicación con un servidor de envío de correo electrónico (servidor SMTP);
  • POP: Post Office Protocol, el protocolo de comunicación con un servidor de almacenamiento de correo electrónico (servidor POP). Se utiliza para recuperar los correos recibidos, no para enviarlos. IMAP cumple la misma función;
  • FTP: File Transfer Protocol, el protocolo de comunicación con un servidor de almacenamiento de archivos (servidor FTP).

Estos protocolos, en sus versiones históricas, se caracterizan por estar basados en texto: el cliente y el servidor intercambian líneas de texto terminadas por los dos caracteres \r\n (retorno de carro, salto de línea). Si se dispone de un cliente capaz de:

  • establecer una conexión con un servidor TCP;
  • mostrar en la consola las líneas de texto enviadas por el servidor;
  • enviar al servidor las líneas de texto que un usuario escribe con el teclado,

entonces podemos comunicarnos con un servidor TCP que use un protocolo basado en texto, siempre que conozcamos las reglas de ese protocolo.

El programa [telnet], que antes estaba disponible en las máquinas Unix y Windows, es un cliente de este tipo; el curso de 2008 utilizaba la herramienta PuTTY, configurada en modo de conexión sin procesar (raw). El cliente [telnet] ya no se instala de forma predeterminada en Windows, y la mayoría de los servidores públicos ya no aceptan comunicaciones sin cifrar. Procederemos de otra manera:

  • para HTTP, utilizaremos la herramienta [curl], disponible de forma predeterminada en Windows 10 y 11, así como en Linux, que muestra el detalle de los intercambios, seguida del cliente TCP genérico que escribiremos más adelante en este capítulo. En Windows, en PowerShell, [curl] es un alias del comando [Invoke-WebRequest]: hay que escribir [curl.exe];
  • como no tenemos acceso a servidores reales, consultaremos un pequeño servidor web que escribiremos nosotros mismos y que se ejecuta en la máquina local;
  • Para SMTP, POP y FTP, presentaremos diálogos de ejemplo que se ajustan a las RFC que definen estos protocolos.

12.4.2. Un servidor web de prueba

Nuestro servidor web de prueba es una aplicación ASP.NET Core de un solo archivo llamada “Minimal API”. ASP.NET Core es el framework de desarrollo web de .NET, que exploraremos en el próximo capítulo. Por ahora no es necesario entender este programa en detalle: basta con saber qué produce. El programa [internet-03.cs] es el siguiente:

#:sdk Microsoft.NET.Sdk.Web

// un pequeño servidor web local que servirá de objetivo para nuestros clientes HTTP
// llamada: dotnet run internet-03.cs [-- port]
int port = args.Length == 1 && int.TryParse(args[0], out int p) ? p : 27110;

var builder = WebApplication.CreateBuilder(args);
// sin registro de ASP.NET (solo las advertencias): escribimos el nuestro
builder.Logging.SetMinimumLevel(LogLevel.Warning);
var app = builder.Build();

// seguimiento en consola: cada solicitud y el código de estado de su respuesta
app.Use(async (context, next) =>
{
    await next(context);
    var request = context.Request;
    string url = $"{request.Path}{request.QueryString}";
    Console.WriteLine($"{request.Method} {url} {request.Protocol} -> {context.Response.StatusCode}");
});

// las URL aceptan los métodos GET y HEAD
string[] getHead = ["GET", "HEAD"];

// la página de inicio: un documento HTML
app.MapMethods("/", getHead, () => Results.Content("""
    <!DOCTYPE html>
    <html lang="en">
    <head><meta charset="utf-8"><title>Test server</title></head>
    <body><h1>Welcome to the test server of the C# course</h1></body>
    </html>

    """, "text/html; charset=utf-8"));

// un documento de texto construido a partir de un parámetro de la URL
app.MapMethods("/hello", getHead, (string? name) => $"Hello {name ?? "unknown"}!");

// redirección temporal (302) a una dirección relativa
app.MapMethods("/old", getHead, () => Results.Redirect("/hello?name=visitor"));

// redirección permanente (301) a una dirección absoluta
app.MapMethods("/moved", getHead, () => Results.Redirect($"http://localhost:{port}/", permanent: true));

// una redirección que se repite sobre sí misma
app.MapMethods("/loop", getHead, () => Results.Redirect("/loop"));

// cualquier otra URL recibe la respuesta 404 Not Found (comportamiento predeterminado)
Console.WriteLine($"Web server started on http://localhost:{port}");
app.Run($"http://127.0.0.1:{port}");

Comentarios:

  • Línea 1: esta directiva especifica que la aplicación de un solo archivo utiliza el SDK web de ASP.NET Core ([Microsoft.NET.Sdk.Web]) en lugar del SDK de consola habitual. Los espacios de nombres de ASP.NET Core ([Microsoft.AspNetCore.Builder], [Microsoft.AspNetCore.Http]…) pasan entonces a formar parte de los [using] predeterminados;
  • línea 5: el puerto de escucha, 27110 de forma predeterminada;
  • líneas 13–18: cada solicitud procesada se muestra en la consola junto con el código de estado de la respuesta;
  • línea 25: la URL [/] devuelve un pequeño documento HTML. El texto del documento se escribe mediante un literal de cadena sin formato (raw string literal) [""" ... """] (C# 11), que evita tener que escapar las comillas;
  • línea 35: la URL [/hello?name=xx] devuelve el texto [Hello xx!]. El parámetro [name] de la lambda se rellena automáticamente con el parámetro [name] de la URL;
  • línea 38: la URL [/old] provoca una redirección temporal (código de estado 302) hacia la dirección relativa [/hello?name=visitor];
  • línea 41: la URL [/moved] provoca una redirección permanente (código de estado 301) hacia la dirección absoluta [http://localhost:27110/];
  • línea 44: la URL [/loop] se redirige a sí misma: un cliente que siguiera las redirecciones a ciegas nunca se detendría;
  • cualquier otra URL recibe una respuesta 404 (página no encontrada);
  • línea 48: el servidor escucha en la dirección de loopback 127.0.0.1: solo es accesible desde la propia máquina.

El servidor se inicia en una ventana de comandos. Muestra lo siguiente:

1
2
3
4
> dotnet run internet-03.cs
Web server started on http://localhost:27110
GET / HTTP/1.1 -> 200
GET /unknown HTTP/1.1 -> 404

Las líneas 3–4 aparecieron durante las pruebas descritas en el párrafo siguiente. El servidor se detiene presionando Ctrl-C.

12.4.3. El protocolo HTTP (HyperText Transfer Protocol)

Con el servidor en ejecución, solicitamos, en una segunda ventana de comandos, la raíz [/] del sitio [http://localhost:27110] mediante la herramienta [curl]. Su opción [-v] (verbose) muestra todo el diálogo HTTP:

> curl -v http://localhost:27110/
* Host localhost:27110 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27110...
* Connected to localhost (127.0.0.1) port 27110
> GET / HTTP/1.1
> Host: localhost:27110
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 200 OK
< Content-Length: 169
< Content-Type: text/html; charset=utf-8
< Date: Sat, 03 Oct 2026 09:48:36 GMT
< Server: Kestrel
< 
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the test server of the C# course</h1></body>
</html>
* Connection #0 to host localhost left intact

Comentarios:

  • Las líneas que comienzan con [*] contienen información de [curl]; las líneas que comienzan con [>] se enviaron al servidor; las que comienzan con [<] se recibieron del servidor; las demás constituyen el documento recibido;
  • Líneas 2–6: [curl] obtuvo las direcciones de [localhost] (::1 para IPv6 y 127.0.0.1 para IPv4) y se conectó al puerto 27110 de la dirección 127.0.0.1;
  • líneas 7–10: la solicitud del cliente. Consta de una primera línea con la sintaxis [method URL version] (aquí se usa el método [GET] para solicitar el documento [/], es decir, la raíz del sitio, en HTTP/1.1), seguida de encabezados HTTP de la forma [Name: value], y termina con una línea en blanco;
  • línea 8: el encabezado [Host] especifica la máquina y el puerto consultados; es obligatorio en HTTP/1.1 porque un mismo servidor puede alojar varios sitios;
  • línea 9: el identificador del software cliente;
  • línea 10: los tipos de documento aceptados por el cliente; en este caso, todos;
  • Líneas 12–16: los encabezados de la respuesta, que también terminan con una línea en blanco;
  • línea 12: la línea de estado, con la sintaxis [version code message]. El código 200 indica que se encontró el documento solicitado;
  • línea 13: el tamaño del documento en bytes. Esto indica al cliente dónde termina el documento;
  • línea 14: el tipo del documento (un documento HTML) y su codificación (UTF-8);
  • línea 15: la fecha y la hora del servidor, siempre en tiempo universal coordinado (GMT);
  • línea 16: el software que presta el servicio web, en este caso Kestrel, el servidor web de ASP.NET Core. En el curso de 2008 era un servidor Apache 1.3 con PHP 4;
  • líneas 18–22: el documento enviado por el servidor;
  • línea 23: en HTTP/1.1, la conexión permanece abierta de forma predeterminada después de la respuesta (modo “keep-alive”) para poder atender otras solicitudes; [curl] la deja abierta y luego la cierra al terminar.

Ahora solicitemos un documento que no existe:

> curl -v http://localhost:27110/unknown
* Host localhost:27110 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27110...
* Connected to localhost (127.0.0.1) port 27110
> GET /unknown HTTP/1.1
> Host: localhost:27110
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 404 Not Found
< Content-Length: 0
< Date: Sat, 03 Oct 2026 09:48:36 GMT
< Server: Kestrel
< 
* Connection #0 to host localhost left intact
  • línea 7: solicitamos un documento inexistente;
  • línea 12: el servidor respondió con un código de estado 404, que significa que no se encontró el documento solicitado;
  • línea 13: el documento enviado está vacío. De forma predeterminada, Kestrel no adjunta ningún documento a una respuesta 404; el servidor Apache consultado en 2008 enviaba una breve página HTML explicativa. Un navegador que recibe una respuesta 404 sin documento muestra su propia página de error.

Los códigos de estado se dividen en cinco categorías: 1xx (información), 2xx (éxito, 200 OK), 3xx (redirección, 301 y 302, que veremos más adelante), 4xx (error del cliente: 404 Not Found, 401 Unauthorized, 403 Forbidden…), 5xx (error del servidor: 500 Internal Server Error…).

El navegador hace lo mismo que [curl]: envía una solicitud HTTP, recibe los encabezados y el documento, y luego muestra el documento. Las herramientas para desarrolladores del navegador (tecla F12, pestaña Red) permiten ver los encabezados intercambiados.

Algunas notas sobre el estado actual de HTTP:

  • HTTPS es ahora el estándar: los navegadores señalan como “no seguro” un sitio que usa HTTP sin cifrar. Con HTTPS, una negociación TLS precede al diálogo HTTP, y todo lo que sigue está cifrado. Por lo tanto, ya no es posible comunicarse “manualmente” con un servidor HTTPS mediante un simple cliente TCP. Sin embargo, aún se puede observar el diálogo con [curl], que realiza el handshake TLS y luego muestra los encabezados en texto plano. Solo con fines ilustrativos (no reproducimos el resultado, ya que nuestra máquina de pruebas no tiene acceso a Internet), el comando sería [curl -v https://learn.microsoft.com/];
  • HTTP/1.1 (hoy RFC 9112) es un protocolo basado en texto, el que estamos estudiando. HTTP/2 (2015, hoy RFC 9113) conserva los mismos métodos, encabezados y códigos de estado, pero los transmite en un formato binario comprimido y envía varias solicitudes simultáneamente por una sola conexión TCP. HTTP/3 (2022, RFC 9114) hace lo mismo sobre QUIC y, por lo tanto, sobre UDP. Los navegadores y los servidores eligen automáticamente la versión más reciente que tienen en común; [curl], sin opciones específicas, utiliza HTTP/1.1 para una URL [http://].

12.4.4. El protocolo SMTP (Simple Mail Transfer Protocol)

Los servidores SMTP intercambian correo electrónico entre sí por el puerto 25. Un cliente de correo que envía un mensaje lo entrega al servidor SMTP de su proveedor por el puerto 587 (submission, con cambio a modo cifrado mediante el comando [STARTTLS]) o 465 (conexión cifrada desde el inicio), después de autenticarse. Los proveedores de servicios de Internet suelen bloquear las conexiones salientes al puerto 25 desde los enrutadores de sus abonados para limitar el spam enviado por máquinas infectadas: el diálogo sin cifrar que se mostraba en el curso de 2008 ya no es factible desde una computadora personal.

A modo de ilustración, he aquí un diálogo SMTP típico conforme a la RFC 5321. No se trata de una ejecución real: las líneas con el prefijo [C:] las envía el cliente, las que tienen el prefijo [S:] el servidor, y los dominios [example.org] y [example.com] están reservados para ejemplos:

S: 220 mail.example.com ESMTP ready
C: EHLO pc.example.org
S: 250-mail.example.com
S: 250-SIZE 10240000
S: 250-STARTTLS
S: 250 8BITMIME
C: MAIL FROM:<alice@example.org>
S: 250 2.1.0 Ok
C: RCPT TO:<bob@example.com>
S: 250 2.1.5 Ok
C: DATA
S: 354 End data with <CR><LF>.<CR><LF>
C: From: alice@example.org
C: To: bob@example.com
C: Subject: test
C:
C: line1
C: line2
C: .
S: 250 2.0.0 Ok: queued as 4F2A81C0
C: QUIT
S: 221 2.0.0 Bye
  • Línea 1: mensaje de bienvenida del servidor. Cada respuesta del servidor comienza con un código de tres dígitos: 2xx indica éxito, 3xx significa “continúe” y 4xx y 5xx indican un error;
  • línea 2: el cliente se identifica. El comando [EHLO] ha reemplazado al comando [HELO] del curso de 2008: pide al servidor la lista de las extensiones que admite;
  • Líneas 3–6: la respuesta del servidor, que abarca varias líneas. El guion que sigue al código indica que la respuesta continúa; la última línea tiene un espacio en su lugar. Aquí, el servidor indica que acepta mensajes de hasta 10 MB de tamaño, admite el modo cifrado y acepta caracteres de 8 bits;
  • línea 7: la dirección del remitente;
  • línea 9: la dirección del destinatario (el comando puede repetirse para varios destinatarios);
  • línea 11: el cliente anuncia el mensaje;
  • línea 12: el servidor invita al cliente a enviar el mensaje y le recuerda cómo terminarlo;
  • líneas 13–19: el mensaje, formado por encabezados ([From], [To], [Subject]…), una línea en blanco y el cuerpo, y que termina con una línea que contiene únicamente un punto;
  • línea 20: el servidor aceptó el mensaje y lo colocó en su cola;
  • líneas 21–22: el cliente indica que ha terminado; el servidor cierra la conexión.

12.4.5. El protocolo POP (Post Office Protocol)

Los servidores POP3 funcionan en el puerto 110, o en el puerto 995 para una conexión cifrada mediante TLS —la única opción que ofrecen actualmente la mayoría de los proveedores, ya que la contraseña se transmite durante el diálogo—. A continuación se muestra un diálogo POP3 típico, conforme a la RFC 1939, presentado con las mismas convenciones que el anterior:

S: +OK POP3 server ready
C: USER bob
S: +OK
C: PASS ********
S: +OK Logged in.
C: LIST
S: +OK 2 messages:
S: 1 1205
S: 2 1916
S: .
C: RETR 2
S: +OK 1916 octets
S: Return-Path: <alice@example.org>
S: Delivered-To: bob@example.com
S: ...
S: Date: Sat, 03 Oct 2026 10:59:25 +0200
S: From: alice@example.org
S: To: bob@example.com
S: Subject: test
S:
S: line1
S: line2
S: .
C: QUIT
S: +OK Logging out.
  • Línea 1: mensaje de bienvenida del servidor. Las respuestas de POP3 comienzan con [+OK] (éxito) o [-ERR] (error);
  • línea 2: el cliente proporciona su nombre de usuario, es decir, el nombre que utiliza para leer su correo;
  • línea 4: la contraseña del cliente (oculta aquí);
  • línea 6: el cliente solicita la lista de sus correos;
  • líneas 7–10: la lista de mensajes del buzón del cliente, en el formato [message number, size in bytes], que termina con una línea que contiene únicamente un punto;
  • línea 11: se solicita el mensaje n.º 2;
  • líneas 12–23: el mensaje n.º 2, con sus encabezados, una línea en blanco y su cuerpo, que también termina con un punto;
  • líneas 24–25: el cliente indica que ha terminado; el servidor cierra la conexión.

POP3 está diseñado para descargar el correo electrónico a la computadora del usuario. Hoy enfrenta una fuerte competencia de IMAP (puerto 143, o 993 con TLS; RFC 9051), que deja los mensajes en el servidor y permite consultarlos y organizarlos desde varios dispositivos, así como mediante clientes de correo web.

12.4.6. El protocolo FTP (File Transfer Protocol)

El protocolo FTP (RFC 959) es más complejo que los descritos anteriormente: el diálogo (los comandos y sus respuestas) se lleva a cabo a través de una conexión de control abierta al puerto 21 del servidor, y cada transferencia de un archivo o de una lista de archivos utiliza una segunda conexión, abierta específicamente para ese fin. A continuación se muestra un diálogo típico a través de la conexión de control:

S: 220 FTP service ready
C: USER anonymous
S: 331 Please specify the password.
C: PASS guest@example.org
S: 230 Login successful.
C: PWD
S: 257 "/" is the current directory
C: EPSV
S: 229 Entering Extended Passive Mode (|||40312|)
C: RETR readme.txt
S: 150 Opening BINARY mode data connection for readme.txt (1250 bytes).
S: 226 Transfer complete.
C: QUIT
S: 221 Goodbye.
  • línea 2: conexión anónima, como la que ofrecen los servidores públicos de descarga;
  • línea 8: el cliente pide al servidor que abra un puerto para la conexión de datos. El servidor responde (línea 9) que espera esta conexión en el puerto 40312;
  • línea 10: el cliente solicita el archivo [readme.txt]. El archivo llega por la conexión de datos, y la conexión de control recibe las respuestas 150 (inicio de la transferencia) y 226 (fin de la transferencia).

El curso de 2008 recomendaba supervisar estos comandos en el registro del cliente FileZilla, lo cual sigue siendo posible. Sin embargo, FTP está quedando obsoleto: transmite las contraseñas en texto plano, tiene dificultades para funcionar con los firewalls debido a su segunda conexión, y los navegadores ya no lo admiten desde 2021 (Chrome 88, Firefox 90). Es preferible utilizar SFTP, la transferencia de archivos mediante SSH, y la simple descarga mediante HTTPS.

12.5. Las clases de .NET en la programación web

12.5.1. Elegir la clase adecuada

.NET ofrece diversas clases para trabajar con la red:

Image

  • La clase [Socket] es la que opera más cerca de la red. Permite una gestión detallada de la conexión de red. El término inglés “socket” designa un enchufe eléctrico; su significado se ha extendido para designar un socket de red de software. En una comunicación TCP/IP entre dos máquinas, A y B, dos sockets se comunican entre sí. Una aplicación puede trabajar directamente con los sockets: es el caso de la aplicación A de más arriba. Un socket puede ser de cliente o de servidor;
  • si desea trabajar a un nivel más alto que el de la clase [Socket], puede utilizar la clase [TcpClient] para crear un cliente (TCP) y la clase [TcpListener] para crear un servidor (TCP) (la aplicación B de más arriba). Estas dos clases ofrecen a la aplicación una visión más sencilla de la comunicación de red, ya que se encargan por ella de los detalles técnicos de los sockets. La clase [UdpClient] cumple la misma función para UDP;
  • .NET también ofrece clases especializadas en un protocolo específico. La más importante hoy en día es [HttpClient] (la aplicación C de más arriba), que gestiona el protocolo HTTP en sus versiones 1.1, 2 y 3, incluido el cifrado TLS de HTTPS. El curso de 2008 abordaba las clases [WebClient] y [WebRequest], hoy obsoletas y reemplazadas por [HttpClient] (volveremos sobre esto en la segunda parte de este capítulo), así como la clase [SmtpClient] para el envío de correo, que no se ha declarado obsoleta pero que Microsoft ya no recomienda para nuevos desarrollos.

Cabe señalar que la clase [Socket] basta por sí sola para gestionar toda la comunicación TCP/IP, pero buscaremos utilizar principalmente las clases de nivel superior para simplificar el desarrollo de aplicaciones.

12.5.2. La clase TcpClient

La clase [TcpClient] (espacio de nombres [System.Net.Sockets]) es la clase adecuada en la mayoría de los casos para crear un cliente de un servicio TCP. Entre sus constructores C, métodos M y propiedades P, tiene los siguientes:

Miembro
Tipo
Función
TcpClient()
C
crea un cliente que aún no está conectado
Task ConnectAsync(string machine, int port), ValueTask ConnectAsync(string machine, int port, CancellationToken token)
M
establece (de forma asíncrona) una conexión TCP con el servicio que se ejecuta en el puerto [port] de la máquina [machine]. Por ejemplo, [await client.ConnectAsync("localhost", 27110)]. Existen sobrecargas que aceptan una [IPAddress] o un [IPEndPoint]. Lanza una [SocketException] si la conexión falla
NetworkStream GetStream()
M
obtiene un flujo de lectura y escritura hacia el servidor. Este flujo permite la comunicación cliente-servidor
Socket Client
P
El socket que utiliza el cliente para comunicarse con el servidor. Sus propiedades [LocalEndPoint] y [RemoteEndPoint] representan los dos extremos de la conexión
bool Connected
P
true si la conexión se ha establecido (y el cliente no la ha cerrado)
void Close(), void Dispose()
M
Cierra la conexión. El socket y el flujo [NetworkStream] también se cierran

El curso de 2008 utilizaba el constructor [TcpClient(string machine, int port)], que se conecta de forma bloqueante: el hilo que lo ejecuta queda bloqueado durante todo el tiempo que dura el establecimiento de la conexión, que puede tardar varias decenas de segundos si la máquina remota no responde. Utilizaremos [ConnectAsync].

La clase [NetworkStream] representa el flujo de red entre el cliente y el servidor. Deriva de la clase [Stream] y, por lo tanto, ofrece los métodos [ReadAsync] y [WriteAsync] , que leen y escriben bytes. Muchas aplicaciones cliente-servidor intercambian líneas de texto. Por eso resulta útil emplear los objetos [StreamReader] y [StreamWriter] , presentados en el capítulo sobre archivos, para leer y escribir estas líneas en el flujo de red:

1
2
3
NetworkStream stream = client.GetStream();
var reader = new StreamReader(stream);
var writer = new StreamWriter(stream) { AutoFlush = true };

La propiedad [AutoFlush = true] significa que cada escritura en [writer] se transmite de inmediato por la red, sin esperar a que se llene el búfer interno de [StreamWriter] . Este es un punto importante. En general, cuando un cliente envía una línea de texto a su interlocutor, espera una respuesta. Esa respuesta nunca llegará si la línea permanece en el búfer de la máquina emisora sin enviarse. Sin [AutoFlush], hay que llamar explícitamente a [FlushAsync] después de escribir una solicitud completa.

Para enviar una línea de texto al servidor, se escribe:

await writer.WriteLineAsync("some text");

y para leer la respuesta del servidor:

        string? response = await reader.ReadLineAsync();

[ReadLineAsync] devuelve [null] cuando el interlocutor ha cerrado la conexión y se ha leído todo lo que envió: esto marca el final del flujo.

Un punto merece atención: el carácter de fin de línea. [WriteLineAsync] termina la línea con el valor de la propiedad [NewLine] de [StreamWriter], que de forma predeterminada es [Environment.NewLine], es decir, \r\n en Windows pero solo \n en Linux y macOS. Los protocolos de Internet (HTTP, SMTP, POP, FTP) exigen \r\n. Algunos servidores, como Kestrel, toleran un solo \n, mientras que otros no; por lo tanto, un programa portable que use uno de estos protocolos debe establecer [NewLine = "\r\n"]. Al leer, [ReadLineAsync] acepta tanto \r\n como \n.

Ya contamos con los elementos para escribir la arquitectura básica de un cliente TCP con el siguiente protocolo de comunicación básico con el servidor:

  • el cliente envía una solicitud contenida en una sola línea;
  • el servidor envía una respuesta contenida en una sola línea.
try
{
    // conexión al servicio
    using var client = new TcpClient();
    await client.ConnectAsync(server, port);
    // flujo de red, flujos de lectura y escritura
    await using NetworkStream stream = client.GetStream();
    using var reader = new StreamReader(stream);
    await using var writer = new StreamWriter(stream) { AutoFlush = true };
    // bucle de solicitud - respuesta
    while (true)
    {
        // preparación de la solicitud
        string request = ...;
        // envío de la solicitud al servidor
        await writer.WriteLineAsync(request);
        // lectura de la respuesta del servidor
        string? response = await reader.ReadLineAsync();
        // procesamiento de la respuesta
        ...
    }
}
catch (SocketException ex)
{
    // conexión imposible
    ...
}
catch (IOException ex)
{
    // error durante los intercambios
    ...
}
  • Línea 4: creación del cliente. La declaración [using] (C# 8) garantiza que la conexión se cerrará al salir del bloque que la contiene, suceda lo que suceda. El curso de 2008 anidaba cuatro instrucciones [using (...) { ... }]; las declaraciones [using] evitan este anidamiento;
  • línea 5: conexión asíncrona al servicio;
  • Línea 7: obtención del flujo de red. [await using] (C# 8) libera el objeto llamando a su método [DisposeAsync], la versión asíncrona de [Dispose]: liberar un [StreamWriter] puede, en efecto, desencadenar una última escritura en la red;
  • líneas 8–9: creación de flujos de lectura y escritura sobre el flujo de red;
  • líneas 11–19: el ciclo de solicitud del cliente y respuesta del servidor;
  • línea 16: el cliente envía su solicitud al servidor;
  • línea 18: el cliente espera la respuesta del servidor. Esta espera termina cuando llega una línea que termina con \n, o cuando finaliza el flujo si el servidor cierra la conexión. Mientras espera, no se bloquea ningún hilo;
  • líneas 23–28: una [SocketException] indica una conexión fallida (máquina desconocida, ningún servicio en el puerto solicitado, etc.), mientras que una [IOException] indica un error durante la comunicación (conexión perdida, etc.).

12.5.3. La clase TcpListener

La clase [TcpListener] es la clase adecuada en la mayoría de los casos para crear un servicio TCP. Entre sus constructores C, métodos M y propiedades P, tiene los siguientes:

Miembro
Tipo
Función
TcpListener(IPAddress address, int port)
C
crea un servicio TCP que escuchará las solicitudes de los clientes en el puerto [port] —denominado puerto de escucha— en la dirección [address]. Con [IPAddress.Any], el servicio escucha en todas las direcciones IPv4 de la máquina; con [IPAddress.Loopback], escucha únicamente en la dirección de loopback
static TcpListener Create(int port)
M
crea un servicio que escucha tanto en IPv4 como en IPv6 en todas las direcciones de la máquina
void Start()
M
inicia la escucha de las solicitudes de los clientes
Task<TcpClient> AcceptTcpClientAsync(), ValueTask<TcpClient> AcceptTcpClientAsync(CancellationToken token)
M
espera (de forma asíncrona) la solicitud de un cliente y la acepta. Devuelve el objeto [TcpClient] asociado, del lado del servidor, a la conexión de servicio abierta con ese cliente
void Stop()
M
detiene la escucha de las solicitudes de los clientes
EndPoint LocalEndpoint
P
dirección y puerto de escucha
Socket Server
P
el socket de escucha del servidor

El constructor [TcpListener(int port)] utilizado en el curso de 2008 se ha declarado obsoleto: hay que especificar la dirección de escucha o usar [TcpListener.Create].

La estructura básica de un servidor TCP que se comunica con sus clientes mediante el protocolo de “una línea de solicitud, una línea de respuesta” podría ser la siguiente:

// el servicio de escucha, en todas las interfaces de red de la máquina
var listener = new TcpListener(IPAddress.Any, port);
listener.Start();
// bucle de espera de clientes
while (true)
{
    // espera de un cliente
    TcpClient client = await listener.AcceptTcpClientAsync();
    // el cliente es atendido por otra tarea, que no esperamos
    _ = ServeAsync(client);
    // siguiente cliente
}

// el servicio prestado a un cliente
static async Task ServeAsync(TcpClient client)
{
    try
    {
        using (client)
        {
            await using NetworkStream stream = client.GetStream();
            using var reader = new StreamReader(stream);
            await using var writer = new StreamWriter(stream) { AutoFlush = true };
            // bucle de lectura de solicitud / escritura de respuesta
            while (await reader.ReadLineAsync() is string request)
            {
                // preparación de la respuesta
                string response = ...;
                // envío de la respuesta al cliente
                await writer.WriteLineAsync(response);
            }
        }
    }
    catch (IOException ex)
    {
        // error
        ...
    }
}
  • Línea 2: el servicio de escucha se crea para un puerto determinado y una dirección IP determinada. Una máquina tiene al menos dos direcciones IP: la dirección de loopback 127.0.0.1 y la dirección que tiene en la red a la que está conectada. Puede tener otras si está conectada a varias redes. [IPAddress.Any] designa todas las direcciones IPv4 de la máquina;
  • línea 3: se inicia el servicio de escucha. Se había creado antes, pero todavía no escuchaba. Escuchar significa esperar las solicitudes de conexión de los clientes;
  • Líneas 5–11: el ciclo de espera de un cliente y de inicio de su servicio, que se repite para cada nuevo cliente;
  • línea 8: se acepta la solicitud de un cliente. [AcceptTcpClientAsync] devuelve una instancia de servicio llamada [TcpClient]:
    • el cliente hizo su solicitud mediante su propia instancia, [TcpClient], que llamaremos [TcpClientRequest];
    • el servidor acepta esta solicitud con [AcceptTcpClientAsync], que crea una instancia [TcpClient] del lado del servidor, que llamaremos [TcpClientService]. Entonces tenemos una conexión TCP abierta, con las instancias [TcpClientRequest] ↔ [TcpClientService] en cada extremo;
    • la comunicación cliente-servidor que se produce a continuación tiene lugar por esta conexión. El servicio de escucha ya no interviene;
  • Línea 10: para que el servidor pueda atender a varios clientes a la vez, el servicio lo presta una tarea asíncrona. El servidor no la espera (sin [await]); vuelve de inmediato a esperar al siguiente cliente. La tarea devuelta por [ServeAsync] se asigna a la variable de descarte [_], lo que indica al lector (y al compilador) que su resultado se ignora intencionalmente;
  • línea 15: el método que atiende a un cliente. Recibe como parámetro la instancia [TcpClient], que ya está conectada al cliente que se va a atender;
  • línea 25: aquí vemos un código similar al del cliente TCP básico presentado anteriormente. El ciclo se detiene cuando [ReadLineAsync] devuelve [null], es decir, cuando el cliente ha cerrado la conexión. El patrón [is string request] comprueba que el valor leído no sea [null] y lo asigna a la variable [request];
  • línea 34: las excepciones deben capturarse en [ServeAsync]: como nadie espera la tarea, una excepción no capturada pasaría inadvertida.

12.5.4. ¿Un hilo por cliente o una tarea por cliente?

El servidor del curso de 2008 asignaba cada cliente a un hilo del grupo de hilos ([ThreadPool.QueueUserWorkItem]), que realizaba lecturas y escrituras bloqueantes: mientras el cliente pensaba, su hilo permanecía bloqueado en [ReadLine]. Cada hilo consume memoria (una pila reservada de aproximadamente 1 MB) y tiempo de procesador, ya que el sistema debe alternar entre ellos. Con unas pocas decenas de clientes, esto no es un problema; con miles de conexiones simultáneas —un escenario habitual para un servidor real— el servidor colapsa. De hecho, el curso limitaba el grupo a 10 hilos: el undécimo cliente debía esperar a que uno de los diez primeros se desconectara.

Con los métodos asíncronos ([AcceptTcpClientAsync], [ReadLineAsync], [WriteLineAsync]), un cliente que no envía nada no consume ningún hilo: su tarea queda suspendida, y solo cuando llegan datos uno de los hilos del grupo ejecuta el resto de su tarea. Bastan, por lo tanto, unos pocos hilos para atender a miles de clientes. Así funcionan los servidores modernos, en particular Kestrel, el servidor web de ASP.NET Core. Los principios tratados en el capítulo sobre programación asíncrona se aplican plenamente aquí: [async] / [await] de principio a fin, y un [CancellationToken] para finalizar limpiamente las operaciones en curso.

12.6. Ejemplos de clientes y servidores TCP

Los programas de esta sección son aplicaciones de un solo archivo de la carpeta [12-internet]. Los servidores y los clientes se inician en ventanas de comandos separadas en la misma máquina; los puertos utilizados tienen la forma 271xx.

12.6.1. Un servidor de eco

Escribiremos un servidor de eco, que se iniciará desde una ventana de comandos mediante:

dotnet run internet-04.cs -- port

El servidor se ejecuta en el puerto pasado como argumento. Se limita a devolver al cliente cada línea que este le envía, encerrada entre corchetes. El programa [internet-04.cs] es el siguiente:

using System.Net;
using System.Net.Sockets;

// servidor de eco: devuelve a cada cliente las líneas que este le envía
// llamada: dotnet run internet-04.cs -- port

const string syntax = "Syntax: dotnet run internet-04.cs -- port";
// se necesita un argumento: un puerto entre 1 y 65535
if (args.Length != 1 || !int.TryParse(args[0], out int port) || port is < 1 or > 65535)
{
    Console.WriteLine(syntax);
    return;
}

// Ctrl-C cancela el token: el servidor se detiene limpiamente
using var cancellation = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    // evitamos el final abrupto del proceso
    e.Cancel = true;
    cancellation.Cancel();
};

// el servicio de escucha, en todas las interfaces de red de la máquina
var listener = new TcpListener(IPAddress.Any, port);
// las tareas de servicio en curso
var services = new List<Task>();
int clientNumber = 0;
try
{
    // lo iniciamos
    listener.Start();
    Console.WriteLine($"Echo server started on {listener.LocalEndpoint}");
    // bucle de espera de clientes - se detiene con Ctrl-C
    while (true)
    {
        // espera (asíncrona) de un cliente
        TcpClient client = await listener.AcceptTcpClientAsync(cancellation.Token);
        // el cliente es atendido por una tarea que aquí no esperamos
        services.Add(ServeAsync(client, clientNumber++, cancellation.Token));
        // olvidamos las tareas terminadas
        services.RemoveAll(service => service.IsCompleted);
    }
}
catch (OperationCanceledException)
{
    Console.WriteLine("Server stop requested");
}
catch (SocketException ex)
{
    Console.WriteLine($"The following error occurred on the server: {ex.SocketErrorCode} ({ex.Message})");
}
finally
{
    // fin de la escucha
    listener.Stop();
}
// esperamos el final de los servicios en curso antes de salir
await Task.WhenAll(services);

// --------------------------------------------------------------------
// el servicio prestado a un cliente
static async Task ServeAsync(TcpClient client, int clientNumber, CancellationToken token)
{
    Console.WriteLine($"Start of service to client {clientNumber} ({client.Client.RemoteEndPoint})");
    try
    {
        // la conexión y el flujo de red se liberan al salir del bloque
        using (client)
        {
            await using NetworkStream stream = client.GetStream();
            using var reader = new StreamReader(stream);
            await using var writer = new StreamWriter(stream) { AutoFlush = true };
            // bucle de lectura de solicitud / escritura de respuesta
            // ReadLineAsync devuelve null cuando el cliente cierra la conexión
            while (await reader.ReadLineAsync(token) is string request)
            {
                Console.WriteLine($"<--- client {clientNumber} : {request}");
                // eco de la solicitud al cliente, entre corchetes
                await writer.WriteLineAsync($"[{request}]");
                Console.WriteLine($"---> client {clientNumber} : [{request}]");
            }
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"Service to client {clientNumber} interrupted by the server stop");
    }
    catch (IOException ex)
    {
        Console.WriteLine($"The following error occurred while serving client {clientNumber}: {ex.Message}");
    }
    finally
    {
        Console.WriteLine($"End of service to client {clientNumber}");
    }
}

La estructura del servidor de eco se ajusta a la arquitectura básica de los servidores TCP descrita anteriormente, con algunos añadidos:

  • línea 9: el puerto debe ser un entero entre 1 y 65.535. El patrón relacional combinado [is < 1 or > 65535] (C# 9) expresa esta condición de forma concisa;
  • Líneas 16–21: cierre del servidor. El servidor de 2008 se terminaba bruscamente con Ctrl-C: el proceso finalizaba sin cerrar las conexiones. Aquí, el evento [Console.CancelKeyPress] se dispara con Ctrl-C. Su controlador impide que el proceso termine de inmediato (línea 20) y cancela el token [cancellation] (línea 21);
  • línea 38: la espera de un cliente recibe el token de cancelación. Cuando se cancela el token, la espera termina con una [OperationCanceledException], que se intercepta en la línea 45;
  • líneas 40–42: cada cliente es atendido por una tarea que el ciclo no espera. Estas tareas se mantienen en una lista, de la cual se eliminan las tareas completadas a medida que terminan;
  • línea 56: fin de la escucha, que se ejecuta en todos los casos mediante [finally];
  • línea 59: antes de salir, se espera a que terminen los servicios en curso. Como han recibido el mismo token de cancelación, terminan rápidamente.

La sección “servicio al cliente”:

  • línea 65: la dirección y el puerto del cliente;
  • línea 76: se lee la solicitud del cliente. El token de cancelación interrumpe la espera si el servidor se cierra. [ReadLineAsync] devuelve [null] cuando el cliente cierra la conexión: entonces el ciclo y el servicio se detienen;
  • línea 80: la solicitud se devuelve al cliente, encerrada entre corchetes;
  • líneas 85–89: se gestionan el cierre del servidor y una conexión terminada por el cliente;
  • línea 95: [finally] señala el fin del servicio, sea cual sea la causa.

Para ver el servidor en acción, necesitamos un cliente. El curso de 2008 utilizaba PuTTY; escribiremos nuestro propio cliente en la próxima sección y presentaremos los resultados después.

12.6.2. Un cliente para el servidor de eco

Escribiremos ahora un cliente para el servidor anterior. Se invocará de la siguiente manera:

dotnet run internet-05.cs -- machine port

Se conecta a la máquina [machine] en el puerto [port] y luego envía al servidor el texto ingresado por teclado, que este devuelve como eco. El programa [internet-05.cs] es el siguiente:

using System.Net.Sockets;

// cliente de eco: envía al servidor las líneas escritas con el teclado
// y muestra las respuestas del servidor
// llamada: dotnet run internet-05.cs -- machine port

const string syntax = "Syntax: dotnet run internet-05.cs -- machine port";
if (args.Length != 2 || !int.TryParse(args[1], out int port) || port is < 1 or > 65535)
{
    Console.WriteLine(syntax);
    return;
}
string server = args[0];

try
{
    // conexión (asíncrona) al servicio
    using var client = new TcpClient();
    await client.ConnectAsync(server, port);
    Console.WriteLine($"Connected to the server {client.Client.RemoteEndPoint} from {client.Client.LocalEndPoint}");
    // flujos de lectura y escritura sobre la conexión
    await using NetworkStream stream = client.GetStream();
    using var reader = new StreamReader(stream);
    // AutoFlush: cada línea escrita sale de inmediato a la red
    await using var writer = new StreamWriter(stream) { AutoFlush = true };
    // bucle de solicitud - respuesta
    while (true)
    {
        // la solicitud proviene del teclado
        Console.Write("Request (bye to stop): ");
        string? request = Console.ReadLine();
        // ¿terminó?
        if (request is null || request.Trim().Equals("bye", StringComparison.OrdinalIgnoreCase))
        {
            break;
        }
        // enviamos la solicitud al servidor
        await writer.WriteLineAsync(request);
        // esperamos su respuesta
        string? response = await reader.ReadLineAsync();
        if (response is null)
        {
            Console.WriteLine("The server has closed the connection");
            break;
        }
        Console.WriteLine($"Response: {response}");
    }
}
catch (SocketException ex)
{
    Console.WriteLine($"The following error occurred: {ex.SocketErrorCode} ({ex.Message})");
}
catch (IOException ex)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
}

La estructura de este cliente se ajusta a la arquitectura básica propuesta para los clientes TCP:

  • línea 19: conexión asíncrona al servidor;
  • línea 20: se muestran los dos extremos de la conexión: [RemoteEndPoint] (el servidor) y [LocalEndPoint] (el cliente). El puerto del cliente fue elegido por el sistema;
  • línea 25: cada línea escrita se envía de inmediato;
  • línea 31: la solicitud se escribe con el teclado. [Console.ReadLine] devuelve [null] si la entrada estándar está cerrada (Ctrl-D en Linux, Ctrl-Z seguido de Enter en Windows);
  • línea 33: la comparación con [bye] no distingue entre mayúsculas y minúsculas;
  • línea 38: la solicitud se envía al servidor;
  • líneas 40–43: se espera la respuesta; [null] indica que el servidor ha cerrado la conexión;
  • líneas 49–53: errores de conexión y de intercambio.

Estos son los resultados obtenidos con la siguiente configuración:

  • el servidor se ejecuta en el puerto 27100 en una ventana de comandos;
  • en la misma máquina, dos clientes, A y B, se ejecutan en otras dos ventanas; el cliente B se inició mientras el cliente A aún se comunicaba con el servidor.

En la ventana del cliente A:

1
2
3
4
5
6
7
8
9
> dotnet run internet-05.cs -- localhost 27100
Connected to the server 127.0.0.1:27100 from 127.0.0.1:41404
Request (bye to stop): line1A
Response: [line1A]
Request (bye to stop): line2A
Response: [line2A]
Request (bye to stop): line3A
Response: [line3A]
Request (bye to stop): bye

El cliente A envió tres líneas, que fueron devueltas como eco, y luego escribió [bye]: cerró la conexión sin enviar nada al servidor.

En la ventana del cliente B:

1
2
3
4
5
6
7
8
> dotnet run internet-05.cs -- localhost 27100
Connected to the server 127.0.0.1:27100 from 127.0.0.1:47282
Request (bye to stop): line1B
Response: [line1B]
Request (bye to stop): line2B
Response: [line2B]
Request (bye to stop): line3B
The server has closed the connection

El cliente B envió dos líneas y, luego, antes de escribir la tercera, se terminó el servidor con Ctrl-C. La línea [line3B] se envió por una conexión que el servidor ya había cerrado: la lectura de la respuesta (línea 8) devolvió [null].

En la ventana del servidor:

> dotnet run internet-04.cs -- 27100
Echo server started on 0.0.0.0:27100
Start of service to client 0 (127.0.0.1:41404)
<--- client 0 : line1A
---> client 0 : [line1A]
Start of service to client 1 (127.0.0.1:47282)
<--- client 0 : line2A
---> client 0 : [line2A]
<--- client 0 : line3A
---> client 0 : [line3A]
End of service to client 0
<--- client 1 : line1B
---> client 1 : [line1B]
<--- client 1 : line2B
---> client 1 : [line2B]
Server stop requested
Service to client 1 interrupted by the server stop
End of service to client 1
  • Línea 2: el servidor escucha en el puerto 27100 en todas las direcciones IPv4 de la máquina (0.0.0.0);
  • líneas 3–6: ambos clientes llegaron desde la misma máquina (127.0.0.1) usando puertos diferentes, elegidos por el sistema. Estos puertos distinguen las dos conexiones, que terminan ambas en el puerto 27100 del servidor;
  • Línea 6: el cliente 1 (B) es atendido mientras el cliente 0 (A) aún está siendo atendido: el servidor atiende, en efecto, a varios clientes simultáneamente;
  • Línea 11: el servidor detectó que el cliente A cerró la conexión;
  • líneas 16–18: se presionó Ctrl-C en la ventana del servidor. Se canceló la espera de un nuevo cliente y luego se interrumpió, mediante el mismo token de cancelación, el servicio al cliente 1, que esperaba una línea. El servidor se cerró correctamente.

Por último, esto es lo que sucede cuando se intenta conectar a un puerto en el que no escucha ningún servicio:

> dotnet run internet-05.cs -- localhost 27199
The following error occurred: ConnectionRefused (Connection refused)

[ConnectAsync] lanzó una [SocketException] con el código [ConnectionRefused]: la máquina respondió, pero ningún programa escucha en el puerto 27199. El mensaje proviene del sistema operativo; en Windows es diferente.

12.6.3. Un cliente TCP genérico

Escribiremos un cliente TCP genérico, que se iniciará de la siguiente manera:

dotnet run internet-06.cs -- machine port

Funcionará de forma similar a los clientes [telnet] y PuTTY: permitirá la comunicación con cualquier servidor TCP basado en texto.

En la aplicación anterior, el protocolo de comunicación era conocido: el cliente enviaba una sola línea y el servidor respondía con una sola línea. Cada servicio tiene su propio protocolo específico, y también pueden presentarse las siguientes situaciones:

  • el cliente debe enviar varias líneas de texto antes de recibir una respuesta (una solicitud HTTP);
  • la respuesta de un servidor puede constar de varias líneas de texto (la respuesta [EHLO] de un servidor SMTP, un documento HTML);
  • el servidor puede hablar primero (el mensaje de bienvenida de los servidores SMTP y POP).

Por lo tanto, el ciclo de “enviar una sola línea al servidor / recibir una sola línea enviada por el servidor” no siempre es adecuado. Para manejar protocolos más complejos que el protocolo de eco, el cliente TCP genérico realiza dos tareas en paralelo:

  • el programa principal lee las líneas de texto escritas con el teclado y las envía al servidor;
  • una tarea independiente se dedica a leer las líneas de texto enviadas por el servidor. En cuanto recibe una, la muestra en la consola. No se detiene hasta que se cierra la conexión.

El curso de 2008 asignaba la tarea de leer las respuestas del servidor a un hilo del grupo. El programa [internet-06.cs] es el siguiente:

using System.Net.Sockets;

// cliente TCP genérico
// - se conecta al servicio (máquina, puerto)
// - envía al servidor cada línea escrita con el teclado
// - una tarea separada muestra continuamente las líneas enviadas por el servidor
// llamada: dotnet run internet-06.cs -- machine port

const string syntax = "Syntax: dotnet run internet-06.cs -- machine port";
if (args.Length != 2 || !int.TryParse(args[1], out int port) || port is < 1 or > 65535)
{
    Console.WriteLine(syntax);
    return;
}
string server = args[0];

// conexión al servicio
using var client = new TcpClient();
try
{
    await client.ConnectAsync(server, port);
}
catch (SocketException ex)
{
    Console.WriteLine($"Unable to connect to the service ({server}, {port}): {ex.Message}");
    return;
}

NetworkStream stream = client.GetStream();
// las líneas enviadas terminan con \r\n, como exigen HTTP, SMTP, POP, FTP...
var writer = new StreamWriter(stream) { AutoFlush = true, NewLine = "\r\n" };

// la lectura de las líneas del servidor se entrega a una tarea que trabaja en paralelo
Task reception = ReceiveAsync(new StreamReader(stream));

// la lectura de los comandos del teclado se hace en el programa principal
Console.WriteLine("Type your commands (bye to stop):");
try
{
    while (true)
    {
        // Console.ReadLine es bloqueante: lo ejecutamos en una tarea del grupo de hilos
        Task<string?> input = Task.Run(Console.ReadLine);
        // esperamos ya sea una línea escrita con el teclado, o el final de la recepción
        if (await Task.WhenAny(input, reception) == reception)
        {
            // el servidor ha cerrado la conexión: no tiene caso esperar la entrada
            Console.WriteLine("[the server has closed the connection]");
            break;
        }
        string? command = await input;
        // ¿terminó?
        if (command is null || command.Trim().Equals("bye", StringComparison.OrdinalIgnoreCase))
        {
            break;
        }
        // enviamos el comando al servidor
        await writer.WriteLineAsync(command);
    }
}
catch (IOException ex)
{
    Console.WriteLine($"The following error occurred while writing: {ex.Message}");
}
// cerramos la conexión: la tarea de recepción termina si no lo ha hecho ya
client.Close();
await reception;

// --------------------------------------------------------------------
// muestra las líneas enviadas por el servidor hasta que se cierra la conexión
static async Task ReceiveAsync(StreamReader reader)
{
    try
    {
        while (await reader.ReadLineAsync() is string response)
        {
            Console.WriteLine($"<-- {response}");
        }
    }
    catch (Exception ex) when (ex is IOException or ObjectDisposedException)
    {
        // la conexión se cerró durante la lectura: la tarea termina
    }
}
  • línea 21: el cliente se conecta al servidor;
  • línea 31: las líneas enviadas terminan con \r\n, como exigen los protocolos que queremos explorar;
  • línea 34: la lectura de las líneas enviadas por el servidor se delega en el método asíncrono [ReceiveAsync]. No lo esperamos de inmediato: la tarea [reception] se ejecuta en paralelo con el programa principal;
  • Líneas 40–58: el ciclo de entrada por teclado y de envío de datos al servidor;
  • línea 43: no existe una entrada de teclado realmente asíncrona. Por lo tanto, [Console.ReadLine], que es bloqueante, se ejecuta en una tarea del grupo;
  • línea 45: [Task.WhenAny] devuelve la primera de las dos tareas que se complete: la entrada de una línea por teclado o la recepción, que termina cuando el servidor cierra la conexión. En este último caso, no hay necesidad de esperar a que el usuario escriba algo: se sale del ciclo. En cambio, el cliente de 2008 esperaba a que el usuario escribiera [bye];
  • línea 51: la línea escrita con el teclado;
  • línea 58: se envía al servidor;
  • líneas 66–67: se cierra la conexión y luego el programa espera a que termine la tarea de recepción, que a su vez finaliza si todavía estaba leyendo. Cuando el programa termina, cualquier entrada de teclado en curso se descarta;
  • líneas 71–82: el método ejecutado por la tarea de recepción. Muestra cada línea recibida, precedida de [<--], hasta el final del flujo. Si el cliente cierra la conexión mientras hay una lectura en curso, la operación de lectura actual termina con una excepción, que se captura: el filtro [when] (C# 6) captura únicamente los dos tipos de excepción esperados.

Ahora podemos enviar manualmente una solicitud HTTP a nuestro servidor web de prueba, que se ejecuta en otra ventana. Las líneas precedidas de [<--] son las enviadas por el servidor; las demás se escribieron manualmente:

> dotnet run internet-06.cs -- localhost 27110
Type your commands (bye to stop):
GET /hello?name=Serge HTTP/1.1
Host: localhost:27110
Connection: close

<-- HTTP/1.1 200 OK
<-- Connection: close
<-- Content-Type: text/plain; charset=utf-8
<-- Date: Sat, 03 Oct 2026 09:49:07 GMT
<-- Server: Kestrel
<-- Transfer-Encoding: chunked
<-- 
<-- c
<-- Hello Serge!
<-- 0
<-- 
[the server has closed the connection]
  • líneas 3–5: la solicitud, escrita con el teclado: pedimos el documento [/hello?name=Serge]. El encabezado [Connection: close] indica al servidor que cierre la conexión una vez enviada su respuesta;
  • la línea en blanco que sigue termina la solicitud. Esta desencadena la respuesta del servidor;
  • línea 7: se encontró el documento;
  • línea 8: el servidor anuncia que cerrará la conexión después de enviar su respuesta;
  • línea 9: esta vez, el documento es texto plano;
  • línea 12: el servidor no especificó el tamaño del documento ([Content-Length]); lo envía en fragmentos (chunks), cada uno precedido por su tamaño en hexadecimal;
  • líneas 14–16: un único fragmento de 0x0c = 12 bytes, el texto [Hello Serge!], seguido de un fragmento de tamaño cero que marca el final del documento;
  • línea 18: como se solicitó, el servidor cerró la conexión. El cliente lo detectó y se cerró por sí mismo.

Intentemos de nuevo sin el encabezado [Connection: close], solicitando la raíz del sitio:

> dotnet run internet-06.cs -- localhost 27110
Type your commands (bye to stop):
GET / HTTP/1.1
Host: localhost:27110

<-- HTTP/1.1 200 OK
<-- Content-Length: 169
<-- Content-Type: text/html; charset=utf-8
<-- Date: Sat, 03 Oct 2026 09:49:13 GMT
<-- Server: Kestrel
<-- 
<-- <!DOCTYPE html>
<-- <html lang="en">
<-- <head><meta charset="utf-8"><title>Test server</title></head>
<-- <body><h1>Welcome to the test server of the C# course</h1></body>
<-- </html>
bye
  • línea 7: se anuncia el documento junto con su tamaño, 169 bytes. Así, el cliente sabe dónde termina;
  • línea 16: el documento se ha recibido por completo, pero el servidor no ha cerrado la conexión: en HTTP/1.1, esta permanece abierta de forma predeterminada para otras solicitudes. El servidor espera una nueva solicitud; el usuario escribe entonces [bye] para cerrar la conexión.

Cuando el servidor no está disponible, la conexión falla:

> dotnet run internet-06.cs -- localhost 27199
Unable to connect to the service (localhost, 27199): Connection refused

El lector puede utilizar este cliente TCP genérico con el servidor de eco o, si dispone de un servidor SMTP o POP3 que acepte conexiones sin cifrar (como un servidor de pruebas instalado localmente), para reproducir los diálogos de ejemplo mostrados anteriormente.

12.6.4. Un servidor TCP genérico

Ahora nos centraremos en un servidor:

  • que muestra en la pantalla las líneas enviadas por sus clientes;
  • que envía como respuestas las líneas de texto escritas con el teclado por un usuario. El usuario, por lo tanto, actúa como el servidor.

El programa se inicia en una ventana de comandos mediante [dotnet run internet-07.cs -- port], donde [port] es el puerto al que deben conectarse los clientes. El servicio a un cliente lo prestan dos procesos:

  • el programa principal:
    • atiende a los clientes uno tras otro, no en paralelo. Como la consola no puede ser utilizada por dos clientes simultáneamente, nuestro servidor atiende a un solo cliente a la vez. Los clientes que se conectan durante ese tiempo tienen su conexión establecida por el sistema, pero deben esperar a que el programa los acepte;
    • lee las líneas escritas por el usuario con el teclado y las envía al cliente. El usuario indica con el comando [bye] que cierra la conexión con el cliente;
  • una tarea independiente se dedica exclusivamente a leer las líneas de texto enviadas por el cliente.

El servidor nunca se detiene, a menos que el usuario presione Ctrl-C en el teclado.

El programa [internet-07.cs] es el siguiente:

using System.Net;
using System.Net.Sockets;

// servidor TCP genérico
// - muestra las líneas enviadas por el cliente
// - le envía como respuestas las líneas escritas con el teclado por el usuario
// los clientes se atienden uno tras otro (una sola consola)
// llamada: dotnet run internet-07.cs -- port

const string syntax = "Syntax: dotnet run internet-07.cs -- port";
if (args.Length != 1 || !int.TryParse(args[0], out int port) || port is < 1 or > 65535)
{
    Console.WriteLine(syntax);
    return;
}

// el servicio de escucha
var listener = new TcpListener(IPAddress.Any, port);
listener.Start();
Console.WriteLine($"Generic server started on {listener.LocalEndpoint}");

// la entrada de teclado en curso (puede sobrevivir a la conexión de un cliente)
Task<string?>? input = null;
// bucle de servicio - el servidor se detiene con Ctrl-C
while (true)
{
    // espera de un cliente
    Console.WriteLine("Waiting for the next client...");
    using TcpClient client = await listener.AcceptTcpClientAsync();
    Console.WriteLine($"Client {client.Client.RemoteEndPoint}");
    NetworkStream stream = client.GetStream();
    var writer = new StreamWriter(stream) { AutoFlush = true, NewLine = "\r\n" };
    // una tarea separada muestra las líneas enviadas por el cliente
    Task reception = ReceiveAsync(new StreamReader(stream));
    // la lectura de las respuestas desde el teclado se hace en el programa principal
    Console.WriteLine("Type your responses (bye to close the connection with the client):");
    try
    {
        while (true)
        {
            // lanzamos una entrada de teclado si no hay ninguna en curso
            input ??= Task.Run(Console.ReadLine);
            // esperamos ya sea una línea escrita con el teclado, o la partida del cliente
            if (await Task.WhenAny(input, reception) == reception)
            {
                // la entrada en curso servirá al siguiente cliente
                Console.WriteLine("[the client has closed the connection]");
                break;
            }
            string? response = await input;
            input = null;
            // fin de la entrada de teclado (Ctrl-D, Ctrl-Z): detención del servidor
            if (response is null)
            {
                listener.Stop();
                return;
            }
            // ¿fin de la conexión con este cliente?
            if (response.Trim().Equals("bye", StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine("[connection closed by the server]");
                break;
            }
            // enviamos la respuesta al cliente
            await writer.WriteLineAsync(response);
        }
    }
    catch (IOException ex)
    {
        Console.WriteLine($"The following error occurred while writing: {ex.Message}");
    }
    // cerramos la conexión con el cliente
    client.Close();
    await reception;
}

// --------------------------------------------------------------------
// muestra las líneas enviadas por el cliente hasta que se cierra la conexión
static async Task ReceiveAsync(StreamReader reader)
{
    try
    {
        while (await reader.ReadLineAsync() is string request)
        {
            Console.WriteLine($"<-- {request}");
        }
    }
    catch (Exception ex) when (ex is IOException or ObjectDisposedException)
    {
        // la conexión se cerró durante la lectura: la tarea termina
    }
}
  • líneas 18–19: se crea e inicia el servicio de escucha. Escucha en todas las interfaces de red de la máquina;
  • línea 23: la entrada de teclado en curso. Se declara fuera del ciclo de clientes, por una razón que se explica más abajo;
  • línea 25: ciclo infinito de espera de clientes. El usuario detendrá el servidor presionando Ctrl-C;
  • línea 29: espera de un cliente. Cuando llega un cliente, la instancia [TcpClient] devuelta por [AcceptTcpClientAsync] representa el lado del servidor de la conexión abierta con ese cliente. La declaración [using] la libera al final de cada iteración del ciclo;
  • línea 34: la lectura de las líneas enviadas por el cliente corre a cargo de una tarea independiente, como en el cliente genérico;
  • líneas 39–65: el ciclo de ingreso por teclado de las respuestas que se enviarán al cliente;
  • Línea 42: el operador [??=] (C# 8) inicia una nueva entrada solo si no hay ninguna en curso. En efecto, cuando un cliente cierra la conexión (línea 44), el programa pasa al siguiente cliente sin esperar una entrada, y la entrada de teclado iniciada para el cliente anterior sigue en curso: la utilizará el siguiente cliente. Iniciar una segunda haría que dos procesos de entrada compitieran por las mismas pulsaciones de teclas;
  • línea 53: si la entrada estándar está cerrada, el servidor se detiene;
  • línea 59: el comando [bye] cierra la conexión con el cliente actual;
  • línea 65: la línea escrita se envía al cliente;
  • líneas 73–74: se cierra la conexión y se espera a que termine la operación de lectura;
  • líneas 79–90: el método que muestra continuamente en la consola las líneas de texto enviadas por el cliente. Es similar a lo que vimos para el cliente TCP genérico.

El curso de 2008 utilizaba este servidor para simular un servidor web consultado por un navegador. Haremos lo mismo, reemplazando el navegador por [curl]. El servidor genérico se ejecuta en el puerto 27101. En otra ventana, pedimos a [curl] la URL [http://localhost:27101/example.html]. [curl] se conecta entonces al puerto 27101 de la máquina [localhost] y solicita el documento [/example.html]. Esta es la ventana del servidor:

> dotnet run internet-07.cs -- 27101
Generic server started on 0.0.0.0:27101
Waiting for the next client...
Client 127.0.0.1:52208
<-- GET /example.html HTTP/1.1
<-- Host: localhost:27101
<-- User-Agent: curl/8.5.0
<-- Accept: */*
<-- 
Type your responses (bye to close the connection with the client):
HTTP/1.1 200 OK
Server: generic tcp server
Connection: close
Content-Type: text/html; charset=utf-8

<html><head><title>Generic server</title></head>
<body><h1>Response of the generic server</h1></body></html>
bye
[connection closed by the server]
Waiting for the next client...
  • línea 4: ha llegado un cliente;
  • líneas 5–8: vemos la solicitud HTTP enviada por [curl], que termina con una línea en blanco. Un navegador enviaría muchos más encabezados (idiomas y formatos admitidos, compresión, cookies, etc.): el lector puede comprobarlo solicitando la misma URL desde su navegador;
  • Líneas 10–17: el usuario del teclado es aquí el verdadero servidor, y elabora la respuesta manualmente. Se limita al mínimo indispensable: una línea de estado, tres encabezados, una línea en blanco y el documento HTML. No especifica el tamaño del documento ([Content-Length]) pero indica que cerrará la conexión después de enviarlo ([Connection: close]). Esto es suficiente: cuando el cliente vea que la conexión se cierra, sabrá que la respuesta está completa;
  • línea 19: el usuario escribió [bye]: el servidor cierra la conexión con el cliente;
  • línea 20: el servidor espera a un nuevo cliente. Lo detenemos con Ctrl-C.

Y esto es lo que [curl] mostró:

> curl -v http://localhost:27101/example.html
* Host localhost:27101 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27101...
* Connected to localhost (127.0.0.1) port 27101
> GET /example.html HTTP/1.1
> Host: localhost:27101
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 200 OK
< Server: generic tcp server
< Connection: close
< Content-Type: text/html; charset=utf-8
< 
<html><head><title>Generic server</title></head>
<body><h1>Response of the generic server</h1></body></html>
* Closing connection

[curl] recibió exactamente lo que se escribió en la ventana del servidor (líneas 12–18) y detectó que la conexión se cerró (línea 19). Un navegador habría mostrado la página HTML recibida, con el título [Generic server] en la pestaña.

12.6.5. Un cliente web

En el ejemplo anterior vimos los encabezados HTTP enviados por [curl]. Vamos a escribir un cliente web que toma una URL como parámetro y muestra en la pantalla todo lo que el servidor le envía. Supondremos que el servidor admite el protocolo HTTP/1.1. Nuestro cliente enviará la siguiente solicitud:

1
2
3
4
GET /document HTTP/1.1
Host: machine:port
User-Agent: web-client-csharp-course
Connection: close
  • la primera línea especifica el documento deseado;
  • el encabezado [Host] identifica el servidor consultado;
  • el encabezado [User-Agent] identifica a nuestro cliente;
  • el encabezado [Connection] indica que queremos que el servidor cierre la conexión después de responder: leeremos su respuesta hasta el final del flujo;
  • la línea en blanco termina la solicitud.

Si, en la primera línea, reemplazamos [GET] por [HEAD], el servidor nos enviará solo los encabezados HTTP de su respuesta, y no el documento.

Nuestro cliente web se invocará de la siguiente manera: [dotnet run internet-08.cs -- URL command], donde [URL] es la URL deseada y [command] es una de las dos palabras clave [GET] o [HEAD]. El programa [internet-08.cs] es el siguiente:

using System.Net.Sockets;

// cliente web: solicita una URL con una solicitud HTTP/1.1 escrita "a mano"
// y muestra todo lo que el servidor devuelve (encabezados HTTP y documento)
// llamada: dotnet run internet-08.cs -- URL GET|HEAD

const string syntax = "Syntax: dotnet run internet-08.cs -- http://machine[:port][/document] GET|HEAD";
if (args.Length != 2)
{
    Console.WriteLine(syntax);
    return;
}

// verificación de la URL: debe ser absoluta y usar el esquema http
if (!Uri.TryCreate(args[0], UriKind.Absolute, out Uri? uri) || uri.Scheme != Uri.UriSchemeHttp)
{
    Console.WriteLine($"Incorrect URL [{args[0]}]. {syntax}");
    return;
}
// verificación del comando
string command = args[1].ToUpper();
if (command is not ("GET" or "HEAD"))
{
    Console.WriteLine($"The second parameter must be GET or HEAD. {syntax}");
    return;
}

try
{
    // conexión al servidor web
    using var client = new TcpClient();
    await client.ConnectAsync(uri.Host, uri.Port);
    await using NetworkStream stream = client.GetStream();
    using var reader = new StreamReader(stream);
    // HTTP exige el fin de línea \r\n (Environment.NewLine es \n en Linux)
    await using var writer = new StreamWriter(stream) { NewLine = "\r\n" };
    // la solicitud: línea de comando, encabezados HTTP, línea vacía
    await writer.WriteLineAsync($"{command} {uri.PathAndQuery} HTTP/1.1");
    await writer.WriteLineAsync($"Host: {uri.Authority}");
    await writer.WriteLineAsync("User-Agent: web-client-csharp-course");
    await writer.WriteLineAsync("Connection: close");
    await writer.WriteLineAsync();
    // la solicitud sale a la red de una sola vez
    await writer.FlushAsync();
    // la respuesta se lee hasta que el servidor cierra la conexión
    while (await reader.ReadLineAsync() is string line)
    {
        Console.WriteLine(line);
    }
}
catch (SocketException ex)
{
    Console.WriteLine($"The following error occurred: {ex.SocketErrorCode} ({ex.Message})");
}
catch (IOException ex)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
}

Una novedad de este programa es el uso de la clase [Uri] (espacio de nombres [System]). El programa recibe una URL (Uniform Resource Locator), una forma específica de URI (Uniform Resource Identifier), con el formato [http://server:port/path?param1=val1&param2=val2]. La clase [Uri] permite descomponer esta cadena en sus distintos componentes:

  • Línea 15: [Uri.TryCreate] construye un objeto [Uri] a partir de la cadena [args[0]] y devuelve [false] si la cadena no es una URI absoluta válida (falta el esquema, el servidor, etc.). El curso de 2008 utilizaba el constructor [new Uri(...)] dentro de un [try/catch]; [TryCreate] evita la excepción. También verificamos que el esquema sea [http]: nuestro cliente no puede realizar la negociación TLS para [https]. Una vez construido el objeto [Uri], tenemos acceso a los distintos elementos de la URI. Así, si el objeto [uri] se construyó a partir de la cadena [http://localhost:27110/hello?name=Serge], tenemos:
    • [uri.Scheme]: http;
    • [uri.Host]: localhost;
    • [uri.Port]: 27110 (80 si no se especifica el puerto en la URL, 443 para HTTPS);
    • [uri.Authority]: localhost:27110 (el puerto se omite si es el puerto predeterminado del esquema);
    • [uri.AbsolutePath]: /hello;
    • [uri.Query]: ?name=Serge;
    • [uri.PathAndQuery]: /hello?name=Serge;
  • línea 22: el patrón [not (... or ...)] (C# 9) verifica que el comando sea [GET] o [HEAD];
  • línea 32: se conecta al servidor especificado por la URL;
  • línea 36: HTTP exige finales de línea \r\n;
  • líneas 38–42: la solicitud HTTP;
  • línea 44: no se utilizó [AutoFlush]: la solicitud se envía de una sola vez, una vez escrita por completo;
  • líneas 46–48: la respuesta se muestra hasta que el servidor cierra la conexión.

Solicitemos solo los encabezados de la raíz de nuestro servidor de pruebas:

1
2
3
4
5
6
7
> dotnet run internet-08.cs -- http://localhost:27110/ HEAD
HTTP/1.1 200 OK
Content-Length: 169
Connection: close
Content-Type: text/html; charset=utf-8
Date: Sat, 03 Oct 2026 09:49:51 GMT
Server: Kestrel

Obtenemos la línea de estado y los encabezados, seguidos de una línea en blanco, pero no el documento. El encabezado [Content-Length] indica el tamaño que habría tenido el documento con el comando [GET]. Con el comando [GET] y un documento enviado en fragmentos (chunks):

> dotnet run internet-08.cs -- "http://localhost:27110/hello?name=Serge" GET
HTTP/1.1 200 OK
Connection: close
Content-Type: text/plain; charset=utf-8
Date: Sat, 03 Oct 2026 09:49:53 GMT
Server: Kestrel
Transfer-Encoding: chunked

c
Hello Serge!
0

Observe las comillas alrededor de la URL en el comando: sin ellas, algunos intérpretes de comandos asignarían un significado especial al carácter [?]. El documento ([Hello Serge!]) está enmarcado por los tamaños de sus fragmentos, como ya vimos. Nuestro cliente muestra la respuesta tal cual; un verdadero cliente HTTP, en cambio, debe reconstruir el documento a partir de los fragmentos.

Un documento inexistente:

1
2
3
4
5
6
> dotnet run internet-08.cs -- http://localhost:27110/unknown GET
HTTP/1.1 404 Not Found
Content-Length: 0
Connection: close
Date: Sat, 03 Oct 2026 09:49:54 GMT
Server: Kestrel

Una URL sujeta a una redirección:

1
2
3
4
5
6
7
> dotnet run internet-08.cs -- http://localhost:27110/old GET
HTTP/1.1 302 Found
Content-Length: 0
Connection: close
Date: Sat, 03 Oct 2026 09:49:56 GMT
Server: Kestrel
Location: /hello?name=visitor
  • Línea 2: el código 302 indica una redirección; el documento solicitado se encuentra temporalmente en otra dirección;
  • línea 7: esta dirección la proporciona el encabezado [Location]. Aquí es relativa: la dirección completa es [http://localhost:27110/hello?name=visitor].

Nuestro cliente se detuvo ahí. Un navegador, en cambio, habría solicitado automáticamente la nueva dirección. Eso es lo que hará nuestro próximo cliente.

Por último, se rechaza una solicitud a una URL [https]:

> dotnet run internet-08.cs -- https://learn.microsoft.com/ GET
Incorrect URL [https://learn.microsoft.com/]. Syntax: dotnet run internet-08.cs -- http://machine[:port][/document] GET|HEAD

12.6.6. Un cliente web que gestiona las redirecciones

El cliente web anterior no gestiona una posible redirección de la URL que solicitó. Los códigos de estado de redirección son los siguientes:

Código
Significado
301 Moved Permanently
El documento se trasladó de forma permanente a una nueva dirección; un navegador puede guardar la nueva dirección
302 Found
El documento se encuentra temporalmente en otra dirección
303 See Other
La respuesta debe solicitarse a otra dirección con el método [GET] (se usa después de enviar un formulario)
307 Temporary Redirect, 308 Permanent Redirect
Igual que 302 y 301, pero el cliente debe reenviar la solicitud con el mismo método ([POST] sigue siendo [POST])

En cualquier caso, la nueva dirección la proporciona el encabezado [Location], ya sea como URL absoluta o relativa. El cliente de 2008 detectaba una redirección por la presencia de la palabra [moved] en la línea de estado. Esto no es confiable: el mensaje que sigue al código es arbitrario, y Kestrel responde con [302 Found], sin la palabra [moved]. Nosotros nos basamos en el código de estado mismo.

El programa [internet-09.cs] es el siguiente:

using System.Net.Sockets;

// cliente web que sigue las redirecciones (códigos 301, 302, 303, 307, 308)
// llamada: dotnet run internet-09.cs -- URL GET|HEAD

const string syntax = "Syntax: dotnet run internet-09.cs -- http://machine[:port][/document] GET|HEAD";
if (args.Length != 2)
{
    Console.WriteLine(syntax);
    return;
}
if (!Uri.TryCreate(args[0], UriKind.Absolute, out Uri? uri) || uri.Scheme != Uri.UriSchemeHttp)
{
    Console.WriteLine($"Incorrect URL [{args[0]}]. {syntax}");
    return;
}
string command = args[1].ToUpper();
if (command is not ("GET" or "HEAD"))
{
    Console.WriteLine($"The second parameter must be GET or HEAD. {syntax}");
    return;
}

// los códigos de estado HTTP que señalan una redirección
int[] redirectionCodes = [301, 302, 303, 307, 308];
// número máximo de redirecciones seguidas
const int maxRedirections = 3;

try
{
    // una iteración por URL solicitada
    for (int nbRedirections = 0; ; nbRedirections++)
    {
        // solicitamos la URL y obtenemos la posible dirección de redirección
        string? location = await RequestAsync(uri, command, redirectionCodes);
        // sin redirección: ha terminado
        if (location is null)
        {
            break;
        }
        // demasiadas redirecciones: nos rendimos
        if (nbRedirections == maxRedirections)
        {
            Console.WriteLine($"<-- Giving up: more than {maxRedirections} redirections -->");
            break;
        }
        // la nueva URL: la dirección de redirección puede ser absoluta o relativa a la URL actual
        uri = new Uri(uri, location);
        Console.WriteLine($"<-- Redirection to {uri} -->{Environment.NewLine}");
    }
}
catch (SocketException ex)
{
    Console.WriteLine($"The following error occurred: {ex.SocketErrorCode} ({ex.Message})");
}
catch (Exception ex) when (ex is IOException or UriFormatException)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
}

// --------------------------------------------------------------------
// solicita la URL [uri], muestra la respuesta del servidor
// devuelve la dirección de redirección, o null si no hay redirección
static async Task<string?> RequestAsync(Uri uri, string command, int[] redirectionCodes)
{
    using var client = new TcpClient();
    await client.ConnectAsync(uri.Host, uri.Port);
    await using NetworkStream stream = client.GetStream();
    using var reader = new StreamReader(stream);
    await using var writer = new StreamWriter(stream) { NewLine = "\r\n" };
    // la solicitud HTTP
    await writer.WriteLineAsync($"{command} {uri.PathAndQuery} HTTP/1.1");
    await writer.WriteLineAsync($"Host: {uri.Authority}");
    await writer.WriteLineAsync("User-Agent: web-client-csharp-course");
    await writer.WriteLineAsync("Connection: close");
    await writer.WriteLineAsync();
    await writer.FlushAsync();

    // la línea de estado, por ejemplo: HTTP/1.1 302 Found
    string statusLine = await reader.ReadLineAsync() ?? "";
    Console.WriteLine(statusLine);
    string[] fields = statusLine.Split(' ');
    bool redirection = fields.Length >= 2 && int.TryParse(fields[1], out int code)
        && redirectionCodes.Contains(code);

    // los encabezados HTTP, hasta la línea vacía
    string? location = null;
    while (await reader.ReadLineAsync() is string header && header != "")
    {
        Console.WriteLine(header);
        // el nombre de un encabezado HTTP no distingue mayúsculas de minúsculas
        if (redirection && header.StartsWith("Location:", StringComparison.OrdinalIgnoreCase))
        {
            location = header["Location:".Length..].Trim();
        }
    }
    Console.WriteLine();
    // el posible documento
    while (await reader.ReadLineAsync() is string line)
    {
        Console.WriteLine(line);
    }
    return location;
}

En comparación con la versión anterior, los cambios son los siguientes:

  • línea 25: los códigos de estado que indican una redirección;
  • línea 27: el número máximo de redirecciones consecutivas. Sin un límite, un servidor mal configurado podría atrapar a nuestro cliente en un bucle infinito (los navegadores se rinden después de unas veinte redirecciones);
  • línea 32: el código que antes se ejecutaba para una sola URL ahora puede ejecutarse sucesivamente para varias URL;
  • línea 35: el método [RequestAsync] solicita la URL actual, muestra la respuesta y devuelve la URL de redirección, o [null] si no hay redirección;
  • líneas 42–44: el proceso se aborta si se alcanza el número máximo de redirecciones;
  • línea 48: el constructor [Uri(Uri base, string relative)] calcula la nueva URL. Si [location] es una dirección absoluta, se usa tal cual; si es relativa, se completa a partir de la URL actual, [uri]. El curso de 2008 distinguía entre ambos casos con una prueba: el compilador se encarga de esto;
  • líneas 64–103: la solicitud de una URL:
    • línea 80: lectura de la línea de estado, por ejemplo [HTTP/1.1 302 Found];
    • líneas 82–84: se extrae el código (el segundo campo de la línea) y se verifica si es uno de los códigos de redirección;
    • líneas 88–94: lectura de los encabezados hasta la línea vacía. Si hay una redirección, se busca el encabezado [Location], ignorando las mayúsculas y minúsculas, ya que los nombres de los encabezados en HTTP no distinguen entre ellas. La expresión [header["Location:".Length..]] utiliza un rango (C# 8) para extraer lo que sigue al nombre del encabezado;
    • líneas 98–103: se muestra el resto de la respuesta y luego se devuelve la URL de redirección encontrada.

Volvamos a la URL [/old]:

> dotnet run internet-09.cs -- http://localhost:27110/old GET
HTTP/1.1 302 Found
Content-Length: 0
Connection: close
Date: Sat, 03 Oct 2026 09:50:00 GMT
Server: Kestrel
Location: /hello?name=visitor

<-- Redirection to http://localhost:27110/hello?name=visitor -->

HTTP/1.1 200 OK
Connection: close
Content-Type: text/plain; charset=utf-8
Date: Sat, 03 Oct 2026 09:50:00 GMT
Server: Kestrel
Transfer-Encoding: chunked

e
Hello visitor!
0
  • líneas 2–7: la redirección temporal a una dirección relativa;
  • línea 9: la nueva URL, completada mediante [new Uri(uri, location)];
  • líneas 11–19: la respuesta a la nueva URL. El documento, de 0x0e = 14 bytes, se envió en fragmentos.

La URL [/moved] se redirige de forma permanente a una dirección absoluta:

> dotnet run internet-09.cs -- http://localhost:27110/moved GET
HTTP/1.1 301 Moved Permanently
Content-Length: 0
Connection: close
Date: Sat, 03 Oct 2026 09:50:02 GMT
Server: Kestrel
Location: http://localhost:27110/

<-- Redirection to http://localhost:27110/ -->

HTTP/1.1 200 OK
Content-Length: 169
Connection: close
Content-Type: text/html; charset=utf-8
Date: Sat, 03 Oct 2026 09:50:02 GMT
Server: Kestrel

<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the test server of the C# course</h1></body>
</html>

La URL [/loop] se redirige a sí misma:

> dotnet run internet-09.cs -- http://localhost:27110/loop HEAD
HTTP/1.1 302 Found
Connection: close
Date: Sat, 03 Oct 2026 09:50:04 GMT
Server: Kestrel
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Found
Connection: close
Date: Sat, 03 Oct 2026 09:50:04 GMT
Server: Kestrel
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Found
Connection: close
Date: Sat, 03 Oct 2026 09:50:04 GMT
Server: Kestrel
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Found
Connection: close
Date: Sat, 03 Oct 2026 09:50:04 GMT
Server: Kestrel
Location: /loop

<-- Giving up: more than 3 redirections -->

Nuestro cliente siguió tres redirecciones y luego se rindió (línea 32). Con el comando [HEAD], no se envió ningún documento.

El registro del servidor web anotó todas las solicitudes de las entradas [A web client] y [A web client that handles redirects]:

> dotnet run internet-03.cs
Web server started on http://localhost:27110
HEAD / HTTP/1.1 -> 200
GET /hello?name=Serge HTTP/1.1 -> 200
GET /unknown HTTP/1.1 -> 404
GET /old HTTP/1.1 -> 302
GET /old HTTP/1.1 -> 302
GET /hello?name=visitor HTTP/1.1 -> 200
GET /moved HTTP/1.1 -> 301
GET / HTTP/1.1 -> 200
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302

Para cada redirección, muestra la solicitud que la provocó, seguida de la solicitud a la nueva dirección (líneas 7–8), y las cuatro solicitudes del bucle interrumpido (líneas 11–14).

Escribir un cliente HTTP basado en TCP ayuda a comprender el protocolo, pero un cliente real debe encargarse de muchas otras cosas: cifrado TLS, transmisión por fragmentos, compresión, conexiones persistentes, HTTP/2 y HTTP/3… La segunda parte de este capítulo presenta la clase [HttpClient] de .NET, que se ocupa de todo esto por nosotros.

12.7. Las clases de .NET especializadas en un protocolo

En los ejemplos anteriores, el protocolo HTTP se manejaba con un cliente TCP: nosotros mismos teníamos que construir las solicitudes, analizar las líneas de estado y los encabezados, y seguir las redirecciones. Habríamos podido construir de la misma manera un cliente SMTP o POP. .NET proporciona clases especializadas en los protocolos HTTP y SMTP. Estas clases conocen el protocolo de comunicación entre el cliente y el servidor, y le ahorran al desarrollador tener que gestionarlo. Las presentaremos a continuación.

Los programas de esta segunda parte, como los de la primera, son aplicaciones de un solo archivo en la carpeta [12-internet], numerados consecutivamente ([internet-10.cs] hasta [internet-19.cs]). La aplicación de ejemplo del final del capítulo constituye una solución aparte, [TaxV8]. Los puertos utilizados tienen la forma 272xx.

12.7.1. Las clases WebClient y WebRequest, ahora obsoletas

El curso de 2008 presentaba dos familias de clases:

  • la clase [WebClient], que solicitaba un documento con una sola instrucción (métodos [DownloadString], [DownloadData], [DownloadFile], [OpenRead]) o enviaba uno (métodos [UploadString], [UploadValues] para un formulario…);
  • las clases [WebRequest] / [WebResponse] y sus derivadas [HttpWebRequest] / [HttpWebResponse], que eran más flexibles: permitían elegir el método HTTP ([GET], [HEAD], [POST]), agregar encabezados y leer la respuesta a medida que llega.

Estas clases siguen existiendo en .NET 10 por compatibilidad, pero están marcadas como obsoletas desde .NET 6. El siguiente programa pequeño las utiliza:

1
2
3
4
5
using System.Net;

using var client = new WebClient();
Console.WriteLine(client.DownloadString("http://localhost:27210/"));
var request = WebRequest.Create("http://localhost:27210/");

Al compilarlo se producen las siguientes dos advertencias (reproducimos solo estas dos líneas de la salida de [dotnet build]):

1
2
3
> dotnet build webclient.cs
webclient.cs(3,20): warning SYSLIB0014: 'WebClient.WebClient()' is obsolete: 'WebRequest, HttpWebRequest, ServicePoint, and WebClient are obsolete. Use HttpClient instead.' (https://aka.ms/dotnet-warnings/SYSLIB0014)
webclient.cs(5,15): warning SYSLIB0014: 'WebRequest.Create(string)' is obsolete: 'WebRequest, HttpWebRequest, ServicePoint, and WebClient are obsolete. Use HttpClient instead.' (https://aka.ms/dotnet-warnings/SYSLIB0014)

El mensaje es claro: debe usar la clase [HttpClient]. Esta clase se introdujo con .NET 4.5 (2012); fue concebida desde el principio para la programación asíncrona (todos sus métodos de red son asíncronos), admite HTTP/1.1, HTTP/2 y HTTP/3, reutiliza sus conexiones y puede ser utilizada por varias tareas simultáneamente. En el .NET actual, [WebClient], y [WebRequest] no son, en realidad, más que fachadas construidas sobre [HttpClient]. No las estudiaremos más y retomaremos con [HttpClient], usando los ejemplos que el curso de 2008 trataba con ellas.

12.7.2. La clase HttpClient

12.7.2.1. Un servidor web de pruebas

Para ilustrar las capacidades de [HttpClient], necesitamos un servidor web más completo que el de la Parte 1 ([internet-03.cs]): debe aceptar formularios, intercambiar JSON y poder manejar retrasos. Por eso escribiremos un segundo servidor de pruebas, [internet-10.cs], una aplicación ASP.NET Core llamada “Minimal API”, igual que la primera. Una vez más, no es necesario entender este programa en detalle por ahora (ASP.NET Core se tratará en el próximo capítulo): basta con saber qué responde cada URL.

#:sdk Microsoft.NET.Sdk.Web
#:property PublishAot=false

// un servidor web local que servirá de objetivo para los clientes HttpClient
// llamada: dotnet run internet-10.cs [-- port]
int port = args.Length == 1 && int.TryParse(args[0], out int p) ? p : 27210;

var builder = WebApplication.CreateBuilder(args);
// sin registro de ASP.NET (solo las advertencias): escribimos el nuestro
builder.Logging.SetMinimumLevel(LogLevel.Warning);
var app = builder.Build();

// seguimiento en consola: cada solicitud, el puerto del cliente y el código de estado de la respuesta
app.Use(async (context, next) =>
{
    var request = context.Request;
    string start = $"{request.Method} {request.Path}{request.QueryString} {request.Protocol}"
        + $" (client port {context.Connection.RemotePort})";
    try
    {
        await next(context);
        Console.WriteLine($"{start} -> {context.Response.StatusCode}");
    }
    catch (OperationCanceledException) when (context.RequestAborted.IsCancellationRequested)
    {
        // el cliente abandonó la solicitud antes de la respuesta
        Console.WriteLine($"{start} -> abandoned by the client");
    }
});

// las URL de consulta aceptan los métodos GET y HEAD
string[] getHead = ["GET", "HEAD"];

// la página de inicio: un documento HTML
app.MapMethods("/", getHead, () => Results.Content("""
    <!DOCTYPE html>
    <html lang="en">
    <head><meta charset="utf-8"><title>Test server</title></head>
    <body><h1>Welcome to the HttpClient test server</h1></body>
    </html>

    """, "text/html; charset=utf-8"));

// un documento de texto construido a partir de un parámetro de la URL
app.MapMethods("/hello", getHead, (string? name) => $"Hello {name ?? "unknown"}!");

// los encabezados HTTP recibidos por el servidor, devueltos al cliente como texto
app.MapMethods("/headers", getHead, (HttpRequest request) =>
    string.Join("\n", request.Headers.Select(header => $"{header.Key}: {header.Value}")));

// redirección temporal (302) a una dirección relativa
app.MapMethods("/old", getHead, () => Results.Redirect("/hello?name=visitor"));

// una redirección que se repite sobre sí misma
app.MapMethods("/loop", getHead, () => Results.Redirect("/loop"));

// un error del servidor (500 Internal Server Error)
app.MapMethods("/error", getHead, () => Results.StatusCode(500));

// una respuesta que se toma su tiempo
app.MapGet("/slow", async (int seconds, CancellationToken token) =>
{
    await Task.Delay(TimeSpan.FromSeconds(seconds), token);
    return $"Response obtained after {seconds} s";
});

// un formulario enviado por POST: describimos lo que se recibió
app.MapPost("/form", async (HttpRequest request) =>
{
    IFormCollection form = await request.ReadFormAsync();
    string fields = string.Join(", ", form.Select(field => $"{field.Key}=[{field.Value}]"));
    return $"Content-Type received: {request.ContentType}\nFields received: {fields}";
});

// cualquier texto enviado por POST: lo devolvemos en mayúsculas
app.MapPost("/text", async (HttpRequest request) =>
{
    using var reader = new StreamReader(request.Body);
    string text = await reader.ReadToEndAsync();
    return $"Content-Type received: {request.ContentType}\nText received in upper case: {text.ToUpper()}";
});

// una pequeña "base de datos" de personas, intercambiada en formato JSON
List<Person> persons = [new(1, "Dupont", 42), new(2, "Durand", 35)];
Lock padlock = new();

// la lista de personas
app.MapGet("/api/persons", () =>
{
    lock (padlock)
    {
        return persons.ToList();
    }
});

// una persona designada por su número, o 404 si no existe
app.MapGet("/api/persons/{id:int}", (int id) =>
{
    lock (padlock)
    {
        return persons.Find(person => person.Id == id) is Person person
            ? Results.Ok(person)
            : Results.NotFound();
    }
});

// adición de una persona: el servidor le asigna un número y responde 201 Created
app.MapPost("/api/persons", (Person newPerson) =>
{
    lock (padlock)
    {
        Person created = newPerson with { Id = persons.Max(person => person.Id) + 1 };
        persons.Add(created);
        return Results.Created($"/api/persons/{created.Id}", created);
    }
});

// cualquier otra URL recibe la respuesta 404 Not Found (comportamiento predeterminado)
Console.WriteLine($"Web server started on http://localhost:{port}");
app.Run($"http://127.0.0.1:{port}");

// una persona
record Person(int Id, string Name, int Age);

Comentarios:

  • línea 2: las aplicaciones de un solo archivo están configuradas de forma predeterminada para la compilación nativa (AOT), que desactiva la serialización (JSON) basada en reflexión. Como en el Capítulo 5, la volvemos a activar: el servidor podrá convertir automáticamente sus objetos a JSON;
  • líneas 14–27: cada solicitud se registra en la consola junto con el puerto del cliente y el código de estado de la respuesta. El puerto del cliente nos permitirá determinar si dos solicitudes utilizaron la misma conexión TCP. Si el cliente aborta una solicitud antes de recibir una respuesta, Kestrel revoca el token [RequestAborted], y la operación en curso termina con una [OperationCanceledException]: también lo mostramos;
  • línea 35: la URL [/] devuelve un pequeño documento HTML;
  • línea 45: la URL [/hello?name=xx] genera el texto [Hello xx!];
  • línea 48: la URL [/headers] devuelve al cliente, como texto, los encabezados HTTP de la solicitud del cliente. Esto nos permitirá ver lo que envía [HttpClient]. El curso de 2008 utilizaba para este fin el servidor TCP genérico, al que el usuario sentado frente al teclado debía hacer responder;
  • líneas 52–55: una redirección temporal a [/hello?name=visitor] y una redirección que vuelve sobre sí misma, como en el servidor de la Parte 1;
  • línea 58: una respuesta 500 (error interno del servidor);
  • línea 61: la URL [/slow?seconds=n] no responde hasta que transcurren n segundos. El token [token] se cancela si el cliente aborta la solicitud: la espera se interrumpe entonces;
  • línea 68: la URL [/form] recibe un formulario enviado mediante el método [POST] y describe lo que recibió;
  • línea 76: la URL [/text] recibe texto arbitrario mediante [POST] y lo devuelve en mayúsculas;
  • líneas 84–114: un pequeño “conjunto de datos” de personas, intercambiado en formato JSON. [GET /api/persons] devuelve la lista de personas; [GET /api/persons/n] devuelve a la persona n.º n (o una respuesta 404); [POST /api/persons] agrega la persona enviada por el cliente, le asigna un número y responde con el código de estado 201 (Created). Como varias solicitudes pueden ser procesadas simultáneamente por distintos hilos, la lista está protegida por un bloqueo [Lock] (Capítulo 8);
  • línea 123: el tipo [Person], un registro ([record]);
  • línea 120: el servidor escucha en el puerto 27210 de la dirección de bucle invertido (loopback).

El servidor se inicia en una ventana de comandos y permanece allí durante todas las pruebas de esta sección. Las solicitudes que haya recibido se presentarán al final de la sección.

12.7.2.2. Descarga de un documento: GetStringAsync

La forma más sencilla de recuperar un documento con [HttpClient] es usar uno de los siguientes métodos:

Método
Función
Task<string> GetStringAsync(string url)
solicita la URL [url] con el método [GET] y devuelve el documento recibido como una cadena
Task<byte[]> GetByteArrayAsync(string url)
Igual que el anterior, con el documento devuelto como un arreglo de bytes (una imagen, por ejemplo)
Task<Stream> GetStreamAsync(string url)
Igual que el anterior, con el documento devuelto como un flujo que se lee a medida que llega (un archivo grande, por ejemplo)

Cada uno de ellos existe también con un parámetro de tipo [Uri] y con un parámetro adicional de tipo [CancellationToken]. Estos métodos lanzan una [HttpRequestException] si el servidor responde con un código de error.

El programa [internet-11.cs] es el siguiente:

// primeros pasos con HttpClient: descargar un documento como cadena
// el servidor de pruebas [internet-10.cs] debe estar en ejecución en el puerto 27210

// un cliente HTTP, y la dirección base de las URL relativas que se le solicitarán
using var client = new HttpClient { BaseAddress = new Uri("http://localhost:27210/") };

// 1 - un documento de texto
string text = await client.GetStringAsync("hello?name=Serge");
Console.WriteLine($"Document received: {text}");

// 2 - los encabezados HTTP enviados por HttpClient, tal como los recibió el servidor
Console.WriteLine("--- headers sent by default");
Console.WriteLine(await client.GetStringAsync("headers"));

// 3 - agregamos encabezados a todas las solicitudes de este cliente
client.DefaultRequestHeaders.UserAgent.ParseAdd("csharp-course-client/1.0");
client.DefaultRequestHeaders.Add("Accept-Language", "en-US");
Console.WriteLine("--- headers after adding User-Agent and Accept-Language");
Console.WriteLine(await client.GetStringAsync("headers"));

// 4 - un documento HTML, como arreglo de bytes
byte[] bytes = await client.GetByteArrayAsync("/");
Console.WriteLine($"--- the home page is {bytes.Length} bytes long");

// 5 - un documento que no existe
try
{
    await client.GetStringAsync("unknown");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"--- {ex.GetType().Name} : {ex.Message}");
    Console.WriteLine($"Status code: {(int?)ex.StatusCode} ({ex.StatusCode})");
}

Resultados (con el servidor [internet-10.cs] iniciado en otra ventana):

> dotnet run internet-11.cs
Document received: Hello Serge!
--- headers sent by default
Host: localhost:27210
--- headers after adding User-Agent and Accept-Language
Host: localhost:27210
User-Agent: csharp-course-client/1.0
Accept-Language: en-US
--- the home page is 163 bytes long
--- HttpRequestException : Response status code does not indicate success: 404 (Not Found).
Status code: 404 (NotFound)

Comentarios:

  • Línea 5: creación del cliente. La propiedad [BaseAddress] establece la dirección a la que se vinculan los valores de URL relativa que se usen después: [hello?name=Serge] se refiere así a [http://localhost:27210/hello?name=Serge]. La barra final de la dirección base es importante: sin ella, el último segmento de la ruta sería reemplazado por la URL relativa;
  • línea 8: una sola instrucción basta para recuperar el documento. [HttpClient] construyó la solicitud, se conectó, analizó la respuesta y reconstruyó el documento enviado en fragmentos ([Transfer-Encoding: chunked]), que nuestro cliente TCP de la primera parte mostraba tal cual;
  • Línea 13: en la línea 3 de los resultados vemos que [HttpClient] envía de forma predeterminada solo el encabezado obligatorio [Host]. La versión de 2008 de [WebClient] agregaba [Connection: Keep-Alive]; esto es innecesario en HTTP/1.1, donde la conexión se mantiene de forma predeterminada. Tampoco hay encabezado [User-Agent]: algunos servidores públicos rechazan las solicitudes que carecen de él;
  • Líneas 16–17: la colección [DefaultRequestHeaders] contiene los encabezados que se agregan a todas las solicitudes de este cliente. Los encabezados comunes tienen una propiedad tipada, como [UserAgent]; los demás se agregan por nombre, con [Add]. Las líneas 7–8 de los resultados muestran que el servidor, en efecto, los recibió;
  • línea 22: el documento se recibe como bytes. Observe la URL [/]: una URL relativa que comienza con una barra diagonal designa la raíz del sitio a partir de la dirección base;
  • líneas 26–33: un documento inexistente. [GetStringAsync] lanza una [HttpRequestException] cuya propiedad [StatusCode] (de tipo [HttpStatusCode?], .NET 5) devuelve el código de estado recibido. El curso de 2008 recibía una [WebException] en este caso.

12.7.2.3. Solicitud y respuesta: HttpRequestMessage y HttpResponseMessage

Los métodos [GetXxxAsync] devuelven solo el documento. Para gestionar la solicitud (método, encabezados) o examinar la respuesta (estado, encabezados), se utilizan las clases [HttpRequestMessage] y [HttpResponseMessage]:

Miembro
Función
new HttpRequestMessage(HttpMethod method, Uri url)
Una solicitud. [HttpMethod] tiene propiedades estáticas para los siguientes métodos: [HttpMethod.Get], [HttpMethod.Head], [HttpMethod.Post]…
HttpRequestMessage.Headers, Content
los encabezados de la solicitud y el documento que se envíe, si lo hay (método [POST])
Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
Método de [HttpClient] que envía la solicitud y devuelve la respuesta. [GetAsync(url)] es un atajo para una solicitud [GET]
HttpResponseMessage.StatusCode, ReasonPhrase, Version
línea de estado: código (enumeración [HttpStatusCode]), mensaje y versión de HTTP
HttpResponseMessage.IsSuccessStatusCode
true si el código de estado está entre 200 y 299
HttpResponseMessage.EnsureSuccessStatusCode()
lanza una [HttpRequestException] si el código de estado no está entre 200 y 299
HttpResponseMessage.Headers
los encabezados de la respuesta propiamente dicha ([Date], [Server], [Location]…)
HttpResponseMessage.Content
el documento recibido ([HttpContent]): sus propios encabezados ([Content.Headers]: [Content-Type], [Content-Length]…) y los métodos [ReadAsStringAsync], [ReadAsByteArrayAsync], [ReadAsStreamAsync] para leerlo
HttpResponseMessage.RequestMessage
la solicitud a la que corresponde la respuesta: en caso de redirección, es la última solicitud enviada

Usaremos estas clases para implementar el cliente web de la Parte 1 ([internet-08.cs], [internet-09.cs]), que se invocaba con una URL y el método [GET] o [HEAD] . El curso de 2008 hacía lo mismo con las clases [HttpWebRequest] / [HttpWebResponse]. El programa [internet-12.cs] es el siguiente:

using System.Net.Http.Headers;

// cliente web basado en HttpClient: muestra el estado, los encabezados y el documento recibido
// llamada: dotnet run internet-12.cs -- URL GET/HEAD

const string syntax = "Syntax: dotnet run internet-12.cs -- URL GET/HEAD";
if (args.Length != 2)
{
    Console.WriteLine(syntax);
    return;
}
// la URL debe ser una URL http o https absoluta
if (!Uri.TryCreate(args[0], UriKind.Absolute, out Uri? uri) || (uri.Scheme != "http" && uri.Scheme != "https"))
{
    Console.WriteLine($"Incorrect URL [{args[0]}]: give a URL of the form http://machine[:port]/document");
    return;
}
// el método HTTP
string command = args[1].ToUpper();
if (command is not ("GET" or "HEAD"))
{
    Console.WriteLine(syntax);
    return;
}

// el manejador que hace el trabajo de red: como máximo 3 redirecciones seguidas
var handler = new SocketsHttpHandler { MaxAutomaticRedirections = 3 };
// el cliente HTTP: 10 segundos como máximo para obtener una respuesta
using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(10) };
try
{
    // la solicitud: método, URL, encabezados
    using var request = new HttpRequestMessage(new HttpMethod(command), uri);
    request.Headers.UserAgent.ParseAdd("csharp-course-client/1.0");
    // la enviamos y esperamos la respuesta
    using HttpResponseMessage response = await client.SendAsync(request);
    // la línea de estado
    Console.WriteLine($"The server {response.RequestMessage?.RequestUri} answered: "
        + $"HTTP/{response.Version} {(int)response.StatusCode} {response.ReasonPhrase}");
    // los encabezados de la respuesta, y luego los del documento
    Console.WriteLine("--- headers");
    DisplayHeaders(response.Headers);
    DisplayHeaders(response.Content.Headers);
    // un código de estado fuera del rango 200-299 lanza una HttpRequestException
    response.EnsureSuccessStatusCode();
    // el documento
    Console.WriteLine("--- document");
    Console.WriteLine(await response.Content.ReadAsStringAsync());
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"{ex.GetType().Name} [{ex.HttpRequestError}] : {ex.Message}");
}
catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
{
    Console.WriteLine("The server did not answer within the allotted time");
}

// muestra una colección de encabezados: un nombre puede tener varios valores
static void DisplayHeaders(HttpHeaders headers)
{
    foreach ((string name, IEnumerable<string> values) in headers)
    {
        Console.WriteLine($"{name}: {string.Join(", ", values)}");
    }
}

Comentarios:

  • Línea 13: como en [internet-08.cs], se verifica que la URL sea válida. Esta vez se acepta el esquema [https] : [HttpClient] es capaz de realizar la negociación TLS;
  • Línea 27: un [HttpClient] delega el procesamiento de red a un manejador (handler); de forma predeterminada, un objeto [SocketsHttpHandler] creado para él. Nosotros lo creamos para establecer una de sus propiedades: [MaxAutomaticRedirections] limita a 3 el número de redirecciones seguidas (50 de forma predeterminada). El manejador también administra el grupo de conexiones, las cookies ([UseCookies]), la descompresión ([AutomaticDecompression]) y el proxy ([Proxy]);
  • línea 29: la propiedad [Timeout] establece el tiempo máximo para recibir una respuesta (100 segundos de forma predeterminada);
  • líneas 33–34: la solicitud, con el método solicitado y un encabezado [User-Agent] propio de esta solicitud. El curso de 2008 no supo cómo hacer una solicitud [HEAD] con [WebClient]: con [HttpRequestMessage], basta con elegir el método;
  • Línea 36: se envía la solicitud; la respuesta está disponible una vez recibidos sus encabezados y, de forma predeterminada, su documento. [HttpResponseMessage] es [IDisposable]: la declaración [using] libera sus recursos;
  • líneas 38–39: la línea de estado. [response.RequestMessage.RequestUri] es la URL de la última solicitud: en caso de redirección, difiere de la URL solicitada;
  • líneas 42–43: [HttpClient] organiza los encabezados en dos colecciones: los de la respuesta y los que describen el documento;
  • línea 45: si el código de estado no indica éxito, se lanza una [HttpRequestException];
  • línea 48: el documento se lee como una cadena de caracteres. El conjunto de caracteres especificado por el encabezado [Content-Type] ([charset=utf-8]) se utiliza para decodificar los bytes recibidos;
  • línea 50: a partir de .NET 8, la propiedad [HttpRequestError] de la excepción indica la naturaleza del error en forma de enumeración: [ConnectionError], [NameResolutionError], [SecureConnectionError]… Vale [Unknown] para un código de estado de error;
  • línea 54: por razones históricas, un tiempo de espera agotado produce una [TaskCanceledException], cuya excepción interna es una [TimeoutException]; el filtro [when] lo verifica;
  • líneas 60–64: un nombre de encabezado puede tener varios valores; cada elemento de la colección [HttpHeaders] es un par (nombre, valores) que se recorre en el [foreach].

Solicitemos la raíz del sitio:

> dotnet run internet-12.cs -- http://localhost:27210/ GET
The server http://localhost:27210/ answered: HTTP/1.1 200 OK
--- headers
Date: Sat, 03 Oct 2026 10:18:56 GMT
Server: Kestrel
Content-Length: 163
Content-Type: text/html; charset=utf-8
--- document
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the HttpClient test server</h1></body>
</html>

Encontramos la información que obtuvimos al analizar nosotros mismos la respuesta con el cliente TCP: la línea de estado, los encabezados de la respuesta [Date] y [Server], y luego los encabezados del documento [Content-Length] y [Content-Type].

Una URL que se redirige:

1
2
3
4
5
6
7
8
9
> dotnet run internet-12.cs -- http://localhost:27210/old GET
The server http://localhost:27210/hello?name=visitor answered: HTTP/1.1 200 OK
--- headers
Date: Sat, 03 Oct 2026 10:18:58 GMT
Server: Kestrel
Transfer-Encoding: chunked
Content-Type: text/plain; charset=utf-8
--- document
Hello visitor!

La redirección se gestionó automáticamente: la respuesta recibida es la de la URL [/hello?name=visitor] (línea 2). Comparémoslo con la primera parte: el cliente [internet-09.cs] tenía que leer la línea de estado, extraer el código, buscar el encabezado [Location], calcular la nueva URL y volver a empezar, en un bucle limitado a tres redirecciones. Aquí, todo esto lo gestiona el manejador [SocketsHttpHandler]. El documento, enviado en fragmentos (línea 6), fue reconstruido. Para gestionar las redirecciones usted mismo, basta con establecer [AllowAutoRedirect = false] en el manejador: la respuesta 302 se devuelve entonces tal cual.

Un documento inexistente:

1
2
3
4
5
6
7
> dotnet run internet-12.cs -- http://localhost:27210/unknown GET
The server http://localhost:27210/unknown answered: HTTP/1.1 404 Not Found
--- headers
Date: Sat, 03 Oct 2026 10:19:00 GMT
Server: Kestrel
Content-Length: 0
HttpRequestException [Unknown] : Response status code does not indicate success: 404 (Not Found).

El código 404 está incluido en la respuesta, junto con sus encabezados. Fue [EnsureSuccessStatusCode] quien lanzó la excepción. En el curso de 2008, con [HttpWebRequest], se obtenía directamente una [WebException] y había que recuperar la respuesta a partir de la excepción; con [HttpClient], solo los métodos [GetStringAsync], [GetByteArrayAsync], y [GetStreamAsync] lanzan una excepción ante un código de error; [SendAsync] y [GetAsync] devuelven la respuesta, y le corresponde al programa decidir.

La URL [/loop], que se redirige a sí misma:

1
2
3
4
5
6
7
> dotnet run internet-12.cs -- http://localhost:27210/loop HEAD
The server http://localhost:27210/loop answered: HTTP/1.1 302 Found
--- headers
Date: Sat, 03 Oct 2026 10:19:02 GMT
Server: Kestrel
Location: /loop
HttpRequestException [Unknown] : Response status code does not indicate success: 302 (Found).

Después de tres redirecciones, el manejador se rinde y devuelve la última respuesta recibida, una respuesta 302. Como no está en el rango 200–299, [EnsureSuccessStatusCode] lanza una excepción.

Un error del servidor:

1
2
3
4
5
6
> dotnet run internet-12.cs -- http://localhost:27210/error HEAD
The server http://localhost:27210/error answered: HTTP/1.1 500 Internal Server Error
--- headers
Date: Sat, 03 Oct 2026 10:19:04 GMT
Server: Kestrel
HttpRequestException [Unknown] : Response status code does not indicate success: 500 (Internal Server Error).

Un puerto en el que no escucha ningún servidor:

> dotnet run internet-12.cs -- http://localhost:27299/ GET
HttpRequestException [ConnectionError] : Connection refused (localhost:27299)

La propiedad [HttpRequestError] es igual a [ConnectionError]: no se pudo alcanzar el servidor. Por último, una URL [https] enviada a nuestro servidor, que solo habla HTTP en texto sin cifrar:

> dotnet run internet-12.cs -- https://localhost:27210/ GET
HttpRequestException [SecureConnectionError] : The SSL connection could not be established, see inner exception.

La negociación TLS falló ([SecureConnectionError]). En una máquina conectada a Internet, una solicitud a una URL como [https://learn.microsoft.com/] normalmente se atendería mediante HTTP/2 o HTTP/3, según las capacidades del servidor.

Una última observación sobre los proxies. El curso de 2008 dedicaba un párrafo a los proxies HTTP: las máquinas por las que deben pasar las estaciones de trabajo de una red corporativa para acceder a la Web. De forma predeterminada, [HttpClient] usa el proxy configurado en el sistema (la configuración de Windows, las variables de entorno [HTTP_PROXY] y [HTTPS_PROXY] en Linux y macOS). Puede especificar otro mediante la propiedad [Proxy] del manejador, [new SocketsHttpHandler { Proxy = new WebProxy("proxy.example.org:3128") }], o no usar ninguno con [UseProxy = false].

12.7.2.4. Envío de datos al servidor: GET y POST

Un cliente puede enviar información al servidor de dos maneras:

  • con el método [GET], la información forma parte de la URL: [/document?param1=value1&param2=value2];
  • con el método [POST], la información constituye el documento adjunto a la solicitud, a continuación de la línea en blanco que termina los encabezados. El encabezado [Content-Type] especifica su formato. Para un formulario HTML, el documento tiene el mismo formato que la sección de parámetros de una URL: [param1=value1&param2=value2], con el tipo [application/x-www-form-urlencoded].

En ambos casos, los valores deben codificarse: ciertos caracteres (espacios, [&], [=], [?], letras acentuadas, etc.) no pueden aparecer tal cual en una URL ni en un formulario. El curso de 2008 usaba para ello el método [HttpUtility.UrlEncode]; hoy usamos [Uri.EscapeDataString] para un valor que se colocará en una URL, y la propia clase [FormUrlEncodedContent] codifica un formulario.

Los métodos de [HttpClient] para enviar datos son [PostAsync], [PutAsync] y [PatchAsync]. Reciben una URL y el documento que se enviará, un objeto derivado de [HttpContent]:

Clase
Documento enviado
FormUrlEncodedContent
un formulario, construido a partir de una colección de pares (nombre, valor)
StringContent
texto, con su codificación y su tipo ([text/plain], [application/json]…)
ByteArrayContent, StreamContent
bytes arbitrarios, un flujo (un archivo, por ejemplo)
MultipartFormDataContent
un formulario que contiene archivos ([multipart/form-data])
JsonContent
un objeto transformado en JSON (espacio de nombres [System.Net.Http.Json])

El programa [internet-13.cs] es el siguiente:

using System.Text;

// enviar datos al servidor: parámetros de URL (GET), formulario y texto (POST)
// el servidor de pruebas [internet-10.cs] debe estar en ejecución en el puerto 27210

using var client = new HttpClient { BaseAddress = new Uri("http://localhost:27210/") };

// 1 - GET: los parámetros forman parte de la URL; deben codificarse en ella
string name = "Jean & Marie";
string url = $"hello?name={Uri.EscapeDataString(name)}";
Console.WriteLine($"--- GET {url}");
Console.WriteLine(await client.GetStringAsync(url));

// 2 - POST de un formulario: los parámetros forman el documento enviado al servidor
var form = new FormUrlEncodedContent(
[
    new("name", "Jean & Marie"),
    new("age", "42"),
    new("city", "Angers"),
]);
// el documento tal como se enviará
Console.WriteLine($"--- POST form, document sent: {await form.ReadAsStringAsync()}");
using (HttpResponseMessage response = await client.PostAsync("form", form))
{
    response.EnsureSuccessStatusCode();
    Console.WriteLine(await response.Content.ReadAsStringAsync());
}

// 3 - POST de un texto cualquiera, con su tipo
var text = new StringContent("summer and winter", Encoding.UTF8, "text/plain");
Console.WriteLine("--- POST text");
using (HttpResponseMessage response = await client.PostAsync("text", text))
{
    response.EnsureSuccessStatusCode();
    Console.WriteLine(await response.Content.ReadAsStringAsync());
}

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run internet-13.cs
--- GET hello?name=Jean%20%26%20Marie
Hello Jean & Marie!
--- POST form, document sent: name=Jean+%26+Marie&age=42&city=Angers
Content-Type received: application/x-www-form-urlencoded
Fields received: name=[Jean & Marie], age=[42], city=[Angers]
--- POST text
Content-Type received: text/plain; charset=utf-8
Text received in upper case: SUMMER AND WINTER

Comentarios:

  • Líneas 9–10: el valor [Jean & Marie] se coloca dentro de la URL. Sin codificación, el carácter [&] se interpretaría como el separador entre dos parámetros, y el servidor recibiría el parámetro [name] con el valor [Jean]. En la línea 2 de los resultados vemos que el espacio se convirtió en [%20] y el carácter [&] se convirtió en [%26]: es el código hexadecimal del carácter, precedido de [%];
  • Líneas 15–19: el formulario se construye a partir de una colección de pares, [KeyValuePair<string, string>]; como se conoce el tipo de cada elemento, basta con [new(...)] ;
  • línea 22: para comprobarlo, leemos el documento que se enviará: en la línea 4 de los resultados encontramos el formato [name=value&name=value]. En un formulario, un espacio se codifica como [+];
  • línea 23: el formulario se envía con el método [POST] a la URL [/form]. El servidor indica (líneas 5–6) que recibió un documento de tipo [application/x-www-form-urlencoded] y que extrajo y decodificó de él los tres campos;
  • línea 30: texto, codificado en UTF-8, de tipo [text/plain]. El servidor lo devuelve en mayúsculas (línea 9).

Observe los bloques [using (...) { ... }]: aquí no podíamos usar una declaración [using], porque hay dos variables [response] en el mismo bloque de código. La diferencia entre [GET] y [POST], señalada en el curso de 2008, sigue siendo válida: un navegador muestra en su barra de direcciones los parámetros de una solicitud [GET], no los de una solicitud [POST]; además, una solicitud [GET] solo debe usarse para recuperar información, mientras que una solicitud [POST] sirve para enviar información o modificar el estado del servidor.

12.7.2.5. Intercambio de objetos en formato JSON

Actualmente, las aplicaciones intercambian la mayor parte de sus datos en formato JSON, descrito en el Capítulo 5. El espacio de nombres [System.Net.Http.Json] agrega métodos de extensión a [HttpClient] y [HttpContent] que, en una sola instrucción, realizan la solicitud HTTP y la conversión entre objetos y JSON mediante [System.Text.Json]:

Método
Función
Task<T?> GetFromJsonAsync<T>(string url)
recupera la URL mediante [GET] y convierte el documento JSON recibido en un objeto de tipo [T]
Task<HttpResponseMessage> PostAsJsonAsync<T>(string url, T object)
envía el objeto, convertido a JSON, mediante [POST] (tipo [application/json]) y devuelve la respuesta. [PutAsJsonAsync] hace lo mismo con el [PUT] método
Task<T?> ReadFromJsonAsync<T>()
Método de [HttpContent]: convierte el documento JSON de una respuesta en un objeto de tipo [T]

El programa [internet-14.cs] es el siguiente:

#:property PublishAot=false
using System.Net.Http.Json;

// intercambiar objetos en formato JSON con un servidor web
// el servidor de pruebas [internet-10.cs] debe estar en ejecución en el puerto 27210

using var client = new HttpClient { BaseAddress = new Uri("http://localhost:27210/") };

// 1 - la lista de personas: el documento JSON se convierte directamente en objetos
List<Person>? persons = await client.GetFromJsonAsync<List<Person>>("api/persons");
Console.WriteLine("--- list of persons");
foreach (Person person in persons ?? [])
{
    Console.WriteLine(person);
}

// 2 - una persona
Person? durand = await client.GetFromJsonAsync<Person>("api/persons/2");
Console.WriteLine($"--- person no. 2: {durand}");

// 3 - adición de una persona: el objeto se envía en formato JSON
var martin = new Person(0, "Martin", 25);
using (HttpResponseMessage response = await client.PostAsJsonAsync("api/persons", martin))
{
    Console.WriteLine($"--- addition of {martin}");
    Console.WriteLine($"Status: {(int)response.StatusCode} {response.ReasonPhrase}, Location: {response.Headers.Location}");
    // el documento JSON recibido, primero en bruto y luego como objeto
    Console.WriteLine($"JSON received: {await response.Content.ReadAsStringAsync()}");
    Person? created = await response.Content.ReadFromJsonAsync<Person>();
    Console.WriteLine($"Person created: {created}");
}

// 4 - una persona que no existe
try
{
    await client.GetFromJsonAsync<Person>("api/persons/99");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"--- person no. 99: {ex.GetType().Name} : {ex.Message}");
}

// una persona: el mismo tipo que en el lado del servidor
record Person(int Id, string Name, int Age);

Resultados:

> dotnet run internet-14.cs
--- list of persons
Person { Id = 1, Name = Dupont, Age = 42 }
Person { Id = 2, Name = Durand, Age = 35 }
--- person no. 2: Person { Id = 2, Name = Durand, Age = 35 }
--- addition of Person { Id = 0, Name = Martin, Age = 25 }
Status: 201 Created, Location: /api/persons/3
JSON received: {"id":3,"name":"Martin","age":25}
Person created: Person { Id = 3, Name = Martin, Age = 25 }
--- person no. 99: HttpRequestException : Response status code does not indicate success: 404 (Not Found).

Comentarios:

  • Línea 1: al igual que con el servidor, volvemos a activar la serialización JSON mediante reflexión. La otra solución, tratada en el Capítulo 6 para la capa [dao] de la Versión 5, es un contexto de serialización generado en tiempo de compilación ([JsonSerializerContext]): cada uno de los métodos anteriores tiene una sobrecarga que lo acepta;
  • Línea 10: la lista de personas. El documento JSON [[{"id":1,"name":"Dupont","age":42},...]] enviado por el servidor se convierte directamente en una lista de objetos [Person]. El resultado es de tipo [List<Person>?]: el documento JSON podría ser [null];
  • línea 12: si es así, se recorre una lista vacía;
  • línea 18: una sola persona;
  • línea 23: el objeto [martin] se convierte a JSON y se envía al servidor. El servidor responde con el código de estado 201 (Created) y el encabezado [Location], que proporciona la URL del nuevo recurso (línea 7 de los resultados);
  • línea 28: el documento JSON recibido: los nombres de las propiedades están en formato “camelCase” ([id], [name], [age]), siguiendo las convenciones de la web. Los métodos de [System.Net.Http.Json] usan las opciones [JsonSerializerDefaults.Web], que realizan la conversión con las propiedades de C# [Id], [Name] y [Age];
  • línea 29: el mismo documento, convertido en un objeto. Observe que el documento pudo haberse leído dos veces: [HttpClient] lo mantuvo en memoria, ya que la solicitud se hizo sin la opción [HttpCompletionOption.ResponseHeadersRead], de la que hablaremos más adelante;
  • líneas 34–40: al igual que [GetStringAsync], [GetFromJsonAsync] lanza una [HttpRequestException] si el código de estado indica un error.

Volveremos sobre estos métodos en el próximo capítulo, donde el servidor de cálculo del impuesto se convertirá en un servicio web JSON.

12.7.2.6. Tiempo de espera, cancelación y reutilización del cliente

El programa [internet-15.cs] ilustra tres puntos importantes para el uso de [HttpClient] en una aplicación real:

using System.Diagnostics;

// tiempo de espera, cancelación y reutilización de un HttpClient
// el servidor de pruebas [internet-10.cs] debe estar en ejecución en el puerto 27210

// 1 - una sola instancia de HttpClient para toda la aplicación
//     tiempo de espera de 2 segundos para cada solicitud
var client = new HttpClient
{
    BaseAddress = new Uri("http://localhost:27210/"),
    Timeout = TimeSpan.FromSeconds(2),
};

// 2 - solicitudes sucesivas: se reutiliza la misma conexión TCP
Console.WriteLine("--- three successive requests");
for (int i = 1; i <= 3; i++)
{
    Console.WriteLine(await client.GetStringAsync($"hello?name=trial{i}"));
}

// 3 - una respuesta obtenida dentro del tiempo de espera, y luego una respuesta demasiado lenta
foreach (int seconds in (int[])[1, 3])
{
    Console.WriteLine($"--- response in {seconds} s expected");
    try
    {
        Console.WriteLine(await client.GetStringAsync($"slow?seconds={seconds}"));
    }
    catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
    {
        Console.WriteLine($"{ex.GetType().Name} : {ex.Message}");
    }
}

// 4 - una solicitud cancelada por el programa después de medio segundo
Console.WriteLine("--- cancellation after 0.5 s");
using (var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(0.5)))
{
    try
    {
        Console.WriteLine(await client.GetStringAsync("slow?seconds=1", cancellation.Token));
    }
    catch (TaskCanceledException ex) when (cancellation.IsCancellationRequested)
    {
        Console.WriteLine($"Request cancelled ({ex.GetType().Name})");
    }
}

// 5 - cuatro solicitudes simultáneas con el mismo cliente
Console.WriteLine("--- four simultaneous requests of one second each");
var stopwatch = Stopwatch.StartNew();
string[] responses = await Task.WhenAll(
    Enumerable.Range(1, 4).Select(_ => client.GetStringAsync("slow?seconds=1")));
foreach (string response in responses)
{
    Console.WriteLine(response);
}
Console.WriteLine($"Total duration: {stopwatch.Elapsed.TotalSeconds:F1} s");

Resultados:

> dotnet run internet-15.cs
--- three successive requests
Hello trial1!
Hello trial2!
Hello trial3!
--- response in 1 s expected
Response obtained after 1 s
--- response in 3 s expected
TaskCanceledException : The request was canceled due to the configured HttpClient.Timeout of 2 seconds elapsing.
--- cancellation after 0.5 s
Request cancelled (TaskCanceledException)
--- four simultaneous requests of one second each
Response obtained after 1 s
Response obtained after 1 s
Response obtained after 1 s
Response obtained after 1 s
Total duration: 1.0 s

Comentarios:

  • Línea 8: todo el programa utiliza una única instancia de [HttpClient] . Esta es la regla: un objeto [HttpClient] administra un grupo de conexiones y las reutiliza de una consulta a la siguiente; está diseñado para vivir mucho tiempo y puede ser usado por varias tareas simultáneamente. Crear un [HttpClient] para cada solicitud, dentro de un [using], es un error clásico: cada instancia abre sus propias conexiones, que el sistema mantiene luego en reserva durante cierto tiempo después de cerradas (estado TIME_WAIT de TCP); un programa que realiza muchas consultas termina por agotar los puertos disponibles. Incluimos [using] en los programas anteriores porque realizaban solo unas pocas solicitudes antes de terminar;
  • línea 11: cada solicitud debe recibir una respuesta en 2 segundos como máximo;
  • líneas 16–18: tres solicitudes sucesivas. Veremos en el registro del servidor que utilizaron la misma conexión (TCP);
  • líneas 22–29: una respuesta que llega en 1 segundo, seguida de una respuesta que tardaría 3 segundos: transcurridos 2 segundos, la solicitud se abandona y se lanza una [TaskCanceledException] (línea 9 de los resultados). La expresión [(int[])[1, 3]] asigna un tipo a la expresión de colección, que por sí sola no lo tiene;
  • líneas 37–45: una cancelación iniciada por el programa. Todos los métodos de [HttpClient] aceptan un token de cancelación, al igual que los métodos asíncronos tratados en el Capítulo 9. Aquí, el token se cancela automáticamente después de medio segundo (constructor [CancellationTokenSource(TimeSpan)]); en una aplicación interactiva, lo cancelaría un botón [Cancel] o Ctrl-C. La excepción es de nuevo una [TaskCanceledException]; el filtro [when (cancellation.IsCancellationRequested)] es el que distingue entre una cancelación y un tiempo de espera agotado;
  • Líneas 51–58: cuatro solicitudes lanzadas simultáneamente con el mismo cliente y luego procesadas en conjunto por [Task.WhenAll] (Capítulo 9). Cada solicitud tardó un segundo en procesarse; el total tardó un segundo (línea 17): las solicitudes se procesaron en paralelo.

El registro del servidor [internet-10.cs] muestra todas las solicitudes recibidas desde el comienzo de esta sección:

> dotnet run internet-10.cs
Web server started on http://localhost:27210
GET /hello?name=Serge HTTP/1.1 (client port 45988) -> 200
GET /headers HTTP/1.1 (client port 45988) -> 200
GET /headers HTTP/1.1 (client port 45988) -> 200
GET / HTTP/1.1 (client port 45988) -> 200
GET /unknown HTTP/1.1 (client port 45988) -> 404
GET / HTTP/1.1 (client port 45996) -> 200
GET /old HTTP/1.1 (client port 46006) -> 302
GET /hello?name=visitor HTTP/1.1 (client port 46006) -> 200
GET /unknown HTTP/1.1 (client port 46018) -> 404
HEAD /loop HTTP/1.1 (client port 56222) -> 302
HEAD /loop HTTP/1.1 (client port 56222) -> 302
HEAD /loop HTTP/1.1 (client port 56222) -> 302
HEAD /loop HTTP/1.1 (client port 56222) -> 302
HEAD /error HTTP/1.1 (client port 56230) -> 500
GET /hello?name=Jean%20%26%20Marie HTTP/1.1 (client port 56262) -> 200
POST /form HTTP/1.1 (client port 56262) -> 200
POST /text HTTP/1.1 (client port 56262) -> 200
GET /api/persons HTTP/1.1 (client port 39124) -> 200
GET /api/persons/2 HTTP/1.1 (client port 39124) -> 200
POST /api/persons HTTP/1.1 (client port 39124) -> 201
GET /api/persons/99 HTTP/1.1 (client port 39124) -> 404
GET /hello?name=trial1 HTTP/1.1 (client port 39138) -> 200
GET /hello?name=trial2 HTTP/1.1 (client port 39138) -> 200
GET /hello?name=trial3 HTTP/1.1 (client port 39138) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 39138) -> 200
GET /slow?seconds=3 HTTP/1.1 (client port 39138) -> abandoned by the client
GET /slow?seconds=1 HTTP/1.1 (client port 39140) -> abandoned by the client
GET /slow?seconds=1 HTTP/1.1 (client port 39156) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 39168) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 39172) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 39170) -> 200
  • líneas 3–7: las cinco solicitudes de [internet-11.cs] llegaron por la misma conexión (mismo puerto de cliente): el cliente la mantuvo abierta entre solicitudes;
  • líneas 9–10: la solicitud redirigida de [internet-12.cs] y la solicitud a la nueva dirección, realizada automáticamente por la misma conexión;
  • líneas 12–15: la solicitud inicial y las tres redirecciones que la siguieron antes de que se cerrara la conexión;
  • líneas 24–28: las solicitudes sucesivas de [internet-15.cs] utilizaron todas la misma conexión. La solicitud que tardó demasiado fue abandonada por el cliente (línea 28): [HttpClient] cerró la conexión, y el servidor vio revocado su token [RequestAborted];
  • línea 29: la solicitud cancelada por el programa tuvo que abrir una nueva conexión, ya que la anterior se había cerrado;
  • las cuatro últimas líneas: las cuatro solicitudes simultáneas utilizaron cuatro conexiones distintas, abiertas específicamente para ello. En HTTP/1.1, una conexión transporta una sola solicitud a la vez; HTTP/2 permitiría enviarlas todas por una única conexión.

Un programa que permanece activo durante mucho tiempo (un servidor, un servicio del sistema) debe tener en cuenta un último punto: un único [HttpClient] conserva sus conexiones indefinidamente y, por lo tanto, no detecta los cambios en las direcciones IP de los servidores que consulta, que el DNS revelaría. Para remediarlo, se establece una duración máxima de las conexiones mediante la propiedad [PooledConnectionLifetime] del manejador [SocketsHttpHandler] (por ejemplo, dos minutos). En las aplicaciones basadas en el Generic Host de .NET ([Microsoft.Extensions.Hosting]) y en ASP.NET Core, los objetos [HttpClient] se obtienen más bien a través de la interfaz [IHttpClientFactory]: declarada con [services.AddHttpClient()] (paquete [Microsoft.Extensions.Http]), esta fábrica proporciona clientes configurados (dirección base, encabezados, tiempo de espera) y administra por sí misma sus manejadores y sus tiempos de vida. El lector la encontrará en la documentación de ASP.NET Core.

12.7.3. Aplicación: un cliente proxy para un servicio web de traducción

Mostraremos ahora cómo [HttpClient] permite utilizar recursos web, incluso cuando esos recursos no estaban pensados para ser usados por un programa.

12.7.3.1. La aplicación

El curso de 2008 utilizaba el sitio de traducción [trans.voila.fr]. Los usuarios escribían un texto, seleccionaban una dirección de traducción (“francés a inglés”, etc.) en una lista desplegable, hacían clic en un botón y recibían una página HTML con la traducción. El curso creaba una clase [TranslationService] que realizaba la misma tarea de forma programática: construía la URL de la solicitud, la enviaba al sitio y extraía la traducción de la página HTML recibida mediante una expresión regular. Una interfaz gráfica de Windows Forms se apoyaba en esta clase; se habla entonces de un cliente “proxy”: la clase [TranslationService] actúa como sustituto del sitio web y lo oculta al usuario.

Ese sitio web ya no existe, y nuestra máquina de pruebas no tiene acceso a Internet. Conservamos el concepto reemplazando el sitio web por un pequeño sitio local que lo imita: tiene el mismo formulario (un cuadro de texto, una lista desplegable de direcciones de traducción escritas como en el sitio de 2008) y muestra la traducción en el mismo lugar de su página. Sus “traducciones” se hacen palabra por palabra con pequeños diccionarios: lo que nos interesa es la técnica del cliente, no la calidad de la traducción. La interfaz gráfica se reemplaza por un programa de prueba de consola, como el del curso de 2008. La arquitectura es la siguiente:

Image

12.7.3.2. El sitio de traducción

El programa [internet-16.cs] es el siguiente:

#:sdk Microsoft.NET.Sdk.Web
using System.Net;
using System.Text;
using System.Text.RegularExpressions;

// un pequeño sitio web de "traducción" palabra por palabra, que imita el sitio consultado por el curso de 2008
// llamada: dotnet run internet-16.cs [-- port]
int port = args.Length == 1 && int.TryParse(args[0], out int p) ? p : 27220;

// los sentidos de traducción: código -> (etiqueta, diccionario)
var translationDirections = new Dictionary<string, (string Label, Dictionary<string, string> Words)>
{
    ["fe"] = ("French &rarr; English", new()
    {
        ["ce"] = "this", ["chien"] = "dog", ["est"] = "is", ["perdu"] = "lost", ["malade"] = "sick",
        ["l'"] = "the ", ["été"] = "summer", ["sera"] = "will be", ["chaud"] = "hot",
    }),
    ["ef"] = ("English &rarr; French", new()
    {
        ["my"] = "mon", ["tailor"] = "tailleur", ["is"] = "est", ["rich"] = "riche",
        ["this"] = "ce", ["dog"] = "chien", ["lost"] = "perdu",
    }),
    ["fs"] = ("French &rarr; Spanish", new()
    {
        ["ce"] = "este", ["chien"] = "perro", ["est"] = "está", ["perdu"] = "perdido",
        ["l'"] = "el ", ["été"] = "verano", ["sera"] = "será", ["chaud"] = "caliente",
    }),
};

var builder = WebApplication.CreateBuilder(args);
builder.Logging.SetMinimumLevel(LogLevel.Warning);
var app = builder.Build();

// seguimiento en consola de las solicitudes
app.Use(async (context, next) =>
{
    await next(context);
    var request = context.Request;
    Console.WriteLine($"{request.Method} {request.Path}{request.QueryString} -> {context.Response.StatusCode}");
});

// la página de traducción: el formulario, seguido de la traducción si se proporcionó un texto
app.MapGet("/translation", (string? direction, string? text) =>
{
    var page = new StringBuilder();
    page.Append("""
        <!DOCTYPE html>
        <html lang="en">
        <head><meta charset="utf-8"><title>Translator of the C# course</title></head>
        <body>
        <h1>Translation of texts</h1>
        <form action="/translation" method="get">
        <textarea name="text" rows="4" cols="60"></textarea>
        <select name="direction">

        """);
    // la lista de sentidos de traducción, escrita como en 2008: etiquetas <option> sin cerrar
    foreach ((string code, (string label, _)) in translationDirections)
    {
        page.Append($"    <option value='{code}'>{label}\n");
    }
    page.Append("""
        </select>
        <input type="submit" value="Translate">
        </form>

        """);
    // la traducción, si hay un texto por traducir
    if (!string.IsNullOrWhiteSpace(text))
    {
        if (direction is not null && translationDirections.TryGetValue(direction, out var translator))
        {
            // traducción palabra por palabra; una palabra desconocida se deja tal cual
            string translation = Regex.Replace(text.Trim().ToLower(), @"\w+'?",
                word => translator.Words.GetValueOrDefault(word.Value, word.Value));
            page.Append($"<strong>Translated text: </strong><div class=\"txtTrans\">{WebUtility.HtmlEncode(translation)}</div>\n");
        }
        else
        {
            page.Append("<p>Unknown translation direction</p>\n");
        }
    }
    page.Append("</body>\n</html>\n");
    return Results.Content(page.ToString(), "text/html; charset=utf-8");
});

Console.WriteLine($"Translation service started on http://localhost:{port}/translation");
app.Run($"http://127.0.0.1:{port}");

Comentarios:

  • Líneas 11–26: las tres direcciones de traducción propuestas, junto con sus códigos ([fe] para francés → inglés, como en el sitio de 2008), sus etiquetas y sus diccionarios. Las etiquetas contienen entidades HTML ([&rarr;] para [→]), igual que las del sitio original;
  • línea 43: la única página del sitio, [/translation], puede recibir dos parámetros: la dirección de traducción [direction] y el texto [text];
  • líneas 58–60: la lista desplegable. Como en el sitio de 2008, las etiquetas [<option>] no están cerradas: el HTML de los sitios reales no siempre es muy limpio, y nuestro cliente tendrá que sortear esto;
  • líneas 74–75: la traducción palabra por palabra. La expresión regular [\w+'?] reconoce una palabra, seguida posiblemente de un apóstrofo ([l'], [d']); cada palabra se reemplaza por su traducción, o se deja tal cual si es desconocida;
  • línea 76: la traducción se coloca dentro de una etiqueta [<div class="txtTrans">], como en el sitio de 2008. Se codifica con [WebUtility.HtmlEncode]: los caracteres que tienen un significado en HTML ([<], [&]…) y, con este método, las letras acentuadas se reemplazan por entidades;
  • Línea 80: una dirección de traducción desconocida produce una página sin traducción.

Esta es la página generada con [curl] para la traducción de [l'été sera chaud] al español; observe la codificación del texto en la URL:

> curl "http://localhost:27220/translation?direction=fs&text=l%27%C3%A9t%C3%A9%20sera%20chaud"
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Translator of the C# course</title></head>
<body>
<h1>Translation of texts</h1>
<form action="/translation" method="get">
<textarea name="text" rows="4" cols="60"></textarea>
<select name="direction">
    <option value='fe'>French &rarr; English
    <option value='ef'>English &rarr; French
    <option value='fs'>French &rarr; Spanish
</select>
<input type="submit" value="Translate">
</form>
<strong>Translated text: </strong><div class="txtTrans">el verano ser&#225; caliente</div>
</body>
</html>

Para escribir el cliente necesitamos, igual que en 2008:

  • saber qué espera el sitio: una solicitud [GET /translation?direction=code&text=encoded text]. En un sitio web real, esto se averigua mirando la URL que muestra el navegador después de una traducción, o el atributo [action] del formulario;
  • saber dónde, dentro de las páginas recibidas, se encuentra la información que nos interesa: las direcciones de traducción están en las etiquetas [<option value='code'>label] de la lista desplegable (línea 10 de la página anterior), y la traducción está en la etiqueta [<div class="txtTrans">] (línea 16). Esto se averigua viendo el código fuente de la página en el navegador.

Dos expresiones regulares (Capítulo 5) permiten extraer esta información:

  • [<option[^>]*value='(\w+)'>([^<\r\n]+)]: una etiqueta [<option], seguida de caracteres distintos de [>], [value='], el código (primer grupo), [>], y luego la etiqueta, es decir, los caracteres que siguen hasta el siguiente [<] o el fin de la línea (segundo grupo);
  • [<div class="txtTrans">(.*?)</div>]: la traducción es el texto (primer grupo) entre la etiqueta de apertura y la primera etiqueta [</div>] que la sigue. El cuantificador [*?] es “perezoso”: toma la menor cantidad posible de caracteres.

12.7.3.3. El cliente TranslationService

El curso de 2008 dividía el cliente en dos proyectos: una biblioteca para la clase [TranslationService] y su interfaz, y una aplicación de Windows Forms para la interfaz gráfica de usuario, configurada mediante Spring.NET. Para ser breves, reunimos la interfaz [ITranslationService], su implementación [TranslationService], la excepción [TranslationException], y el programa de prueba en un único archivo de aplicación. El programa [internet-17.cs] es el siguiente:

using System.Net;
using System.Text.RegularExpressions;

// cliente "proxy" de un servicio web de traducción: la clase TranslationService
// oculta al programa el diálogo HTTP y el análisis de las páginas HTML del sitio de traducción
// llamada: dotnet run internet-17.cs [-- siteUrl]   (de forma predeterminada http://localhost:27220/)

string siteUrl = args.Length == 1 ? args[0] : "http://localhost:27220/";
using var client = new HttpClient { BaseAddress = new Uri(siteUrl), Timeout = TimeSpan.FromSeconds(10) };
try
{
    // creación del servicio de traducción: consulta al sitio para conocer los idiomas traducidos
    ITranslationService service = await TranslationService.CreateAsync(client);
    Console.WriteLine("Translation directions offered by the site:");
    foreach ((string code, string label) in service.TranslatedLanguages)
    {
        Console.WriteLine($"  {code} : {label}");
    }
    // algunas traducciones
    (string Text, string Direction)[] trials =
    [
        ("ce chien est perdu", "fe"),
        ("l'été sera chaud", "fs"),
        ("my tailor is rich", "ef"),
        ("xx", "ef"),
        ("", "fe"),
        ("bonjour", "fx"),
    ];
    foreach ((string text, string direction) in trials)
    {
        try
        {
            string translation = await service.TranslateAsync(text, direction);
            Console.WriteLine($"Translation [{service.TranslatedLanguages[direction]}] of [{text}]: [{translation}]");
        }
        catch (TranslationException e)
        {
            Console.WriteLine($"The following error with code {e.Code} occurred: {e.Message}");
        }
    }
}
catch (TranslationException e)
{
    Console.WriteLine($"The following error with code {e.Code} occurred: {e.Message}");
    if (e.InnerException is Exception cause)
    {
        Console.WriteLine($"Cause: {cause.GetType().Name} : {cause.Message}");
    }
}

// --------------------------------------------------------------------
// la interfaz presentada al programa
interface ITranslationService
{
    // los sentidos de traducción: código -> etiqueta, por ejemplo fe -> French → English
    IReadOnlyDictionary<string, string> TranslatedLanguages { get; }
    // traducción de un texto en el sentido dado por su código
    Task<string> TranslateAsync(string text, string direction);
}

// la excepción específica del servicio de traducción
class TranslationException : Exception
{
    public int Code { get; init; }
    public TranslationException(string message) : base(message) { }
    public TranslationException(string message, Exception inner) : base(message, inner) { }
}

// la implementación: un cliente HTTP del sitio de traducción
partial class TranslationService : ITranslationService
{
    // el cliente HTTP, proporcionado por el programa
    private readonly HttpClient client;
    public IReadOnlyDictionary<string, string> TranslatedLanguages { get; }

    // constructor privado: pasamos por el método de fábrica CreateAsync
    private TranslationService(HttpClient client, Dictionary<string, string> languages)
    {
        this.client = client;
        TranslatedLanguages = languages;
    }

    // las opciones <option value='fe'>French &rarr; English del formulario
    [GeneratedRegex(@"<option[^>]*value='(\w+)'>([^<\r\n]+)")]
    private static partial Regex OptionRegex();

    // la traducción: <div class="txtTrans">...</div>
    [GeneratedRegex("""<div class="txtTrans">(.*?)</div>""")]
    private static partial Regex TranslationRegex();

    // creación del servicio: los sentidos de traducción se leen del formulario del sitio
    public static async Task<TranslationService> CreateAsync(HttpClient client)
    {
        string page;
        try
        {
            page = await client.GetStringAsync("translation");
        }
        catch (Exception e) when (e is HttpRequestException or TaskCanceledException)
        {
            throw new TranslationException("The translation site is unreachable", e) { Code = 11 };
        }
        var languages = new Dictionary<string, string>();
        foreach (Match option in OptionRegex().Matches(page))
        {
            // las entidades HTML (&rarr;...) se decodifican
            languages[option.Groups[1].Value] = WebUtility.HtmlDecode(option.Groups[2].Value.Trim());
        }
        if (languages.Count == 0)
        {
            throw new TranslationException("The site gives no translation direction") { Code = 13 };
        }
        return new TranslationService(client, languages);
    }

    // traducción
    public async Task<string> TranslateAsync(string text, string direction)
    {
        // ¿es posible la traducción solicitada?
        if (!TranslatedLanguages.ContainsKey(direction))
        {
            throw new TranslationException($"The translation direction [{direction}] is not recognized") { Code = 10 };
        }
        // la URL por solicitar: el texto debe codificarse
        string url = $"translation?direction={direction}&text={Uri.EscapeDataString(text)}";
        try
        {
            // solo esperamos los encabezados de la respuesta: el documento se leerá progresivamente
            using HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
            response.EnsureSuccessStatusCode();
            using var reader = new StreamReader(await response.Content.ReadAsStreamAsync());
            // buscamos la línea de traducción línea por línea, y nos detenemos apenas la encontramos
            while (await reader.ReadLineAsync() is string line)
            {
                Match result = TranslationRegex().Match(line);
                if (result.Success)
                {
                    return WebUtility.HtmlDecode(result.Groups[1].Value.Trim());
                }
            }
        }
        catch (Exception e) when (e is HttpRequestException or TaskCanceledException or IOException)
        {
            throw new TranslationException("Error encountered during the translation", e) { Code = 11 };
        }
        // la página no contenía ninguna traducción
        throw new TranslationException("The server did not send back a translation") { Code = 12 };
    }
}

Comencemos con la interfaz y la excepción:

  • líneas 53–58: la interfaz que se presenta al programa. La propiedad [TranslatedLanguages] es el diccionario de direcciones de traducción aceptadas por el sitio, formado por entradas de la forma [fe] → [French → English]; el método [TranslateAsync] traduce el texto [text] en la dirección con código [direction]. En 2008, el método era síncrono; ahora es asíncrono, como los métodos de [HttpClient] que utiliza;
  • líneas 62–66: la excepción específica del servicio, con un código de error, modelada a partir de [TaxException] (Capítulo 6).

La clase [TranslationService]:

  • línea 70: la clase es parcial ([partial]) porque el código de sus expresiones regulares se genera en tiempo de compilación (atributo [GeneratedRegex], Capítulo 5);
  • línea 73: el servicio no crea su propio [HttpClient]; lo recibe del programa, que determina su configuración (dirección base, tiempo de espera) y su tiempo de vida;
  • línea 77: el constructor es privado. El servicio solo puede crearse después de consultar el sitio, lo cual es una operación asíncrona; sin embargo, un constructor no puede ser asíncrono. Por eso se usa un método de construcción estático, [CreateAsync];
  • líneas 84–89: las dos expresiones regulares presentadas anteriormente. La primera es un literal de cadena textual [@"..."] (sin secuencias de escape), la segunda un literal de cadena sin formato (raw) [""" ... """] (C# 11), que permite escribir las comillas de [class="txtTrans"] sin duplicarlas;
  • líneas 92–113: creación del servicio. El curso de 2008 almacenaba la lista de claves de traducción en el archivo de configuración de Spring. Nosotros la leemos del propio sitio web, lo que garantiza que esté actualizada:
    • línea 97: solicitamos la página del formulario, sin ningún parámetro;
    • línea 99: un error de comunicación se encapsula en una [TranslationException] con el código 11;
    • líneas 104–107: cada etiqueta [<option>] encontrada por la expresión regular proporciona un código (grupo 1) y una etiqueta (grupo 2). [WebUtility.HtmlDecode] reemplaza las entidades HTML por los caracteres que representan: [French &rarr; English] se convierte en [French → English];
  • líneas 117–147: la traducción:
    • líneas 120–122: se verifica que exista la dirección de traducción solicitada. El código de 2008 contenía aquí un error: [String.Format] se llamaba sin el valor que debía insertarse en el mensaje; la interpolación de cadenas hace imposible este tipo de error;
    • Línea 125: la URL de la solicitud, en la que se codifica el texto;
    • Línea 129: [GetAsync] devuelve la respuesta en cuanto llegan sus encabezados, sin esperar el documento. El curso de 2008 prefería [HttpWebRequest] a [WebClient] para poder leer la página línea por línea y detenerse en cuanto se encontrara la traducción; la opción [ResponseHeadersRead] permite hacer lo mismo con [HttpClient];
    • líneas 131–138: el documento se lee a medida que llega, línea por línea, y la traducción se busca en cada línea. En cuanto se encuentra, se devuelve, decodificada; las instrucciones [using] cierran el flujo y liberan la respuesta, y el resto de la página nunca se lee;
    • línea 142: un error de comunicación lanza una excepción con código 11;
    • línea 147: si la página se ha leído por completo sin encontrar una traducción, se lanza una excepción con código 12.

El programa de prueba:

  • línea 8: la dirección del sitio web puede pasarse como argumento;
  • línea 9: el cliente HTTP de la aplicación;
  • línea 13: creación del servicio. A partir de ahí, el programa interactúa con el servicio solo a través de su interfaz [ITranslationService];
  • líneas 20–27: los casos de prueba del curso de 2008, más dos casos de error: un texto vacío y una dirección de traducción desconocida. El arreglo es un arreglo de tuplas con nombre (C# 7);
  • línea 29: cada tupla se deconstruye en dos variables.

Resultados, con el sitio [internet-16.cs] iniciado en otra ventana:

> dotnet run internet-17.cs
Translation directions offered by the site:
  fe : French → English
  ef : English → French
  fs : French → Spanish
Translation [French → English] of [ce chien est perdu]: [this dog is lost]
Translation [French → Spanish] of [l'été sera chaud]: [el verano será caliente]
Translation [English → French] of [my tailor is rich]: [mon tailleur est riche]
Translation [English → French] of [xx]: [xx]
The following error with code 12 occurred: The server did not send back a translation
The following error with code 10 occurred: The translation direction [fx] is not recognized
  • líneas 3–5: las direcciones de traducción se leyeron del formulario del sitio web y las entidades HTML se decodificaron;
  • línea 9: una palabra desconocida se devuelve tal cual, igual que hacía el sitio de 2008;
  • línea 10: para un texto vacío, el sitio web devolvió su formulario sin traducción;
  • línea 11: la traducción [fx] fue rechazada por el servicio sin consultar el sitio web.

Si el sitio no está disponible:

1
2
3
> dotnet run internet-17.cs -- http://localhost:27299/
The following error with code 11 occurred: The translation site is unreachable
Cause: HttpRequestException : Connection refused (localhost:27299)

Del lado del sitio web, vemos la solicitud de [curl] mostrada anteriormente, seguida de las enviadas por el cliente: la primera para el formulario, las siguientes para las traducciones (la solicitud [fx], rechazada por el servicio, no generó ninguna petición):

1
2
3
4
5
6
7
8
9
> dotnet run internet-16.cs
Translation service started on http://localhost:27220/translation
GET /translation?direction=fs&text=l%27%C3%A9t%C3%A9%20sera%20chaud -> 200
GET /translation -> 200
GET /translation?direction=fe&text=ce%20chien%20est%20perdu -> 200
GET /translation?direction=fs&text=l%27%C3%A9t%C3%A9%20sera%20chaud -> 200
GET /translation?direction=ef&text=my%20tailor%20is%20rich -> 200
GET /translation?direction=ef&text=xx -> 200
GET /translation?direction=fe&text= -> 200

12.7.3.4. Conclusión

Esta aplicación demostró que [HttpClient] nos permite aprovechar los recursos web. La técnica es la misma cada vez:

  • determinar qué URL consultar. Suele estar preconfigurada;
  • consultarla;
  • encontrar lo que buscamos en la respuesta del servidor mediante expresiones regulares.

Esta técnica, conocida hoy como “web scraping”, es frágil: con el tiempo, la URL consultada o la estructura de la página pueden cambiar, y la expresión regular que antes encontraba el resultado puede dejar de funcionar. Conviene almacenar esta información en un archivo de configuración, pero eso no siempre basta; además, las condiciones de uso de muchos sitios lo prohíben. Un análisis robusto de una página HTML se realizaría, de hecho, mejor con una biblioteca especializada (AngleSharp, HtmlAgilityPack) que con expresiones regulares. En el próximo capítulo veremos que existen en la Web recursos más estables, diseñados para ser utilizados por programas: los servicios web. Los servicios de traducción actuales, por ejemplo, ofrecen todos una interfaz de este tipo, que acepta y devuelve JSON.

12.7.4. Un cliente SMTP con la clase SmtpClient

Un cliente SMTP es un cliente de un servidor SMTP (un servidor de envío de correo) cuyo protocolo describimos en la Parte 1. La clase [SmtpClient] del espacio de nombres [System.Net.Mail] encapsula las exigencias de un cliente de este tipo: el desarrollador no necesita conocer los detalles del protocolo SMTP ni los del formato de mensajes MIME. Se acompaña de las clases [MailMessage] (un mensaje), [MailAddress] (una dirección de correo) y [Attachment] (un archivo adjunto).

La clase [SmtpClient] sigue existiendo en .NET 10 y no se ha declarado obsoleta, pero su documentación indica que Microsoft no la recomienda para nuevos desarrollos: no admite los protocolos de autenticación modernos (OAuth 2.0, que los principales proveedores de correo exigen cada vez más) y ya no se actualizará. La documentación recomienda la biblioteca de código abierto MailKit (el paquete NuGet [MailKit]), que además admite la lectura de correo en POP3 e IMAP. Como este paquete no está disponible en el entorno del curso, presentaremos [SmtpClient], cuyos principios básicos (un mensaje, direcciones, archivos adjuntos y un cliente que lo envía) son idénticos a los de MailKit.

El curso de 2008 presentaba [SmtpClient] en una aplicación de Windows Forms que enviaba el correo al puerto 25 de un servidor SMTP real, después de pedirle al usuario que desactivara su protección antivirus. Nosotros lo haremos más simple y seguro: el correo se enviará a un pequeño servidor SMTP de pruebas escrito en C# y ejecutado en la máquina local, que mostrará todo lo que reciba y no reenviará nada. Para un uso real existen servidores de prueba completos, como Mailpit o smtp4dev, que además ofrecen una interfaz web para ver los mensajes recibidos.

12.7.4.1. Un servidor SMTP de pruebas

Nuestro servidor SMTP sigue la estructura del servidor de eco de la Parte 1: un bucle asíncrono que espera clientes, una tarea por cliente y un token de cancelación activado con Ctrl-C. El servicio que se presta a cada cliente es el diálogo SMTP mínimo presentado en la Parte 1. El programa [internet-18.cs] es el siguiente:

using System.Net;
using System.Net.Sockets;
using System.Text;

// servidor SMTP de pruebas: reproduce el diálogo SMTP mínimo y muestra los mensajes recibidos,
// sin entregarlos nunca a sus destinatarios
// llamada: dotnet run internet-18.cs [-- port]   (puerto 27225 de forma predeterminada); se detiene con Ctrl-C
int port = args.Length == 1 && int.TryParse(args[0], out int p) ? p : 27225;

// Ctrl-C cancela el token: el servidor se detiene limpiamente
using var cancellation = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    cancellation.Cancel();
};

// el servidor solo acepta clientes de la máquina local
var listener = new TcpListener(IPAddress.Loopback, port);
var services = new List<Task>();
int clientNumber = 0;
try
{
    listener.Start();
    Console.WriteLine($"Test SMTP server started on {listener.LocalEndpoint}");
    while (true)
    {
        TcpClient client = await listener.AcceptTcpClientAsync(cancellation.Token);
        services.Add(ServeAsync(client, clientNumber++, cancellation.Token));
        services.RemoveAll(service => service.IsCompleted);
    }
}
catch (OperationCanceledException)
{
    Console.WriteLine("Server stop requested");
}
finally
{
    listener.Stop();
}
await Task.WhenAll(services);

// --------------------------------------------------------------------
// el diálogo SMTP con un cliente: C: líneas recibidas del cliente, S: líneas enviadas por el servidor
static async Task ServeAsync(TcpClient client, int clientNumber, CancellationToken token)
{
    Console.WriteLine($"--- start of the dialog with client {clientNumber} ({client.Client.RemoteEndPoint})");
    try
    {
        using (client)
        {
            NetworkStream stream = client.GetStream();
            using var reader = new StreamReader(stream, Encoding.UTF8);
            // SMTP exige finales de línea \r\n
            await using var writer = new StreamWriter(stream, new UTF8Encoding(false)) { AutoFlush = true, NewLine = "\r\n" };

            // envío de una línea de respuesta, que también se muestra en la consola
            async Task ReplyAsync(string response)
            {
                Console.WriteLine($"S: {response}");
                await writer.WriteLineAsync(response);
            }

            // el sobre del mensaje actual: remitente y destinatarios
            string? sender = null;
            List<string> recipients = [];
            // mensaje de bienvenida
            await ReplyAsync("220 smtp.test ESMTP test server of the C# course");
            while (await reader.ReadLineAsync(token) is string command)
            {
                Console.WriteLine($"C: {command}");
                // el verbo: los cuatro primeros caracteres, sin distinguir mayúsculas de minúsculas
                string verb = command.Length >= 4 ? command[..4].ToUpperInvariant() : command;
                switch (verb)
                {
                    case "EHLO":
                        // respuesta de varias líneas: 250-... y luego 250 ...
                        await ReplyAsync("250-smtp.test hello");
                        await ReplyAsync("250-SIZE 10485760");
                        await ReplyAsync("250 8BITMIME");
                        break;
                    case "HELO":
                        await ReplyAsync("250 smtp.test hello");
                        break;
                    case "MAIL":
                        // MAIL FROM:<address>
                        sender = command[(command.IndexOf(':') + 1)..].Trim();
                        recipients.Clear();
                        await ReplyAsync("250 2.1.0 Ok");
                        break;
                    case "RCPT":
                        // RCPT TO:<address>
                        recipients.Add(command[(command.IndexOf(':') + 1)..].Trim());
                        await ReplyAsync("250 2.1.5 Ok");
                        break;
                    case "DATA" when sender is null || recipients.Count == 0:
                        await ReplyAsync("503 5.5.1 Give the sender and the recipients first");
                        break;
                    case "DATA":
                        await ReplyAsync("354 End data with <CR><LF>.<CR><LF>");
                        // el mensaje: todas las líneas hasta una línea reducida a un punto
                        int nbLines = 0;
                        while (await reader.ReadLineAsync(token) is string line && line != ".")
                        {
                            Console.WriteLine($"C: {line}");
                            nbLines++;
                        }
                        Console.WriteLine("C: .");
                        Console.WriteLine($"[message from {sender} to {string.Join(", ", recipients)}: {nbLines} lines]");
                        await ReplyAsync("250 2.0.0 Ok: message accepted");
                        sender = null;
                        recipients.Clear();
                        break;
                    case "RSET":
                        sender = null;
                        recipients.Clear();
                        await ReplyAsync("250 2.0.0 Ok");
                        break;
                    case "NOOP":
                        await ReplyAsync("250 2.0.0 Ok");
                        break;
                    case "QUIT":
                        await ReplyAsync("221 2.0.0 Goodbye");
                        return;
                    default:
                        await ReplyAsync("502 5.5.2 Command not recognized");
                        break;
                }
            }
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"Dialog with client {clientNumber} interrupted by the server stop");
    }
    catch (IOException ex)
    {
        Console.WriteLine($"The following error occurred with client {clientNumber}: {ex.Message}");
    }
    finally
    {
        Console.WriteLine($"--- end of the dialog with client {clientNumber}");
    }
}

Solo comentaremos lo que es nuevo con respecto al servidor de eco:

  • Línea 19: el servidor escucha únicamente en la dirección de bucle invertido (loopback): solo los programas de la misma máquina pueden conectarse a él;
  • línea 55: SMTP exige finales de línea \r\n, sea cual sea el sistema;
  • líneas 58–61: una función local (C# 7) que envía una línea de respuesta al cliente y la muestra en la consola, precedida de [S:]. Las líneas recibidas del cliente se muestran precedidas de [C:], como en los diálogos de ejemplo de la Parte 1;
  • líneas 65–66: el encabezado del mensaje actual: el remitente identificado por [MAIL FROM] y los destinatarios identificados por [RCPT TO];
  • línea 68: el mensaje de bienvenida: en SMTP, el servidor habla primero;
  • línea 73: el verbo del comando está formado por sus cuatro primeros caracteres ([EHLO], [MAIL], [RCPT]…), cuyas mayúsculas y minúsculas no se conocen;
  • Líneas 76–80: la respuesta a [EHLO] consta de varias líneas. En ellas, el servidor especifica sus capacidades: el tamaño máximo de los mensajes ([SIZE]) y la compatibilidad con caracteres codificados en 8 bits ([8BITMIME]);
  • línea 96: una cláusula [case] puede complementarse con una condición [when]: el comando [DATA] se rechaza si no se han especificado el remitente o los destinatarios;
  • líneas 99–110: el mensaje propiamente dicho. El servidor invita al cliente a enviarlo (código 354), luego lee y muestra todas las líneas hasta una línea reducida a un solo punto, y confirma la recepción (código 250);
  • líneas 122–124: el cliente ha terminado; el servidor responde y cierra la conexión, saliendo del método;
  • línea 126: cualquier otro comando se rechaza.

Este servidor no realiza muchas verificaciones y no admite las extensiones [STARTTLS] y [AUTH] : basta para observar lo que envía [SmtpClient].

12.7.4.2. El cliente SMTP

El programa [internet-19.cs] solicita al usuario por teclado los elementos del correo que la aplicación gráfica de 2008 hacía ingresar en su formulario, y luego los envía al servidor SMTP especificado como argumento:

using System.Net.Mail;
using System.Net.Mime;
using System.Text;

// envío de un correo electrónico con la clase SmtpClient
// llamada: dotnet run internet-19.cs -- smtpServer port
// los archivos adjuntos se buscan en la carpeta actual

const string syntax = "Syntax: dotnet run internet-19.cs -- smtpServer port";
if (args.Length != 2 || !int.TryParse(args[1], out int port) || port is < 1 or > 65535)
{
    Console.WriteLine(syntax);
    return;
}
string server = args[0];

// entrada de los elementos del correo
string sender = Input("Sender");
string recipients = Input("Recipients (separated by commas)");
string copies = Input("Copy to (Cc)");
string blindCopies = Input("Blind copy to (Bcc)");
string subject = Input("Subject");
string attachments = Input("Attachments (separated by commas)");
// el texto: varias líneas, terminadas por una línea vacía
Console.WriteLine("Text of the message (ended by an empty line):");
var text = new StringBuilder();
while (Console.ReadLine() is string line && line != "")
{
    text.AppendLine(line);
}

try
{
    // el mensaje
    using var message = new MailMessage
    {
        From = new MailAddress(sender),
        Subject = subject,
        Body = text.ToString(),
        // el texto se codifica en UTF-8 y se transporta tal cual (8 bits)
        BodyEncoding = Encoding.UTF8,
        BodyTransferEncoding = TransferEncoding.EightBit,
    };
    // las direcciones: Add acepta una lista de direcciones separadas por comas
    message.To.Add(recipients);
    if (copies != "")
    {
        message.CC.Add(copies);
    }
    if (blindCopies != "")
    {
        message.Bcc.Add(blindCopies);
    }
    // los archivos adjuntos, designados por su ruta
    foreach (string file in attachments.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
    {
        message.Attachments.Add(new Attachment(file));
    }

    // el cliente SMTP: conoce el protocolo SMTP y el formato MIME de los mensajes
    using var client = new SmtpClient(server, port);
    await client.SendMailAsync(message);

    // resumen del envío
    Console.WriteLine("Sending successful...");
    Console.WriteLine($"Subject: {message.Subject}");
    Console.WriteLine($"Recipients: {message.To}");
    Console.WriteLine($"Cc: {message.CC}");
    Console.WriteLine($"Bcc: {message.Bcc}");
    Console.WriteLine($"Attachments: {string.Join(", ", message.Attachments.Select(attachment => attachment.Name))}");
}
catch (Exception ex) when (ex is FormatException or SmtpException or IOException)
{
    Console.WriteLine($"The following error occurred: {ex.GetType().Name} : {ex.Message}");
    if (ex.InnerException is Exception cause)
    {
        Console.WriteLine($"Cause: {cause.GetType().Name} : {cause.Message}");
    }
}

// entrada de una línea con el teclado
static string Input(string label)
{
    Console.Write($"{label}: ");
    return Console.ReadLine()?.Trim() ?? "";
}

Comentarios:

  • líneas 18–23: ingreso de los elementos del correo, mediante la función local [Input];
  • líneas 26–29: el texto del mensaje, en varias líneas, que termina con una línea en blanco;
  • líneas 35–42: el mensaje, creado con un inicializador de objeto:
    • [From]: el remitente, un objeto [MailAddress]. El constructor de [MailAddress] verifica el formato de la dirección y lanza una [FormatException] si es incorrecto;
    • [Subject], [Body]: el asunto y el cuerpo del mensaje;
    • [BodyEncoding], [BodyTransferEncoding]: el texto se codifica en UTF-8 y se transmite tal cual, con 8 bits (el servidor indicó que acepta este formato). Sin estas dos propiedades, [SmtpClient] elegiría su propia codificación (base64 o quoted-printable), lo que dificultaría la lectura del texto cuando lo muestre el servidor;
  • Líneas 45–52: los destinatarios, los del campo “Cc” (con copia) y los del campo “Bcc” (con copia oculta). Los destinatarios del campo “Bcc” reciben el mensaje, pero los demás destinatarios no lo saben. El método [Add] de las colecciones [To], [CC], y [Bcc] acepta una lista de direcciones separadas por comas; la versión de 2008 analizaba la lista por sí misma mediante una expresión regular;
  • líneas 55–57: archivos adjuntos, identificados por su ruta de archivo. Una ruta relativa lo es respecto del directorio actual; en nuestras pruebas, el archivo [attachment.txt] se encuentra en el directorio [12-internet], desde el cual se inicia el programa;
  • línea 61: el cliente SMTP, con el nombre del servidor y el puerto. Para un servidor real, también especificaríamos [EnableSsl = true] (cifrado mediante [STARTTLS]) y las credenciales de conexión, [Credentials = new NetworkCredential("username", "password")];
  • línea 62: envío asíncrono del mensaje. El curso de 2008 usaba el método síncrono [Send];
  • líneas 65–70: un resumen del envío;
  • Línea 72: una dirección no válida provoca un error [FormatException]; un problema de envío provoca un error [SmtpException]; un archivo adjunto no encontrado provoca un error [FileNotFoundException], derivado de [IOException].

El servidor SMTP de pruebas se inicia en una ventana de comandos en el puerto 27225. En otra ventana, se envía un mensaje a dos destinatarios, con un destinatario en copia, uno en copia oculta y un archivo adjunto:

> dotnet run internet-19.cs -- localhost 27225
Sender: alice@example.org
Recipients (separated by commas): bob@example.com, carole@example.com
Copy to (Cc): david@example.com
Blind copy to (Bcc): eve@example.com
Subject: Minutes of the meeting at the café
Attachments (separated by commas): attachment.txt
Text of the message (ended by an empty line):
Hello,
here are the minutes of the meeting at the café.
Best regards,
Alice

Sending successful...
Subject: Minutes of the meeting at the café
Recipients: bob@example.com, carole@example.com
Cc: david@example.com
Bcc: eve@example.com
Attachments: attachment.txt

El archivo [attachment.txt] contiene dos líneas de texto. Esto es lo que mostró el servidor:

> dotnet run internet-18.cs
Test SMTP server started on 127.0.0.1:27225
--- start of the dialog with client 0 (127.0.0.1:53546)
S: 220 smtp.test ESMTP test server of the C# course
C: EHLO vm
S: 250-smtp.test hello
S: 250-SIZE 10485760
S: 250 8BITMIME
C: MAIL FROM:<alice@example.org>
S: 250 2.1.0 Ok
C: RCPT TO:<bob@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<carole@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<eve@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<david@example.com>
S: 250 2.1.5 Ok
C: DATA
S: 354 End data with <CR><LF>.<CR><LF>
C: MIME-Version: 1.0
C: From: alice@example.org
C: To: bob@example.com, carole@example.com
C: Cc: david@example.com
C: Date: 3 Oct 2026 12:20:36 +0200
C: Subject: =?utf-8?B?TWludXRlcyBvZiB0aGUgbWVldGluZyBhdCB0aGUgY2Fmw6k=?=
C: Content-Type: multipart/mixed;
C:  boundary=--boundary_0_40431766-5e35-4c3f-a18f-31531f8834df
C: 
C: 
C: ----boundary_0_40431766-5e35-4c3f-a18f-31531f8834df
C: Content-Type: text/plain; charset=utf-8
C: Content-Transfer-Encoding: 8bit
C: 
C: Hello,
C: here are the minutes of the meeting at the café.
C: Best regards,
C: Alice
C: 
C: ----boundary_0_40431766-5e35-4c3f-a18f-31531f8834df
C: Content-Type: application/octet-stream; name=attachment.txt
C: Content-Transfer-Encoding: base64
C: Content-Disposition: attachment
C: 
C: VGhpcyBpcyB0aGUgYXR0YWNobWVudCBvZiB0aGUgdGVzdCBtYWlsLgpJdCBjb250YWlu
C: cyB0d28gbGluZXMuCg==
C: ----boundary_0_40431766-5e35-4c3f-a18f-31531f8834df--
C: 
C: 
C: .
[message from <alice@example.org> to <bob@example.com>, <carole@example.com>, <eve@example.com>, <david@example.com>: 29 lines]
S: 250 2.0.0 Ok: message accepted
C: QUIT
S: 221 2.0.0 Goodbye
--- end of the dialog with client 0
Server stop requested

Comentarios:

  • línea 5: [SmtpClient] se presenta con el nombre de la máquina;
  • líneas 9–17: el sobre del mensaje: el remitente, seguido de todos los destinatarios, incluido el destinatario con copia oculta (BCC) ([eve@example.com]). El sobre determina a quién se entrega el mensaje;
  • líneas 21–28: los encabezados del mensaje, que constituyen lo que verán los destinatarios. Incluyen los destinatarios [To] y [Cc], pero no el destinatario con copia oculta: así es como la copia oculta permanece oculta. El asunto contiene un carácter acentuado; como los encabezados solo pueden contener caracteres ASCII, se codificó según el estándar RFC 2047: [=?utf-8?B?...?=] significa “texto UTF-8 codificado en Base64”;
  • línea 27: el mensaje está en formato MIME (Multipurpose Internet Mail Extensions, RFC 2045 y siguientes): consta de varias partes, separadas por una línea delimitadora ([boundary]) elegida al azar por [SmtpClient];
  • líneas 32–38: la primera parte, el texto del mensaje, en UTF-8 de 8 bits: se lee tal cual;
  • líneas 41–46: la segunda parte, el archivo adjunto, codificado en Base64. Base64 codifica bytes arbitrarios con 64 caracteres del conjunto ASCII; el servidor de correo del destinatario no necesita conocer la naturaleza del archivo adjunto;
  • línea 50: el fin del mensaje;
  • línea 51: nuestro servidor recibió un mensaje para cuatro destinatarios;
  • líneas 53–54: [SmtpClient] finaliza el intercambio;
  • línea 56: el servidor se detuvo con Ctrl-C después de las pruebas.

Una dirección no válida se rechaza antes de enviar cualquier mensaje:

> dotnet run internet-19.cs -- localhost 27225
Sender: alice@example.org
Recipients (separated by commas): bob.example.com
Copy to (Cc): 
Blind copy to (Bcc): 
Subject: test
Attachments (separated by commas): 
Text of the message (ended by an empty line):
text

The following error occurred: FormatException : The specified string is not in the form required for an e-mail address.

Si el servidor SMTP no está disponible, se lanza una [SmtpException]; su excepción interna indica la causa:

> dotnet run internet-19.cs -- localhost 27299
Sender: alice@example.org
Recipients (separated by commas): bob@example.com
Copy to (Cc): 
Blind copy to (Bcc): 
Subject: test
Attachments (separated by commas): 
Text of the message (ended by an empty line):
text

The following error occurred: SmtpException : Failure sending mail.
Cause: SocketException : Connection refused

12.8. Un cliente TCP asíncrono genérico

El curso de 2008 dedicaba aquí una sección completa a un cliente TCP asíncrono genérico, con una interfaz gráfica de Windows Forms: un campo para el nombre del servidor y el puerto, un botón [Connect] / [Disconnect], un cuadro de texto para ingresar las líneas que se enviarían y dos listas que mostraban los eventos de la conexión y la comunicación con el servidor. Las interfaces gráficas de usuario ya no forman parte de este curso, y este ejemplo ha perdido casi toda su relevancia: su propósito era demostrar la programación asíncrona, que ha sufrido una transformación completa desde 2008.

El cliente de 2008 trabajaba directamente con un objeto [Socket] y usaba el modelo asíncrono de la época, llamado APM (Asynchronous Programming Model): cada operación se dividía en un método [BeginXxx], que iniciaba la operación y devolvía el control de inmediato, y un método [EndXxx], llamado dentro de un método de devolución de llamada (callback) ejecutado por un hilo del grupo al terminar la operación. La conexión se escribía así:

// inicio de la conexión: se llamará de vuelta al método connected al final de la operación
client.BeginConnect(Dns.GetHostEntry(serverName).AddressList[0], port, connected, client);
...
// el método de callback
private void connected(IAsyncResult result)
{
    Socket client = result.AsyncState as Socket;
    // fin de la operación: lanza una excepción si la conexión falló
    client.EndConnect(result);
    // inicio de la lectura asíncrona de los datos enviados por el servidor
    client.BeginReceive(data, 0, bufferSize, SocketFlags.None, read, client);
}

El método de devolución de llamada [read] de la operación de recepción debía a su vez llamar a [BeginReceive] para leer el resto de los datos, reconstruir las líneas a partir de los bloques de bytes recibidos (ya que una línea podía quedar dividida entre dos bloques) y, como se ejecutaba en un hilo del grupo, llamar al método [Invoke] del formulario para actualizar la interfaz gráfica. El código era extenso y la lógica del diálogo estaba dispersa en varios métodos.

El modelo APM fue reemplazado por el modelo basado en tareas (TAP, Task-based Asynchronous Pattern, introducido con .NET 4 en 2010) y por las palabras clave [async] / [await] (C# 5, 2012), presentadas en el Capítulo 9. El cliente TCP genérico de la primera parte ([internet-06.cs]) ya es un cliente asíncrono: [ConnectAsync] reemplaza el par [BeginConnect] / [EndConnect]; una tarea de recepción que llama a [ReadLineAsync] en un bucle reemplaza la cadena de devoluciones de llamada de [BeginReceive]; y [StreamReader] se encarga de reconstruir las líneas. El código se lee en el orden en que se ejecuta, como el código síncrono. En una aplicación gráfica actual (WPF, WinUI, .NET MAUI), [await] también reanuda la ejecución en el hilo de la interfaz, lo que elimina la necesidad de llamar a [Invoke].

La conclusión del curso de 2008 sigue siendo válida: la asincronía aporta poco a un cliente con una sola conexión, aparte de una interfaz que se mantiene receptiva; en cambio, es esencial para un servidor. Un servidor que atiende a sus clientes con operaciones bloqueantes ocupa un hilo por cliente; con operaciones asíncronas, bastan unos pocos hilos para atender a un gran número de clientes. Esto es lo que hace el servidor del siguiente ejemplo de aplicación.

12.9. Aplicación de ejemplo, versión 8: servidor de cálculo del impuesto

12.9.1. La arquitectura de la nueva versión

Retomaremos la aplicación de cálculo del impuesto. En la versión 5 (Capítulo 6), constaba de tres capas, cada una en su propia biblioteca: [dao] (los tramos del impuesto), [business] (el cálculo) y [ui] (el diálogo de consola), ensambladas mediante inyección de dependencias; las versiones 6 y 7 reemplazaron la capa [dao] por un acceso a base de datos. El curso de 2008 partía de la versión 7 (datos en una base de datos, interfaz gráfica); nosotros partimos de la versión 5, que es más sencilla de ejecutar: la nueva versión funcionaría de la misma manera con la capa [dao] de las versiones 6 y 7.

Distribuiremos esta arquitectura en dos máquinas:

Image

  • Una máquina [server] aloja las capas [business] y [dao] de la versión 5. Se construye una capa [server] para permitir que los clientes de la red consulten el servicio de cálculo del impuesto mediante un protocolo TCP basado en texto;
  • una máquina [client] aloja la capa [ui] de la versión 5. Una nueva capa [business], que actúa como cliente del servidor (TCP), permite al cliente consultar el servicio de cálculo del impuesto.

La arquitectura cambia de forma significativa: la versión 5 era una aplicación monousuario; la versión 8 se convierte en una aplicación cliente/servidor, y el servidor podrá atender a varios clientes simultáneamente. Sin embargo, escribiremos solo dos clases nuevas, [TaxServer] y [TaxBusinessTcp], y dos programas principales: todo lo demás se reutiliza sin modificaciones.

La solución [TaxV8] consta de dos proyectos de consola que hacen referencia a los proyectos de la versión 5:

12-internet/TaxV8/
  TaxV8.slnx
  Tax.Server/
    Tax.Server.csproj          references to Tax.Dao and Tax.Business (V5)
    appsettings.json           configuration of the [dao] layer and of the server
    Program.cs                 integration of the layers, launch of the server
    TaxServer.cs               the [server] layer
  Tax.Client/
    Tax.Client.csproj          references to Tax.Business and Tax.Ui (V5)
    TaxBusinessTcp.cs          the [business] layer of the client: a TCP client
    Program.cs                 integration of the layers, dialog

12.9.2. El protocolo de comunicación

Conservamos el protocolo del servidor de 2008. Una vez conectado el cliente, el servidor le envía un mensaje de bienvenida y luego acepta los siguientes comandos, uno por línea, sin distinguir mayúsculas de minúsculas:

Comando
Respuesta del servidor
help
una lista de los comandos aceptados, en cuatro líneas
tax married nbChildren annualSalary
el impuesto de una persona casada (married es [y]) o de una persona soltera ([n]) con [nbChildren] hijos y un salario anual de [annualSalary] euros, por ejemplo, [4282] en respuesta a [tax y 2 60000]; o un mensaje de error, en una línea
goodbye
el mensaje [Goodbye...]; el servidor cierra entonces la conexión

Cualquier otro comando recibe la respuesta [Command not recognized. Use the help command.]

12.9.3. El servidor de cálculo del impuesto

12.9.3.1. El proyecto

El archivo [Tax.Server.csproj] es el siguiente:

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

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

  <ItemGroup>
    <!-- las capas [dao] y [business] de la versión 5, reutilizadas tal cual -->
    <ProjectReference Include="../../../06-architectures/TaxV5/Tax.Dao/Tax.Dao.csproj" />
    <ProjectReference Include="../../../06-architectures/TaxV5/Tax.Business/Tax.Business.csproj" />
  </ItemGroup>

  <ItemGroup>
    <!-- contenedor de inyección de dependencias y lectura de un archivo de configuración JSON -->
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.12" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.12" />
  </ItemGroup>

  <ItemGroup>
    <!-- el archivo de configuración se copia junto al ejecutable -->
    <None Update="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • Líneas 12–13: las capas [dao] y [business] de la versión 5 se referencian mediante sus proyectos. Los archivos de datos [TaxData.txt] y [TaxData.json] del proyecto [Tax.Dao] se copian en la carpeta de salida del servidor;
  • líneas 18–19: el contenedor de inyección de dependencias y la lectura de un archivo de configuración JSON, como en la versión 5;
  • línea 24: el archivo de configuración se copia junto al ejecutable.

El archivo de configuración [appsettings.json]:

{
  "Dao": {
    "Implementation": "FileTax",
    "File": "TaxData.txt"
  },
  "Server": {
    "Port": 27200,
    "Echo": true
  }
}
  • Líneas 2–4: la configuración de la capa [dao], idéntica a la de la versión 5: los tramos del impuesto se leen del archivo de texto [TaxData.txt];
  • Líneas 6–8: el puerto de escucha del servidor y el eco del diálogo con los clientes en el registro del servidor. El servidor de 2008 tenía una consola de administración (comandos [start port], [stop], [echo start], [echo stop], [status], [quit]); optamos por un archivo de configuración y el apagado mediante Ctrl-C, que son más simples y se ajustan más al funcionamiento de los servidores modernos.

12.9.3.2. El programa principal

El archivo [Program.cs] del servidor es el siguiente:

using Dao;
using Entities;
using Business;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Server;

// el servidor TCP de cálculo del impuesto: configuración, integración de las capas, ejecución
TaxServer server;
try
{
    // lectura de la configuración, junto al ejecutable
    IConfiguration config = new ConfigurationBuilder()
        .SetBasePath(AppContext.BaseDirectory)
        .AddJsonFile("appsettings.json", optional: false)
        .Build();
    string implementation = config["Dao:Implementation"] ?? "HardwiredTax";
    string file = config["Dao:File"] ?? "";
    int port = int.TryParse(config["Server:Port"], out int p) ? p : 27200;
    bool echo = bool.TryParse(config["Server:Echo"], out bool e) && e;

    // registro de las capas en el contenedor
    var services = new ServiceCollection();
    // la capa [dao]: la implementación se elige mediante la configuración (como en la versión 5)
    services.AddSingleton<ITaxDao>(_ => implementation switch
    {
        "HardwiredTax" => new HardwiredTax(),
        "FileTax" => new FileTax(file),
        "JsonTax" => new JsonTax(file),
        _ => throw new TaxException($"Unknown implementation [{implementation}] of the [dao] layer")
    });
    // la capa [business] de la versión 5
    services.AddSingleton<ITaxBusiness, TaxBusiness>();
    // la capa [server]: el contenedor le pasará la capa [business] y sus opciones
    services.AddSingleton(new ServerOptions(port, echo));
    services.AddSingleton<TaxServer>();

    // creación del servidor y, por lo tanto, de las capas [business] y [dao]
    ServiceProvider provider = services.BuildServiceProvider();
    server = provider.GetRequiredService<TaxServer>();
}
catch (Exception ex)
{
    // muestra de la cadena de excepciones y detención
    Console.WriteLine("The following error occurred during the initialization of the server:");
    for (Exception? cause = ex; cause != null; cause = cause.InnerException)
    {
        Console.WriteLine($"{cause.GetType().Name} : {cause.Message}");
    }
    return 1;
}

// Ctrl-C cancela el token: el servidor se detiene limpiamente
using var cancellation = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    cancellation.Cancel();
};
// ejecución del servidor hasta la detención solicitada
await server.RunAsync(cancellation.Token);
return 0;

Es claramente el programa principal de la versión 5:

  • líneas 13–20: lectura de la configuración. Los valores son cadenas de caracteres: el puerto y el eco se convierten con [TryParse], con valores predeterminados;
  • líneas 25–33: las capas [dao] y [business] se almacenan en el contenedor exactamente igual que en la versión 5;
  • líneas 35–36: la novedad. Las opciones del servidor (puerto, eco) se almacenan como un objeto ya construido, seguido de la propia capa [server]. El constructor de [TaxServer] espera un [ITaxBusiness] y un [ServerOptions]: el contenedor se los proporcionará;
  • línea 40: la creación del servidor provoca la creación de la capa [business], que a su vez provoca la creación de la capa [dao]; es en ese momento cuando se lee el archivo [TaxData.txt]. Un error (archivo inexistente, mal formado) se muestra y el programa termina (líneas 42–50);
  • líneas 54–58: Ctrl-C cancela el token de [cancellation], como en el servidor de eco;
  • línea 61: el servidor se ejecuta hasta que se cancela el token.

12.9.3.3. La capa [server]

La clase [TaxServer] es la siguiente:

using System.Net;
using System.Net.Sockets;
using Business;

namespace Server;

// las opciones del servidor: puerto de escucha y eco del diálogo en el registro
public record ServerOptions(int Port, bool Echo);

// la capa [server]: hace accesible la capa [business] mediante un protocolo TCP de líneas de texto
public class TaxServer(ITaxBusiness business, ServerOptions options)
{
    // las respuestas fijas del protocolo
    private const string Welcome = "Welcome to the tax calculation server";
    private const string Help = "Accepted commands\n1-help\n2-tax married(Y/N) nbChildren annualSalary\n3-goodbye";
    private const string Goodbye = "Goodbye...";
    private const string IncorrectCommand = "Command not recognized. Use the help command.";
    private const string IncorrectCalculation = "Incorrect calculation command. Use the help command.";

    // ejecución del servidor hasta que se cancele el token
    public async Task RunAsync(CancellationToken token)
    {
        var listener = new TcpListener(IPAddress.Any, options.Port);
        // las tareas de servicio en curso
        var services = new List<Task>();
        int clientNumber = 0;
        try
        {
            listener.Start();
            Log($"Tax calculation server started on port {options.Port}");
            while (true)
            {
                // espera de un cliente
                TcpClient client = await listener.AcceptTcpClientAsync(token);
                // lo atiende una tarea que no esperamos: volvemos a esperar al siguiente cliente
                services.Add(ServeAsync(client, clientNumber++, token));
                services.RemoveAll(service => service.IsCompleted);
            }
        }
        catch (OperationCanceledException)
        {
            Log("Server stop requested");
        }
        catch (SocketException ex)
        {
            Log($"The following error occurred on the server: {ex.SocketErrorCode} ({ex.Message})");
        }
        finally
        {
            listener.Stop();
        }
        // esperamos el final de los servicios en curso
        await Task.WhenAll(services);
        Log("Server stopped");
    }

    // el servicio prestado a un cliente
    private async Task ServeAsync(TcpClient client, int clientNumber, CancellationToken token)
    {
        Log($"Start of service to client {clientNumber} ({client.Client.RemoteEndPoint})");
        try
        {
            using (client)
            {
                NetworkStream stream = client.GetStream();
                using var reader = new StreamReader(stream);
                await using var writer = new StreamWriter(stream) { AutoFlush = true };

                // envío de una respuesta al cliente, con posible eco en el registro
                async Task WriteAsync(string response)
                {
                    if (options.Echo)
                    {
                        Log($"---> client {clientNumber} : {response}");
                    }
                    await writer.WriteLineAsync(response);
                }

                // mensaje de bienvenida
                await WriteAsync(Welcome);
                // bucle de lectura de solicitud / escritura de respuesta, hasta el comando de despedida
                while (await reader.ReadLineAsync(token) is string request)
                {
                    if (options.Echo)
                    {
                        Log($"<--- client {clientNumber} : {request}");
                    }
                    // la solicitud dividida en campos
                    string[] fields = request.Trim().ToLower().Split(' ', StringSplitOptions.RemoveEmptyEntries);
                    if (fields is ["goodbye"])
                    {
                        await WriteAsync(Goodbye);
                        break;
                    }
                    // la respuesta según el comando
                    string response = fields switch
                    {
                        ["help"] => Help,
                        ["tax", ..] => CalculateTax(fields),
                        _ => IncorrectCommand,
                    };
                    await WriteAsync(response);
                }
            }
        }
        catch (OperationCanceledException)
        {
            Log($"Service to client {clientNumber} interrupted by the server stop");
        }
        catch (IOException ex)
        {
            Log($"The following error occurred while serving client {clientNumber}: {ex.Message}");
        }
        finally
        {
            Log($"End of service to client {clientNumber}");
        }
    }

    // el comando tax married nbChildren annualSalary: devuelve el impuesto o un mensaje de error
    private string CalculateTax(string[] fields)
    {
        // se necesitan 4 campos: tax, y o n, dos enteros
        if (fields is not [_, "y" or "n", var children, var salary]
            || !int.TryParse(children, out int nbChildren)
            || !int.TryParse(salary, out int annualSalary))
        {
            return IncorrectCalculation;
        }
        try
        {
            // el cálculo se entrega a la capa [business]
            return business.CalculateTax(fields[1] == "y", nbChildren, annualSalary).ToString();
        }
        catch (Exception ex)
        {
            // el mensaje de la excepción, en una sola línea: el protocolo está hecho de líneas de texto
            return ex.Message.ReplaceLineEndings(" ");
        }
    }

    // el registro del servidor: cada línea lleva una marca de tiempo
    private static void Log(string message) => Console.WriteLine($"{DateTime.Now:HH:mm:ss} {message}");
}
  • línea 8: las opciones del servidor, un record posicional (C# 9);
  • línea 11: la clase recibe la capa [business] y sus opciones mediante su constructor primario (C# 12). Solo conoce la interfaz [business] [ITaxBusiness] de la capa y no sabe nada de la capa [dao];
  • líneas 14–18: las respuestas fijas del protocolo. La respuesta al comando [help] contiene \n: el cliente la recibirá como cuatro líneas, como en 2008;
  • líneas 21–54: el bucle de espera de clientes. Es el mismo que el del servidor de eco de la primera parte: cada cliente es atendido por una tarea asíncrona que no se bloquea (línea 36), la cancelación del token pone fin a la espera de un cliente (línea 40) y el servidor espera a que terminen los servicios en curso antes de cerrarse (línea 53). El servidor de 2008 asignaba cada cliente a un hilo de un grupo limitado a 10 hilos, que permanecía bloqueado mientras duraba el servicio; aquí ningún hilo queda retenido por un cliente que tarda en responder;
  • líneas 58–116: el servicio prestado a un cliente:
    • líneas 70–76: una función local que envía una respuesta al cliente y también la escribe en el registro si el registro está activado;
    • línea 80: una vez conectado el cliente, el servidor le envía un mensaje de bienvenida;
    • línea 82: el bucle de lectura de comandos, que se detiene si el cliente cierra la conexión o si el servidor se apaga;
    • línea 89: el comando, convertido a minúsculas, se descompone en campos. El curso de 2008 usaba [Regex.Split] con el patrón [\s+]; la [RemoveEmptyEntries] opción de [Split] elimina de forma similar los campos vacíos causados por varios espacios consecutivos;
    • línea 90: un patrón de lista (C# 11): el comando consiste únicamente en la palabra [goodbye]. El servidor responde y sale del bucle: la conexión se cierra al salir del bloque [using (client)];
    • líneas 96–100: una expresión [switch] con patrones de lista selecciona la respuesta: [["help"]] reconoce el comando [help] solo, mientras que [["tax", ..]] reconoce un comando que empieza con [tax], seguido de cualquier cantidad de campos (patrón de segmento [..]). El servidor de 2008 cerraba la conexión al recibir una línea vacía; ahora recibe la respuesta [Command not recognized];
  • líneas 121–138: cálculo del impuesto:
    • líneas 124–128: un único patrón de lista comprueba que el comando tenga cuatro campos, que el segundo campo sea [y] o [n], y asigna los dos últimos campos a las variables [children] y [salary]; luego comprueba que sean enteros. El código de 2008 realizaba estas comprobaciones en cuatro pruebas sucesivas;
    • línea 133: el cálculo se solicita a la capa [business]. Una única instancia de [TaxBusiness] atiende a todos los clientes, posiblemente de forma simultánea, desde distintos hilos: esto es posible porque esta clase no modifica ningún dato después de construida (su arreglo de tramos del impuesto es de solo lectura);
    • línea 138: si la capa [business] lanza una excepción (por ejemplo, por un número negativo de hijos), su mensaje se devuelve al cliente. Este mensaje puede contener saltos de línea: se reemplazan por espacios, ya que el protocolo exige una respuesta de una sola línea;
  • línea 143: el registro del servidor, que se muestra en la consola: cada línea está precedida por la hora, lo que permite ver la secuencia de los servicios concurrentes. [Console.WriteLine] puede llamarse sin ninguna precaución especial desde varios hilos: sus escrituras no interfieren entre sí.

12.9.4. El cliente del servidor de cálculo del impuesto

El curso de 2008 usaba la interfaz gráfica de la versión 7; nosotros usamos la interfaz de consola de la versión 5 (la clase [Ui.Dialog]) sin modificarla.

12.9.4.1. La capa [business] del cliente

La capa [ui] se comunica con una capa [business], de la que solo conoce la interfaz [ITaxBusiness]:

1
2
3
4
5
6
7
namespace Business;

// la interfaz de la capa [business]
public interface ITaxBusiness
{
    int CalculateTax(bool married, int nbChildren, int salary);
}

Basta, por lo tanto, con proporcionarle otra implementación de esta interfaz que, en lugar de calcular el impuesto, lo solicite al servidor. Esta es la clase [TaxBusinessTcp]:

using System.Net.Sockets;
using Entities;
using Business;

namespace Client;

// la capa [business] del cliente: implementa ITaxBusiness delegando el cálculo al servidor TCP
public class TaxBusinessTcp : ITaxBusiness, IDisposable
{
    // la conexión al servidor, abierta durante toda la vida del objeto
    private readonly TcpClient client;
    private readonly StreamReader reader;
    private readonly StreamWriter writer;

    // conexión al servidor (máquina, puerto)
    public TaxBusinessTcp(string machine, int port)
    {
        try
        {
            client = new TcpClient(machine, port);
            NetworkStream stream = client.GetStream();
            reader = new StreamReader(stream);
            writer = new StreamWriter(stream) { AutoFlush = true };
            // el servidor habla primero: leemos (e ignoramos) su mensaje de bienvenida
            ReadResponse();
        }
        catch (Exception e) when (e is SocketException or IOException)
        {
            throw new TaxException($"Unable to connect to the server ({machine}, {port})", e) { Code = 21 };
        }
    }

    // cálculo del impuesto: una solicitud, una respuesta
    public int CalculateTax(bool married, int nbChildren, int salary)
    {
        string response;
        try
        {
            writer.WriteLine($"tax {(married ? "y" : "n")} {nbChildren} {salary}");
            response = ReadResponse();
        }
        catch (IOException e)
        {
            throw new TaxException("Error communicating with the server", e) { Code = 22 };
        }
        // el servidor devuelve el impuesto, o un mensaje de error
        return int.TryParse(response, out int tax)
            ? tax
            : throw new TaxException($"The server answered: {response}") { Code = 23 };
    }

    // lectura de una línea de respuesta; null significa que el servidor ha cerrado la conexión
    private string ReadResponse() =>
        reader.ReadLine() ?? throw new TaxException("The server has closed the connection") { Code = 24 };

    // fin de la conexión: nos despedimos del servidor, si todavía está ahí
    public void Dispose()
    {
        try
        {
            writer.WriteLine("goodbye");
            reader.ReadLine();
        }
        catch (IOException)
        {
            // la conexión ya está cortada: no queda nada por hacer
        }
        client.Dispose();
    }
}
  • línea 8: la clase implementa [ITaxBusiness]. También implementa [IDisposable]: mantiene una conexión de red, que debe cerrarse;
  • líneas 11–13: la conexión con el servidor y sus flujos de lectura y escritura. La clase de 2008 abría una nueva conexión para cada cálculo; nosotros abrimos una sola conexión, usada para todos los cálculos de una sesión: es más eficiente, y el servidor ve un cliente por sesión de usuario;
  • líneas 16–29: el constructor se conecta al servidor y lee su mensaje de bienvenida (línea 25). Un error de conexión se encapsula en una [TaxException], la excepción de la aplicación;
  • líneas 34–49: el cálculo del impuesto. El comando [tax y 2 60000] se envía al servidor (línea 39) y se lee su respuesta. Si la respuesta es un entero, ese es el monto del impuesto; de lo contrario, es un mensaje de error del servidor, que se devuelve en una [TaxException] (línea 49). El código de 2008 convertía directamente la respuesta a entero y pedía al lector que lo mejorara: un mensaje de error del servidor provocaba una excepción de conversión que ocultaba la verdadera causa del error;
  • línea 53: [ReadLine] devuelve [null] cuando el servidor ha cerrado la conexión; entonces se lanza una [TaxException];
  • líneas 57–68: fin de la conexión. El cliente se despide del servidor con el comando [goodbye] y luego cierra la conexión. Si el servidor ya ha cerrado la conexión, la [IOException] resultante se ignora.

Esto plantea una pregunta: ¿por qué esta clase usa los métodos síncronos [TcpClient(machine, port)], [ReadLine], y [WriteLine], cuando el resto de este capítulo usa sus versiones asíncronas? Porque la interfaz [ITaxBusiness] de la versión 5 es síncrona: [CalculateTax] devuelve un [int], no un [Task<int>], y la capa [ui] la llama sin [await]. Para usar [ReadLineAsync], habría que esperar su resultado de forma bloqueante ([ReadLineAsync().Result]), algo que el capítulo 9 desaconsejaba, o hacer que la interfaz sea asíncrona y, por lo tanto, modificar las capas [business] y [ui] de la versión 5. Para un programa de consola que atiende a un solo usuario, los métodos síncronos son perfectamente adecuados: el hilo principal no tiene nada más que hacer que esperar la respuesta. La asincronía es esencial del lado del servidor, que debe atender a muchos clientes, no del lado del cliente. Cuando escribamos nuevas capas en el próximo capítulo, las dotaremos de interfaces asíncronas.

12.9.4.2. El programa principal del cliente

El proyecto [Tax.Client.csproj] hace referencia a las capas [business] y [ui] de la versión 5:

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

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

  <ItemGroup>
    <!-- la interfaz de la capa [business] y la capa [ui] de la versión 5 -->
    <ProjectReference Include="../../../06-architectures/TaxV5/Tax.Business/Tax.Business.csproj" />
    <ProjectReference Include="../../../06-architectures/TaxV5/Tax.Ui/Tax.Ui.csproj" />
  </ItemGroup>

  <ItemGroup>
    <!-- contenedor de inyección de dependencias -->
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.12" />
  </ItemGroup>

</Project>

El proyecto [Tax.Ui] es una aplicación de consola: un proyecto puede hacer referencia a otro proyecto ejecutable para usar sus clases públicas, en este caso, [Ui.Dialog]. El archivo [Program.cs] es el siguiente:

using Client;
using Entities;
using Business;
using Microsoft.Extensions.DependencyInjection;
using Ui;

// el cliente de consola del servidor de cálculo del impuesto
// llamada: dotnet run [-- machine port]   (de forma predeterminada: localhost 27200)
string machine = args.Length > 0 ? args[0] : "localhost";
int port = args.Length > 1 && int.TryParse(args[1], out int p) ? p : 27200;

// la capa [business] es ahora un cliente TCP del servidor de cálculo del impuesto
var services = new ServiceCollection();
services.AddSingleton<ITaxBusiness>(_ => new TaxBusinessTcp(machine, port));
// el contenedor libera (Dispose) los objetos que creó: la conexión se cerrará al final del programa
using ServiceProvider provider = services.BuildServiceProvider();
try
{
    ITaxBusiness business = provider.GetRequiredService<ITaxBusiness>();
    Console.WriteLine($"Connected to the tax calculation server ({machine}, {port})");
    // la capa [ui] de la versión 5, sin cambios
    Dialog.Run(business);
}
catch (TaxException e)
{
    Dialog.DisplayError(e);
    return 1;
}
return 0;
  • líneas 9–10: la máquina y el puerto del servidor, pasados como argumentos, con valores predeterminados;
  • línea 14: la capa [business] registrada en el contenedor es ahora [TaxBusinessTcp]. Como su constructor espera dos parámetros que el contenedor no conoce, se le proporciona una función de creación;
  • línea 16: el contenedor se declara con [using]. Cuando se libera al final del programa, libera a su vez los objetos [IDisposable] que creó: se llamará al método [Dispose] de [TaxBusinessTcp] y la conexión se cerrará correctamente;
  • línea 19: creación de la capa [business], es decir, la conexión con el servidor;
  • línea 22: el diálogo de la versión 5, sin cambios. La capa [ui] no sabe que el impuesto lo calcula un servidor remoto;
  • líneas 24–27: un error de conexión o de comunicación se muestra mediante el método [DisplayError] de la versión 5.

12.9.5. Ejecuciones

El servidor se inicia en una ventana de comandos desde la carpeta [Tax.Server]. En otra ventana, el cliente se inicia desde la carpeta [Tax.Client]:

> dotnet run
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y two 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

El diálogo es exactamente el mismo que en la versión 5: incluye los valores de validación (4282 y 2959 para una persona casada con 2 o 3 hijos y un salario de 60 000 euros, 11519 para una persona soltera sin hijos), y los mismos mensajes de error para las entradas incorrectas. Estos mensajes los genera la capa [ui] del cliente, que valida los datos ingresados antes de solicitar el cálculo: las entradas incorrectas nunca llegan al servidor.

Ahora iniciemos dos clientes, A y B, en dos ventanas, de modo que B comience mientras A aún está conectado. Cada uno realiza dos cálculos. En la ventana del cliente A:

1
2
3
4
5
6
7
> dotnet run
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 2 40000
Tax=2854 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

En la ventana del cliente B:

1
2
3
4
5
6
7
> dotnet run
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Para ver las respuestas del servidor a comandos incorrectos, se necesita un cliente que envíe los comandos exactamente como se escriben: el cliente TCP genérico de la primera parte funciona perfectamente. El servidor habla primero, algo que este cliente sabe manejar:

> dotnet run internet-06.cs -- localhost 27200
<-- Welcome to the tax calculation server
Type your commands (bye to stop):
help
<-- Accepted commands
<-- 1-help
<-- 2-tax married(Y/N) nbChildren annualSalary
<-- 3-goodbye
tax y 2 60000
<-- 4282
TAX N 0 60000
<-- 11519
tax x 2 60000
<-- Incorrect calculation command. Use the help command.
tax y 2
<-- Incorrect calculation command. Use the help command.
tax y -2 60000
<-- nbChildren ('-2') must be a non-negative value. (Parameter 'nbChildren') Actual value was -2.
calculation
<-- Command not recognized. Use the help command.
goodbye
<-- Goodbye...
[the server has closed the connection]
  • línea 2: el mensaje de bienvenida, que llegó incluso antes del indicador del cliente;
  • líneas 5–8: la respuesta al comando [help], que ocupa cuatro líneas;
  • línea 11: se ignora la distinción entre mayúsculas y minúsculas del comando;
  • líneas 13–15: dos comandos de cálculo mal formados;
  • línea 18: el comando está bien formado, pero la capa [business] rechaza un número negativo de hijos; el mensaje de la excepción (en inglés: proviene de .NET) se devolvió en una sola línea;
  • línea 20: un comando desconocido;
  • líneas 21–23: después del comando [goodbye], el servidor cerró la conexión.

Luego se termina el servidor con Ctrl-C mientras todavía hay un último cliente conectado. Este cliente realizó un primer cálculo antes de la terminación y envió su segunda solicitud después:

1
2
3
4
5
6
7
8
9
> dotnet run
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Exception chain:
----------------------------------------
Entities.TaxException: The server has closed the connection
----------------------------------------

La lectura de la respuesta dio como resultado [null]: la [business] capa lanzó una [TaxException], que el programa principal mostró. Una vez detenido el servidor, un nuevo cliente ya no puede conectarse:

1
2
3
4
5
6
7
> dotnet run
Exception chain:
----------------------------------------
Entities.TaxException: Unable to connect to the server (localhost, 27200)
----------------------------------------
System.Net.Sockets.SocketException: Connection refused 127.0.0.1:27200
----------------------------------------

Por último, este es el registro del servidor correspondiente a todas estas pruebas:

> dotnet run
12:21:33 Tax calculation server started on port 27200
12:21:37 Start of service to client 0 (127.0.0.1:51654)
12:21:37 ---> client 0 : Welcome to the tax calculation server
12:21:38 <--- client 0 : tax y 2 60000
12:21:38 ---> client 0 : 4282
12:21:39 <--- client 0 : tax y 3 60000
12:21:39 ---> client 0 : 2959
12:21:40 <--- client 0 : tax n 0 60000
12:21:40 ---> client 0 : 11519
12:21:43 <--- client 0 : goodbye
12:21:43 ---> client 0 : Goodbye...
12:21:43 End of service to client 0
12:21:47 Start of service to client 1 (127.0.0.1:56532)
12:21:47 ---> client 1 : Welcome to the tax calculation server
12:21:50 Start of service to client 2 (127.0.0.1:56536)
12:21:50 ---> client 2 : Welcome to the tax calculation server
12:21:50 <--- client 1 : tax y 2 60000
12:21:50 ---> client 1 : 4282
12:21:53 <--- client 2 : tax y 3 60000
12:21:53 ---> client 2 : 2959
12:21:53 <--- client 1 : tax n 2 40000
12:21:53 ---> client 1 : 2854
12:21:56 <--- client 2 : tax n 0 60000
12:21:56 ---> client 2 : 11519
12:21:56 <--- client 1 : goodbye
12:21:56 ---> client 1 : Goodbye...
12:21:56 End of service to client 1
12:21:59 <--- client 2 : goodbye
12:21:59 ---> client 2 : Goodbye...
12:21:59 End of service to client 2
12:22:01 Start of service to client 3 (127.0.0.1:52256)
12:22:01 ---> client 3 : Welcome to the tax calculation server
12:22:02 <--- client 3 : help
12:22:02 ---> client 3 : Accepted commands
1-help
2-tax married(Y/N) nbChildren annualSalary
3-goodbye
12:22:03 <--- client 3 : tax y 2 60000
12:22:03 ---> client 3 : 4282
12:22:04 <--- client 3 : TAX N 0 60000
12:22:04 ---> client 3 : 11519
12:22:05 <--- client 3 : tax x 2 60000
12:22:05 ---> client 3 : Incorrect calculation command. Use the help command.
12:22:06 <--- client 3 : tax y 2
12:22:06 ---> client 3 : Incorrect calculation command. Use the help command.
12:22:07 <--- client 3 : tax y -2 60000
12:22:07 ---> client 3 : nbChildren ('-2') must be a non-negative value. (Parameter 'nbChildren') Actual value was -2.
12:22:08 <--- client 3 : calculation
12:22:08 ---> client 3 : Command not recognized. Use the help command.
12:22:09 <--- client 3 : goodbye
12:22:09 ---> client 3 : Goodbye...
12:22:09 End of service to client 3
12:22:12 Start of service to client 4 (127.0.0.1:52306)
12:22:12 ---> client 4 : Welcome to the tax calculation server
12:22:17 <--- client 4 : tax y 2 60000
12:22:17 ---> client 4 : 4282
12:22:17 Server stop requested
12:22:17 Service to client 4 interrupted by the server stop
12:22:17 End of service to client 4
12:22:17 Server stopped
  • Líneas 3–13: el cliente de la primera ejecución. Con la salida de eco, se pueden ver todos los comandos recibidos y todas las respuestas enviadas. Observe el comando [goodbye] (línea 11), enviado por el método [Dispose] de [TaxBusinessTcp] cuando el usuario terminó: la sesión se cerró correctamente;
  • líneas 14–31: los clientes A (cliente 1) y B (cliente 2). El cliente 2 llegó (línea 16) mientras el cliente 1 todavía estaba siendo atendido, y sus solicitudes se procesaron alternadamente a medida que llegaban: el servidor efectivamente atiende a varios clientes de forma simultánea;
  • líneas 32–53: la sesión del cliente TCP genérico;
  • Líneas 54–61: el último cliente, que estaba siendo atendido en el momento del apagado. Ctrl-C canceló el token; las dos operaciones que lo esperaban (la lectura de un comando del cliente 4 y la espera de un nuevo cliente) terminaron con una [OperationCanceledException], en un orden que depende de la planificación de los hilos. El servidor esperó a que terminara el servicio en curso antes de apagarse.

12.9.6. Conclusión

Una vez más, pudimos reutilizar código existente sin modificarlo: las capas [dao] y [business] de la versión 5 del lado del servidor, y la capa [ui] del lado del cliente. Esto fue posible gracias al uso sistemático de interfaces y de la inyección de dependencias: para desplegar la aplicación en dos máquinas, solo fue necesario añadir una capa [server] encima de la capa [business] y proporcionar a la capa [ui] una implementación diferente de [ITaxBusiness]. Si la versión 1 hubiera combinado el cálculo del impuesto y la interacción con el usuario en un mismo programa, nada de esto habría sido reutilizable. Observe que la capa [ui] no sabe que un servidor remoto calcula el monto del impuesto.

Sin embargo, nuestro protocolo propio tiene sus límites: debemos escribir el servidor, administrar las conexiones, analizar los comandos, convertir las respuestas, y un cliente escrito en otro lenguaje tendría que conocer este protocolo específico. La versión 9, en el próximo capítulo, reemplazará el servidor TCP por un servicio web: el protocolo será HTTP, los datos se intercambiarán en JSON y el cliente usará [HttpClient].

12.10. Conclusión

Este capítulo introdujo la programación para Internet con .NET, partiendo de los fundamentos y avanzando hacia clases de alto nivel:

  • la primera parte repasó el funcionamiento de los protocolos de Internet (IP, TCP, UDP, DNS) y de los protocolos de aplicación basados en texto (HTTP, SMTP, POP, FTP), y luego presentó las clases [IPAddress] y [Dns], así como las clases [TcpClient] y [TcpListener], que se usan de forma asíncrona. Con ellas escribimos servidores que atienden a varios clientes simultáneamente, clientes TCP genéricos y un cliente web que se comunicaba “manualmente” con HTTP;
  • la segunda parte presentó clases especializadas para un protocolo. Para HTTP, la clase [HttpClient] reemplaza a las obsoletas [WebClient] y [WebRequest]: logra en una sola instrucción lo que nuestro cliente TCP hacía en cincuenta líneas; maneja redirecciones, formularios, JSON, tiempos de espera y cancelación, y está pensada para reutilizarse entre solicitudes. Para SMTP, la clase [SmtpClient] sigue siendo utilizable, aunque se prefiere la biblioteca MailKit para los desarrollos nuevos;
  • la aplicación de ejemplo se ha convertido en una aplicación cliente/servidor, sin ningún cambio en sus capas existentes.

Los principios de la programación asíncrona vistos en el capítulo 9 han encontrado aquí su aplicación principal: un servidor asíncrono atiende a un gran número de clientes con unos pocos hilos, y un cliente asíncrono espera las respuestas de la red sin bloquear un hilo. Sin embargo, escribir un servidor TCP e inventar su propio protocolo sigue siendo la excepción: hoy en día, la mayoría de las aplicaciones distribuidas se comunican mediante HTTP, usando servicios web que intercambian datos JSON. Este es el tema del próximo capítulo.