Mostrar la caducidad de la licencia en la zona horaria correcta
Una licencia caduca en un único instante de la línea temporal, pero "30 de noviembre" es una fecha civil que depende de dónde estés. Confunde ambas cosas y un cliente en Auckland verá "caducada" en una clave que un cliente en Los Ángeles aún muestra como válida. Este artículo construye la visualización correcta de la caducidad en .NET: almacena la caducidad como un instante en UTC, proyéctalo en la zona horaria del propio espectador con DateTimeOffset y TimeZoneInfo, etiqueta la zona y calcula los "días restantes" de modo que los cambios de horario de verano nunca hagan que un día dure 23 o 25 horas.
Llega un ticket de soporte: un cliente en Auckland dice que tu aplicación informa de que su licencia caducó hoy, pero su recibo de renovación dice claramente que llega hasta final de mes. Compruebas la clave. Está firmada, es suya, y el instante de caducidad está cómodamente en el futuro. Entonces un segundo cliente, en Los Ángeles, con la misma caducidad en su clave, informa de que no tiene ningún problema: su copia dice “caduca mañana”. Ninguna de las dos licencias tiene nada malo. Tu interfaz proyectó un instante sobre dos calendarios distintos.
Esto no es el problema del desfase de reloj, donde dos máquinas discrepan honestamente sobre qué hora es, y no es un atacante retrasando el reloj. Aquí ambos relojes son correctos. El fallo está en cómo la caducidad de Keyright —un instante en UTC— se convierte en una fecha legible para humanos. Este artículo construye esa conversión como es debido.
Un instante no es una fecha
Una licencia de Keyright almacena su caducidad como un único punto en la línea temporal global, en UTC:
public sealed class LicenseInfo
{
public DateTimeOffset ExpiryUtc { get; } // one instant, e.g. 2026-11-30T07:59:59+00:00
// ...
}
DateTimeOffset es el tipo correcto: fija un instante y recuerda que su desfase es cero (UTC). El problema empieza en cuanto intentas mostrarlo a una persona, porque “cuándo caduca esto” tiene dos respuestas honestas distintas. Como instante es un único valor para todos en la Tierra. Como fecha civil —lo que una persona lee en un calendario— depende por completo de dónde esté quien lo lee.
// The bug. Renders the UTC instant as a bare date.
var label = info.ExpiryUtc.ToString("D"); // "Monday, 30 November 2026" — in UTC
Esa etiqueta solo es correcta para un espectador que resulte vivir sobre el meridiano de UTC. Para el cliente de Los Ángeles, el instante 2026-11-30T07:59:59Z es 2026-11-29T23:59:59 local: todavía es 29 de noviembre donde está. Para el cliente de Auckland, el mismo instante es 2026-11-30T20:59:59 local, bien entrado el 30 de noviembre. Formatea el instante como una fecha sin más y le habrás dicho a uno de ellos el día equivocado.
Proyecta el instante en la zona del espectador
La solución es convertir el instante a la zona de quien lo lee y luego formatear. TimeZoneInfo.ConvertTime toma un DateTimeOffset y devuelve un nuevo DateTimeOffset que lleva el desfase de esa zona en ese instante:
public static string FormatExpiry(DateTimeOffset expiryUtc, string viewerZoneId)
{
// viewerZoneId is an IANA id such as "Pacific/Auckland" or "America/Los_Angeles".
var zone = TimeZoneInfo.FindSystemTimeZoneById(viewerZoneId);
var local = TimeZoneInfo.ConvertTime(expiryUtc, zone);
// Include the zone so the date is unambiguous to the reader.
return $"{local:dddd, d MMMM yyyy 'at' h:mm tt} ({zone.Id})";
// Auckland -> "Monday, 30 November 2026 at 8:59 PM (Pacific/Auckland)"
// Los Angeles -> "Sunday, 29 November 2026 at 11:59 PM (America/Los_Angeles)"
}
Dos cosas hacen que esto sea correcto. Primero, ConvertTime sobre un DateTimeOffset siempre está bien definido: proyectar un instante hacia una zona nunca puede ser ambiguo, porque un instante es un único punto y toda zona tiene exactamente una representación local de él. (La ambigüedad del horario de verano solo muerde en el sentido contrario, al convertir una hora de reloj tecleada de vuelta en un instante: una trampa para la interfaz de administración que fija una caducidad, no para el cliente que la muestra.) Segundo, etiquetar la zona hace que ninguno de los dos clientes pueda malinterpretar la fecha: “29 de noviembre (America/Los_Angeles)” y “30 de noviembre (Pacific/Auckland)” son ambas ciertas, y ahora describen visiblemente el mismo momento.
Desde .NET 6, FindSystemTimeZoneById acepta ids de IANA como America/Los_Angeles tanto en Windows como en Linux y macOS, porque el runtime usa ICU e incluye la correspondencia IANA-a-Windows. Almacena un único id canónico de IANA por usuario —es exactamente lo que informa un navegador desde Intl.DateTimeFormat().resolvedOptions().timeZone— y resuélvelo de forma idéntica allá donde se ejecute tu código. Nunca almacenes un desfase numérico pelado: un desfase no sabe cuándo empieza el horario de verano, así que un valor de -08:00 guardado en invierno sencillamente es incorrecto para un cliente de Los Ángeles todo el verano.
Los “días restantes” son dos preguntas distintas
El aviso de caducidad suele decir también cuánto queda, y aquí hay un segundo lugar donde la respuesta ingenua se desvía. Decide qué pregunta estás respondiendo, porque a través de una transición de horario de verano dan números distintos.
Una duración —“quedan 4 días y 3 horas”— es la distancia real entre dos instantes. Resta directamente los valores DateTimeOffset:
TimeSpan remaining = info.ExpiryUtc - DateTimeOffset.UtcNow; // exact elapsed time
Un recuento de calendario —“caduca el día 30, que es dentro de 3 días”— trata de fechas civiles en la zona del espectador, y debe calcularse sobre las fechas, no sobre una duración en bruto:
static int CalendarDaysUntilExpiry(DateTimeOffset expiryUtc, TimeZoneInfo zone)
{
var expiryLocalDate = TimeZoneInfo.ConvertTime(expiryUtc, zone).Date;
var todayLocalDate = TimeZoneInfo.ConvertTime(DateTimeOffset.UtcNow, zone).Date;
return (expiryLocalDate - todayLocalDate).Days; // whole calendar days in the viewer's zone
}
El atajo tentador —(int)(remaining.TotalDays) o remaining.Days— es incorrecto precisamente los días que importan, los que rodean un cambio de reloj. El día del adelanto de primavera un día local de calendario dura solo 23 horas, y en el atraso de otoño dura 25. Divide un TimeSpan entre 24 horas planas a través de uno de esos días y caerás un día antes o un día después. Recortar ambos instantes a su .Date local primero esquiva el problema por completo: la resta de fechas de medianoche a medianoche cuenta días de calendario sin importar cuántas horas tuviera realmente cada día.
Cuándo se rompe, y qué vigilar
Tres advertencias honestas. Primera, la base de datos de zonas cambia: los gobiernos modifican las reglas del horario de verano, y una caducidad futura que renderizas hoy puede desplazarse una hora en cuanto se actualice la tzdata del host, que es otra razón por la que el instante es la fuente de verdad y la proyección local es solo una vista. Segunda, resuelve la zona del espectador de forma deliberada: prefiere la zona del perfil guardado del usuario, recurre a lo que informa el navegador y nunca uses en silencio la zona del servidor, que es el fallo original con otro disfraz. Tercera, no hagas un ida y vuelta a través de una cadena local: si alguna vez persistes local.DateTime con Kind == Unspecified y lo vuelves a leer, has perdido el instante, y ninguna conversión posterior puede recuperar qué desfase estaba en vigor.
La conclusión
La caducidad de una licencia es un instante en la línea temporal; la fecha que lee una persona es ese instante visto desde algún lugar. Mantén el valor firmado en UTC como un DateTimeOffset, conviértelo a la zona de IANA del espectador con TimeZoneInfo solo en el momento de renderizar, y escribe siempre la zona junto a la fecha para que dos clientes separados por un océano puedan ver que “el 29 aquí” y “el 30 allí” son el mismo momento. Calcula una cuenta atrás a partir de la diferencia de instantes, pero calcula los “días restantes” a partir de la resta de .Date locales para que un día de horario de verano de 23 o 25 horas nunca descuadre tu aviso en uno. Acierta esas dos conversiones y el ticket de Auckland nunca se abre.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.