Años atrás, en los inicios de la informática, se programaba de forma bastante diferente: conectando cables y usando paneles de interruptores. Por eso me ha parecido muy curioso el simulador del Minivac 601, un ordenador de los años 60,  donde podemos probar de primera mano cómo era su experiencia de uso.

Y continuando con temas vintage, Microsoft ha anunciado la liberación del código fuente de los juegos Zork I, II y III, la mítica saga de aventuras conversacionales de los años 80. Pura historia del software.

También esta semana encontramos una interesante lectura de Sudhir Mangla donde explica cómo usar patrones modernos y características recientes de C# para construir modelos más expresivos, seguros y mantenibles que los que ofrece la aplicación estricta de SOLID.

El resto de enlaces interesantes recopilados esta semana, entre los que podéis encontrar información sobre .NET 10, ASP.NET Core, IA, desarrollo web y mucho más, los tenéis a continuación.

Por si te lo perdiste...

• Creando GUIDs con orden natural en .NET 9
  José M. Aguilar
• Localizar errores de validación del binding en ASP.NET Core MVC
  José M. Aguilar

.NET

• Introducing C# 14
  Uwe Keim
• Introducing F# 10
  Adam Boniecki
• Exploring C# File-based Apps in .NET 10
  Milan Jovanović
• How to Upgrade to .NET 10 LTS - Complete Guide for .NET Global Tools with Multi-Targeting
  John Smith
• Post-Quantum Cryptography in .NET
  Jeremy Barton
• Reinventing how .NET Builds and Ships (Again)
  Gábor Szabó
• Companies complaining .NET moves too fast should just pay for post-EOL support
  Andrew Lock
• .NET 10 Testing: Microsoft Finally Fixed the Test Runner (Mostly)
  Martin Stühmer
• Optimize GUID creation performance in .NET applications
  Gérald Barré
• How to Update .NET on Wsl or Ubuntu
  Steve Smith
• No more public partial class Program in .NET 10
  Steven Giesel
• Streamlining Remote C# Scripts with .NET 10 runfile
  Daniel Cazzulino
• A Practical Approach to DI Variation in .NET: Introducing Child Service Providers
  Fernando Escolar
• State of Native AOT in .NET 10
  Peter Ritchie

Hace unos días se lanzó .NET 10 y, con él, C# 14, una nueva versión del lenguaje que viene con varias novedades interesantes que mejoran la productividad y la experiencia de desarrollo.

Las más destacables son:

• Miembros extensores
• Asignaciones condicionales
• Propiedades semi-automáticas
• Simplificación del uso de nameof con tipos genéricos
• Eventos y constructores parciales
• Conversiones implícitas para Span<T> y ReadOnlySpan<T>
• Simplificación de parámetros de lambdas

Les damos un vistazo rápido a continuación.

La semana pasada, sin duda el protagonismo se lo ha llevado el lanzamiento de .NET 10, con multitud de artículos que repasan los cambios y características introducidas en esta versión, aunque hay mucho más.

En primer lugar, destacamos el artículo de CampusMVP: .NET 10 - Informe técnico para desarrolladores: novedades y mejoras importantes, imperdible para ponernos rápidamente al día.

También OpenAI ha publicado interesantes artículos, uno sobre los problemas de seguridad que supone el uso de prompt injection, y otro sobre el uso de una nueva técnica que mejora la interpretabilidad de las redes neuronales, algo difícil de conseguir con los modelos tradicionales. Y bueno, ha aprovechado también presentar su nuevo modelo GPT-5.1.

Por último, destacar el artículo de Sudhir Mangla sobre gestión de memoria en .NET, que repasa conceptos clave como stack, heap, Span<T>, Memory<T>, ArrayPool y otros temas que debemos conocer para crear aplicaciones .NET de alto rendimiento.

Por si te lo perdiste...

• Registro y obtención de servicios con nombre (keyed services) en .NET
  José M. Aguilar
• Cargar automáticamente objetos del modelo en acciones ASP.NET Core MVC
  José M. Aguilar

.NET

• Announcing .NET 10
  Mark Adamson
• .NET 10 - Informe técnico para desarrolladores: novedades y mejoras importantes
  CampusMVP
• Implementando Azure Service Bus con Clean Architecture
  Gerson Azabache Martínez
• What′s new in .NET 10
  nullGeorgii Tormozov
• How to Target Excel Metadata in C# for Smarter Document Management
  Mohan Chandran
• Scanning .NET Assemblies for References & Isolator with References Scanning
  Ricardo Peres
• Mocking Statics in .NET - We Made the Impossible Possible
  Eli Lopian
• Capturing Console Output in xUnit.v3
  Steven Giesel
• Modern .NET Reflection with UnsafeAccessor
  NDepend Team
• .NET 10 and the Release Cycle Paradox & .NET 10: Timing Is the New Technical Debt
  Martin Stühmer
• New Features in .NET 10 and C# 14
  Anton Martyniuk
• Missing Security Features in .NET 10
  Khalid Abuhakmeh
• Working with Excel files in .NET: OpenXML vs EPPlus vs ClosedXML
  Ali Hamza Ansari
• .NET 10: What’s New for Authentication and Authorization
  Andrea Chiarelli
• C# 14 Extension Members: Enhancing Polyfill Libraries
  Gérald Barré
• Unlocking Collection Expressions for your own types
  Bart Wullems
• Syncfusion Delivers Day-1 Support for .NET 10 Across UI Components and Document Libraries
  Meena Alagiah
• Memory Management Masterclass: Stack vs Heap, Span<T>, Memory<T>, and ArrayPool in High-Performance C#
  Sudhir Mangla
• Are C# 14's new features worth updating your app to .NET 10?
  David Grace
• Use TimeSpan Or Specify Units In Duration Properties And Parameters
  Steve Smith
• .NET 10: Boring by Design, Reliable by Default
  Martin Stühmer

La obsesión por los tipos primitivos es un code smell bastante común en el desarrollo de software. Gerson Azabache nos explica cómo los Value Objects en .NET pueden ayudarnos a combatir este problema.

Decidir qué framework de frontend nos conviene aprender siempre es una tarea complicada. Para ayudarnos con esto, José Manuel Alarcón ha preparado una comparativa detallada entre React, Angular, Vue.js y Svelte.

El servidor MCP de Azure permite que agentes o aplicaciones basadas en IA interactúen con los recursos que gestionamos en la nube. Juan Irigoyen da un vistazo a esta herramienta en su artículo.

Daniel Roth nos cuenta cómo Copilot Studio utiliza .NET y WebAssembly para mejorar el rendimiento en este entorno low-code.

Estos, y muchos más enlaces a contenidos interesantes, a continuación.

Por si te lo perdiste...

• Quizás no estés comparando con null de forma totalmente correcta
  José M. Aguilar
• Novedades de System.Text.Json en .NET 9
  José M. Aguilar

.NET

• Value Objects en .NET: la cura contra el code smell Primitive Obsession
  Gerson Azabache Martínez
• Interesting new C# 14 features coming with .NET 10
  Thomas Levesque
• Modern Defensive Programming in .NET — Unified Throw-Helpers and Multi-Framework Compatibility
  Martin Stühmer
• How Copilot Studio uses .NET and WebAssembly for performance and innovation
  Daniel Roth
• Easier reflection with [UnsafeAccessorType] in .NET 10
  Andrew Lock
• Define a default startup project in your slnx file
  Mark Downie
• A Modern Guide to Using OAuth 2.0 with C# and Visual Studio Code
  Dean Hume
• ArrayPool Benchmarks: We have a problem
  Steven Giesel
• Stop Breaking Multi-Targeting Builds with String Comparisons
  Martin Stühmer
• C# 14: The Null-conditional Assignment – Thomas Claudius Huber
  Thomas Claudius Huber
• .NET 10 Breaking Changes To Keep An Eye On When Upgrading
  Khalid Abuhakmeh

Si, por curiosidad o necesidad, alguna vez has abierto un archivo de solución de Visual Studio (.sln) con un editor cualquiera, habrás comprobado que se trata de un archivo de texto plano.

Su estructura, aunque no es excesivamente compleja y está bien documentada, es propietaria de Visual Studio y no es evidente a simple vista, resulta demasiado verbosa, tiene mucha información irrelevante duplicada y, en general, no es nada amigable para los desarrolladores que se ven obligados a modificarla, sobre todo cuando se trata de resolver conflictos en sistemas de control de versiones. Y, por supuesto, es algo que se agrava conforme crece el número de proyectos en la solución.

Esto llevó a Microsoft a presentar hace unos meses el nuevo formato de archivo de solución .slnx, una alternativa basada en XML mucho más ligera, concisa y fácil de entender, que será el utilizado por defecto a partir de la llegada de .NET 10.

Lo vemos en profundidad a continuación.

Esta semana, en la recopilación de enlaces encontramos el interesante repaso de Ricardo Peres a algunas técnicas para optimizar el trabajo con cadenas de texto en .NET en búsquedas, formateo, extracción de subcadenas y uso de interning.

Vale la pena también echar un vistazo a la notación de objetos orientada a tokens (TOON) propuesta por Johann Schopplich para reducir significativamente el coste en tokens al enviar datos estructurados (como JSON) a modelos de lenguaje.

Isaac Ojeda nos muestra cómo utilizar channels y servicios de .NET para crear un sistema de control de tareas en segundo plano, muy interesante.

E imperdible el detallado análisis de Andrew Lock sobre la grave vulnerabilidad "request smuggling" en ASP.NET Core, calificada con una puntuación de 9.9, la más alta hasta la fecha.

El resto de contenidos, a continuación.

Por si te lo perdiste...

• ¿Aplicar [Authorize] a todos los controladores MVC de una carpeta?
  José M. Aguilar
• No se puede conectar al servidor web 'https', el servidor web ya no funciona y otras pistas de que no has lanzado correctamente tu aplicación ASP.NET Core
  José M. Aguilar

.NET

• Sistema de Control de Jobs en Tiempo Real con Channels y Background Services en .NET
  Isaac Ojeda
• Cómo implementar Redis en Clean Architecture utilizando .NET
  Gerson Azabache Martínez
• Thread-Safe Initialization with LazyInitializer
  Gérald Barré
• Using SignalR with Wolverine 5.0
  Jeremy D. Miller
• Akka.NET + Kubernetes: Everything You Need to Know
  Aaron Stannard
• Are you still using new Random() everywhere?
  Steven Giesel
• Building Dropbox in .NET: Chunked Uploads, Merkle Trees, and Cloud Architecture for Petabyte-Scale Sync
  Sudhir Mangla
• Working with Strings in .NET
  Ricardo Peres
• Load Testing Kafka Pipelines with C# and NBomber
  Anton Martyniuk
• How to Import, Export, and Filter PDF Annotations in C#
  Chinnu Muniyappan
• Distributed Isolator
  Ricardo Peres
• PackageDownload: NuGet's Forgotten Power Tool
  Martin Stühmer
• Distributed ID Generation at Scale in .NET: From Snowflake to ULID and Beyond
  Sudhir Mangla
• Your Tests Are Lying — Mutation Testing in .NET
  Martin Stühmer
• Grammarly in .NET: Real-Time Grammar Checking, Context-Aware Suggestions, and Processing 1 Billion Words Daily
  Sudhir Mangla
• Catching dependency injection configuration errors early
  Bart Wullems
• What’s new in .NET 10
  Denis Makarenko

Los dev tunnels permiten exponer, permanente o temporalmente, aplicaciones web locales a Internet de forma segura y sencilla desde Visual Studio. Son ideales para desarrollo y pruebas y, si nos los conoces, deberías echar un vistazo al post de Mike Irving, donde explica cómo usarlos.

Derek Comartin reflexiona sobre la ubicación adecuada para implementar la autorización en nuestras aplicaciones: ¿debería estar en la capa de dominio o en la capa de aplicación? Una lectura muy recomendable para entender mejor este aspecto crucial del diseño de software.

A pesar del miedo generalizado a que la inteligencia artificial (IA) destruya empleos tecnológicos, la realidad es muy distinta. Desde CampusMVP nos llega un artículo que desmonta este mito y da pistas sobre cómo los profesionales podemos adaptarnos en esta nueva era.

Gerson Azabache nos habla sobre el concepto "idempotencia" y su importancia en la ingeniería de software moderna. Un principio clave para garantizar la confiabilidad y robustez de nuestras aplicaciones. No te pierdas su análisis.

Estos, y muchos más enlaces a artículos interesantes, a continuación.

Por si te lo perdiste...

• BenchmarkDotNet: Arañando microsegundos en proyectos .NET Core o .NET Framework
  José M. Aguilar
• Tuplas como variables de control en bucles "for" de C#
  José M. Aguilar

.NET

• Introducing Isolator - a framework for running isolated code for .NET
  Ricardo Peres
• Inlining and structs in C#
  Steven Giesel
• xUnit v3 update: Ability to skip tests & a new TestContext
  David Grace
• RestClient.Net 7: Compile-Time Safety and OpenAPI MCP Generation
  Christian Findlay
• Understanding When Type.FullName Returns Null in .NET
  Gérald Barré
• Using profiler function hooks in .NET with Silhouette
  Kevin Gosse
• Practical OOP in Modern C#: Composition Over Inheritance, Records, and Pattern Matching
  Sudhir Mangla
• Announcing Sponsorship on NuGet.org
  Simon Cropp
• Upgrading to Microsoft Agent Framework in Your .NET AI Chat App
  Bruno Capuano
• Boxing in C#: What It Costs You and How to Get Rid of It
  NDepend Team
• Modern C# Design Patterns You Should Actually Use in 2025
  Vahid Bakhtiary
• Modern C# Design Patterns You Should Actually Use in 2025
  Vahid Bakhtiary
• C# 14: The field Keyword – Or Should I Say: I Had a Dream?
  Thomas Claudius Huber
• The Evolution of .NET Dependency Resolution
  Ricardo Peres
• ConstantExpectedAttribute: Unlocking Performance Through Compiler Awareness
  Martin Stühmer

Los métodos extensores aparecieron con C# 3.0, hace casi veinte años. Desde entonces, se han convertido en una herramienta muy útil para los desarrolladores de C#, permitiéndonos "añadir" métodos a tipos existentes sin modificar su código fuente ni crear un nuevo tipo derivado. Sin embargo, desde aquella lejana versión, este mecanismo no había sufrido cambios significativos.

Con la llegada de C# 14 y .NET 10, el concepto de extensión se ha hecho mucho más ambicioso. Como veremos a continuación, no solo es posible definir métodos extensores, sino también propiedades y otros tipos de miembros, tanto de instancia como estáticos. Además, la sintaxis se ha mejorado para hacerla más clara y fomentar la cohesión entre los distintos miembros de extensión que implementemos para un mismo tipo de datos.

Lo vemos a continuación.

Amit Bahree está escribiendo una serie de artículos sobre cómo construir un modelo de lenguaje grande (Large Language Model, LLM) desde cero. En la primera publicación hace una introducción y en la segunda habla sobre la recopilación de datos y los tokenizadores personalizados. Muy recomendable si te interesa el tema de la inteligencia artificial más allá de utilizar APIs de terceros.

Raymond Chen desvela por qué, en versiones antiguas de Windows, al tomar una captura de pantalla de un vídeo y pegarla en Paint, el vídeo se reproducía dentro de esta aplicación. Todo un misterio que por fin queda resuelto, y el motivo es cuanto menos curioso.

Y también bastante curioso el post de MaiZure analizando en profundidad el código de Altair BASIC 3.0, recientemente publicado por Bill Gates para celebrar el 50 aniversario de Microsoft.

El resto de contenidos, a continuación...

Por si te lo perdiste...

• Problem Details: una forma estándar de retornar errores desde APIs HTTP (y cómo usarlo desde ASP.NET Core)
  José M. Aguilar
• Cómo mostrar una página de error 404 personalizada en una Blazor Web App
  José M. Aguilar

.NET

• Announcing .NET 10 Release Candidate 2
  Frank Krueger
• Announcing the .NET Security Group
  Jamshed Damkewala
• TickerQ: The Modern .NET Job Scheduler That Beats Quartz and Hangfire
  Anton Martyniuk
• How .NET 10.0 boosted JSON Schema performance by 18%
  Ian Griffiths
• Testing with FakeLogger — Scopes
  Adam Storr
• Use fixtures in xUnit for shared context in unit tests
  David Grace
• How .NET Garbage Collector works (and when you should care)
  Ali Hamza Ansari
• Mastering the C# Dispose Pattern
  Ivan Kahl
• What’s New in the AWS Deploy Tool for .NET
  Philippe El Asmar
• .NET 10: Run Standalone C# Files Without Project
  Thomas Claudius Huber
• Top 8 C# PDF Libraries .NET Developers Can’t Miss in 2025
  Ramkumar Ravy
• LINQ and Learning To Be Declarative
  Nick Stambaugh
• Taking Multi-Model AI Orchestration Further: Azure AI Foundry Persistent Agents in .NET 9
  Bruno Capuano

Te propongo un experimento: abre un documento en blanco con el block de notas y anota todas las unidades de medida de CSS que se te ocurran (por ejemplo, px, em, etc.) Luego, cuéntalas... ¿cuántas has recordado? Yo nueve, entre las que había una inventada 😕 Por eso me ha llamado la atención el artículo de Nikolaus Gebhardt en el que recopila las ¡42! unidades de medida que define CSS.

Una lectura de interés también el artículo Ricardo Peres explica cómo restringir el acceso a un método de acción en ASP.NET Core MVC utilizando el filtro [Authorize], atributos de autorización personalizados, políticas y otros mecanismos proporcionados por el framework.

Por último, Juan Irigoyen nos muestra una metodología práctica para generar código con IA usando prompts estructurados en formato Markdown.

El resto de contenidos interesantes recopilados durante la semana pasada, a continuación.

Por si te lo perdiste...

• C# bizarro, episodio 5: ¿cuál es la salida de este código?
  José M. Aguilar
• El filtro [ApiController] en ASP.NET Core MVC
  José M. Aguilar

.NET

• Rx.NET v6.1 Now Available
  Ian Griffiths
• What .NET 10 GC Changes Mean for Developers
  Roxeem
• Introducing XAML.io Preview v0.5— Visual .NET Development, Instantly in Your Browser
  OpenSilver
• No More Mocking ILogger
  Adam Storr
• Use CancellationTokens
  Steven Giesel
• xUnit advanced Assert methods: Throws, IsType + more
  David Grace
• .NET 10: The Deathblow to Python’s AI Dominance?
  DeeDee Walsh
• Interesting new C# 14 features coming with .NET 10
  Thomas Levesque
• The 3 C# PDF Libraries Every Developer Must Know
  Anton Martyniuk
• Modern .NET or .NET Framework: Which Should Developers Choose in 2025?
  Jeyasri Murugan
• Automatic Mappings with AutoMapper
  Ricardo Peres
• How to Find an Available Network Port for a server in .NET
  Gérald Barré
• Announcing a new OData.NET serializer
  Erik Ejlskov Jensen
• Pass the State
  Szymon Kulec
• TUnit — A Pragmatic Evaluation for .NET Teams
  Martin Stühmer

Llevamos utilizando la clase Random de .NET para generar números aleatorios desde hace mucho tiempo, en su aparición con la versión 1.1 de .NET Framework (año 2002). Probablemente por eso, muchos de nosotros la usamos de forma automática, sin pararnos a estudiar todas sus posibilidades y las novedades que le han ido añadiendo a lo largo del tiempo.

En este artículo vamos a ver algunas características de la clase Random que quizás no conocías... o quizás sí, pero que no está de más refrescarlas:

• Los números generados no son realmente aleatorios.
• En versiones antiguas de .NET, era más probable que Random generara números impares.
• No se debe usar Random para operaciones criptográficas.
• No es buena idea crear un objeto Random cada vez que necesitemos un número aleatorio.
• Si estamos en .NET 6+, mejor usar Random.Shared.
• El método Shuffle() desordena arrays.
• El método GetItems() permite obtener elementos aleatorios de una colección.
• Podemos heredar de Random.

¡Vamos a ello!

Aquí están los enlaces recopilados durante la semana pasada 😊

Entre los contenidos destacables, una pregunta: ¿somos conscientes del coste real de las operaciones de boxing y unboxing en .NET? Normalmente no las tenemos en cuenta, pero pueden llegar a ser importantes, y podemos aprender a detectarlas y evitarlas. Ali Hamza Ansari nos lo explica en su artículo.

También, Anton Martyniuk ha recopilado en este post una serie de paquetes NuGet que pueden mejorar tu productividad y la calidad de tus proyectos si usas Entity Framework Core.

Y Addy Osmani nos cuenta la historia, evolución y futuro de Core Web Vitals, los indicadores de rendimiento web que Google utiliza para medir la experiencia de usuario en las páginas web. Muy interesante.

El resto, a continuación...

Por si te lo perdiste...

• Renderizar componentes Blazor en vistas MVC (3/3): componentes interactivos WebAssembly
  José M. Aguilar
• El tipo de retorno ActionResult<T> en ASP.NET Core
  José M. Aguilar

.NET

• xUnit Assert basics: True/False, Equal, Same, Matches
  David Grace
• Hidden Costs of Boxing in C#: How to Detect and Avoid Them
  Ali Hamza Ansari
• Why Microsoft Won't Revive WinForms (And What Developers Are Using Instead
  Matt Mattei
• Is .NET 10 for AI Replacing Python?
  Prayag Vakharia
• Your HTML Comments Are More Powerful Than You Think: Building Custom Validation Grammars with HtmlAgilityPack
  Aaron Stannard
• Wasm 3.0 for .NET Developers
  Sam Basu

Ya he publicado en mi blog la colección de enlaces a contenidos interesantes de la semana pasada 🙂

Para destacar, Milan Jovanović nos habla sobre el problema que surge al intentar coordinar tareas que se ejecutan en distintos procesos o instancias, algo que escapa al alcance de los mecanismos de sincronización tradicionales como mutex, locks o semáforos de .NET, y algunas fórmulas para resolverlo.

Andrew Lock comparte los detalles del desarrollo de 'sleep-pc', una pequeña herramienta de línea de comandos que permite poner el PC a dormir después de un tiempo determinado. Usa .NET Native AOT y es instalable directamente desde NuGet.

Y por último, David Grace nos explica los distintos atributos que xUnit pone a nuestra disposición para proporcionar datos a los tests, y las diferencias entre ellos.

El resto, a continuación.

Por si te lo perdiste...

• Renderizar componentes Blazor en vistas MVC (2/3): componentes interactivos en servidor
  José M. Aguilar
• Generar redirecciones HTTP 307 y 308 en ASP.NET Core MVC
  José M. Aguilar

.NET

• Building Resilient Email Delivery Systems: SendGrid vs Azure Communication Services with Polly in .NET
  Sudhir Mangla
• Distributed Locking in .NET: Coordinating Work Across Multiple Instances
  Milan Jovanović
• How to use InlineData, MemberData and ClassData in xUnit
  David Grace
• sleep-pc: a .NET Native AOT tool to make Windows sleep after a timeout
  Andrew Lock
• Migrating a Modular Monolith to Microservices in .NET: Step-by-Step Guide
  Anton Martyniuk
• Batch migrate .sln files to .slnx format across repositories
  Gérald Barré
• Expression Trees in C#: Building Dynamic LINQ Queries at Runtime
  Ali Hamza Ansari
• Flow: A Pragmatic Approach to Composable Business Logic in C#
  Bahman Movaqar
• Auto update the .NET core versions on your server
  Bart Wullems
• Preparing for the .NET 10 GC. In .NET 9 we enabled DATAS by default…
  Maoni Stephens
• Exploring Text-to-Image capabilities in .NET
  Jeremy Likness
• MassTransit and RabbitMQ in .NET: Building Fault-Tolerant Microservices
  Sudhir Mangla
• Some Thoughts on MS Pulling Back on their “Eventing Framework”
  Jeremy D. Miller

Hace algún tiempo hablamos sobre el atributo [MemberNotNullWhen] y vimos cómo se podía usar para mejorar la seguridad frente a valores nulos en nuestras aplicaciones.

Como recordaréis, este atributo lo aplicábamos sobre miembros booleanos para asegurar que otro miembro de su misma clase no contendrá null, dependiendo del valor (true o false) del primero. El ejemplo que lo ilustraba era el siguiente:

public class Result<T>
{
    [MemberNotNullWhen(true, nameof(Value))]  // Si Success es true, Value no es null
    [MemberNotNullWhen(false, nameof(Error))] // Si Success es false, Error no es null
    public bool Success { get; init; }

    public string? Error { get; init; }
    public T? Value { get; init; }

    // Constructores, factorías, etc
}

Pero también comentamos que existían muchos otros atributos que el compilador empleaba para afinar en la detección de posibles problemas similares en el código. Al usarlos, el compilador comprende mejor las intenciones de nuestro código respecto a la utilización de nulos, y puede generar advertencias que impiden posteriores errores en tiempo de ejecución, pero sólo cuando son estrictamente necesarias.

En este nuevo post, vamos a echar un vistazo a los siguientes:

• [NotNullWhen]
• [NotNullIfNotNull]
• [MemberNotNull]

Vamos con una nueva colección de enlaces a contenidos de interés que he ido recopilando durante la última semana.

Destacamos, en primer lugar, el anuncio de que las versiones STS (Soporte a Largo Plazo) de .NET pasarán a tener 24 meses de soporte en lugar de los 18 actuales, comenzando ya con .NET 9. Una buena noticia para todos aquellos que preferimos estabilidad y no estar actualizando constantemente.

Interesante el post de Ali Hamza Ansari sobre el uso de "async void" en C# y por qué es peligroso, aunque también explica cuándo es aceptable usarlo.

A tener en cuenta asimismo el anuncio de la especificación final WebAssembly 3.0, que trae varios cambios importantes, como el direccionamiento de 64 bits, mejoras en gestión de la memoria y rendimiento, manejo de excepciones y otras.

Y Google ha anunciado Agent Payments Protocol (AP2), un protocolo abierto para facilitar el pago a través de agentes de IA de forme segura y verificable, buscando estandarizar el comercio automatizado 😱 

En resto, a continuación.

Por si te lo perdiste...

• Renderizar componentes Blazor en vistas MVC (1/3): componentes estáticos (SSR)
  José M. Aguilar
• ¿Aún usas ToString() para obtener el nombre de los elementos de un enum?
  José M. Aguilar

.NET

• .NET STS releases supported for 24 months
  Jamshed Damkewala
• Putting Lazy Tasks in a Cache, and Computing Only Once, When First Requested
  Bryan Hogan
• Writing your own batched sink in Serilog
  Bart Wullems
• Compress HttpClient requests with GZIP
  Josef Ottosson
• .NET 10 Release 1: Performance Boosts, Security Upgrades, and Smarter AI
  DeeDee Walsh
• Application Insights Code Optimizations for .NET Apps
  Chuck Weininger
• Supporting platform-specific .NET tools on old .NET SDKs
  Andrew Lock
• Demystifying async void in C#: Why It's Dangerous and When It's Okay
  Ali Hamza Ansari
• Migrating from XUnit v2 to v3
  Bart Wullems
• Moving off of TypeScript. We Love You, TypeScript
  Chander Ramesh
• Morse Code Messages with C#
  Bryan Hogan
• How to Generate Images in .NET 9
  Mahesh Chand

Pues ya estamos aquí, inaugurando la nueva temporada con más de 80 enlaces a contenidos interesantes que he recopilado las semanas anteriores, entre los que hay bastante material para destacar 🙂

Empezamos por el post del equipo de NDepend, donde nos muestran la pinta que podrían tener los esperados tipos unión en C#. Todavía queda para verlos, llegarían con la versión 15 (noviembre de 2026), pero está bien echarles el ojo para interiorizarlos e ir descubriendo su potencia. 

Seguimos con C#, porque el lenguaje que tanto usamos los desarrolladores .NET está cambiando. Andrew Lock explora los miembros de extensores de C# 14, una de las grandes novedades de la próxima versión de .NET (noviembre 2025).

Khalid Abuhakmeh aporta algunos trucos interesantes para optimizar la velocidad de carga en sitios ASP.NET Core, aunque los consejos en realidad son válidos para casi cualquier tecnología.

Vía Miguel Durán descubrimos el repositorio de Ásgeir Thor Johnson donde recopila los prompts de sistema de chatbots populares, como ChatGPT, Claude o Gemini. Aparte de lo curioso que resulta su lectura, lo más importante es que de momento no aparecen órdenes como "dominar a la humanidad" ni nada parecido, así que podemos estar tranquilos 😉

Interesante también el nuevo posicionamiento por anclaje en CSS que nos muestra Ahmad Shadeed, la propiedad position-anchor. Aunque aún no está disponible en todos los navegadores, está bien conocer su existencia porque proporciona una solución sencilla al habitual problema de ubicar un elemento respecto a la posición de otro.

Damos la bienvenida a Visual Studio 2026, aún en versión para insiders, pero que ya podemos probar. Mads Kristensen nos cuenta las novedades más importantes.

Estaba al caer, y ya llegó, el tradicional megapost de Stephen Toub sobre las mejoras de rendimiento en la próxima versión de .NET. Como siempre, muy interesante para conocer en qué se ha trabajado y qué podemos esperar de la próxima versión.

Chrome, el browser que cambió la forma de navegar por la web, acaba de cumplir 17 años, y Addy Osmani aprovecha para contarnos su origen, los objetivos que han guiado su evolución y los retos que afronta en la era de la IA.

Y muy loco el post de Lukas Vogel, que ha implementado DOOMQL, un juego de disparos multijugador al estilo DOOM, pero usando únicamente SQL. Sí, has leído bien, SQL.

El resto, a continuación...

Por si te lo perdiste...

• Renderizar componentes Blazor en vistas MVC (1/3): componentes estáticos (SSR)
  José M. Aguilar
• ¿Aún usas ToString() para obtener el nombre de los elementos de un enum?
  José M. Aguilar

.NET

• Announcing .NET 10 Release Candidate 1
  Rod Macdonald
• The Hidden Gems of .NET 10: Lesser-Known Features That Will Transform Your Development
  DeeDee Walsh
• C# 14 extension members; AKA extension everything
  Andrew Lock
• GPT-OSS - A C# Guide with Ollama
  Bruno Capuano
• Converting an xUnit test project to TUnit
  Andrew Lock
• Enhance your CLI testing workflow with the new dotnet test
  Mariam Abdullah
• Nullable vs nullable in C#
  Einar W. Høst.
• C# 15 Unions
  NDepend Team
• The Value of Custom Exceptions
  Peter Ritchie
• Mastering Incremental Source Generators in C# Complete Guide
  Ali Hamza Ansari
• How to Hash Passwords with BCrypt in C#
  Claudio Bernasconi
• Using and authoring .NET tools
  Andrew Lock
• .NET HttpClient and Delegating Handlers
  Khalid Abuhakmeh
• Load Testing Microservices With C# and NBomber
  Anton Martyniuk
• Packaging self-contained and native AOT .NET tools for NuGet
  Andrew Lock
• Add API key authentication to an Minimal API endpoint
  David Grace
• Performance Improvements in .NET 10
  Stephen Toub
• C# Magical Syntax
  Ricardo Peres

Hace pocas semanas vimos lo sencillo que era realizar esperas asíncronas usando el operador await de C# sobre prácticamente cualquier tipo de objeto. Además de los ejemplos en los que trabajamos, una extensión interesante sería poder esperar hasta una fecha/hora concreta de forma concisa, por ejemplo así:

await Until(2025, 09, 15);

En este post, que además ejercerá de cierre oficial de la temporada, vamos a ver cómo podríamos hacer posible esto usando algunas características de C# que hemos visto en otros posts a lo largo del tiempo: directivas using globales, uso de miembros estáticos y awaiters personalizados.

Para conseguirlo, en primer lugar debemos escribir un par de métodos estáticos relacionados sobre el tipo TimeSpan:

• El primero de ellos, un método estático estándar al que llamaremos Until(), nos permitirá obtener el tiempo que falta hasta la fecha que le pasemos como parámetro.
• El segundo, como vimos en el post anterior, es el extensor GetAwaiter() que nos permitirá usar await sobre el tipo TimeSpan. Si queréis ver más detalles de esto, podéis volver a ojear dicho artículo.

El código podría ser el siguiente, en el archivo TimeSpanExtensions.cs:

public static class TimeSpanExtensions
{
    public static TimeSpan Until(int year, int month, int day,
        int hour = 0, int minute = 0, int second = 0)
    {
        var targetDate = new DateTime(year, month, day, hour, minute, second);
        return targetDate - DateTime.Now;
    }

    public static TaskAwaiter GetAwaiter(this TimeSpan value)
    {
        return Task.Delay(value).GetAwaiter();
    }
}

Simplemente con añadir este clase a nuestro proyecto, pondremos a disposición de otros puntos el método Until() para ser utilizado de la siguiente forma:

await TimeSpanExtensions.Until(2025, 09, 15);

Pero no era esto lo que queríamos, ¿verdad? Aquí es cuando entran en juego las directivas using globales y el uso de miembros estáticos. Si insertamos en el archivo TimeSpanExtensions.cs la siguiente directiva, la cosa cambiará bastante:

global using static TimeSpanExtensions;

... // La clase estática TimeSpanExtensions sigue igual

Con ese using static hemos indicado al compilador que los métodos estáticos de la clase TimeSpanExtensions estarán disponibles en todo el proyecto sin necesidad de referenciar explícitamente la clase. Esto hace posible que podamos usar directamente el método Until().

Pero además, al usar el modificador global estamos haciendo que esa directiva se aplique a todo el proyecto, no solo al archivo actual. Esto significa que podemos usar Until() en cualquier parte de nuestro código sin necesidad de añadir un using específico en cada archivo.

Ahora, ya sí, podemos escribir el código de espera desde cualquier parte de nuestro proyecto:

await Until(2025, 09, 15);

¡Esto es todo! Y, con mucha alegría, aprovecho para informaros de que el blog estará en modo readonly hasta que acabe el await, es decir, hasta mitad de septiembre de 2025 (semana arriba, semana abajo).

Durante este tiempo, intentaré desconectar un poco y disfrutar de algunas semanas de vacaciones, que faltita hacen. Espero que podáis hacer lo mismo, ¡nos veamos de nuevo a la vuelta, con las pilas bien cargadas!

Publicado en Variable not found.

En la última recopilación de enlaces de la temporada, destacamos un artículo de Chema Alonso hablando sobre el Ratio de Potemkin, una forma de medir cómo un LLM parece que entiende algo frente a su comprensión real.

Andrew Lock profundiza en los entresijos del funcionamiento del comando dotnet run app.cs de .NET 10, que ayuda bastante a comprender lo que sucede tras bambalinas cuando lo lanzamos.

Filipe Lopes Domingues nos trae un artículo sobre la hidratación incremental en Angular, una técnica que mejora el rendimiento al reducir la cantidad de JavaScript necesario para cargar aplicaciones.

José Manuel Alarcón nos presenta las novedades de ECMAScript 2025, que incluyen mejoras significativas en el lenguaje JavaScript y sus aplicaciones prácticas.

El resto de enlaces, a continuación.

Por si te lo perdiste...

• ¿Se puede usar System.IO para leer o escribir en el sistema de archivos desde Blazor WebAssembly? (Spoiler: sí, pero con matices)
  José M. Aguilar
• Cómo incluir scripts en la página desde vistas parciales ASP.NET Core MVC con DynamicSections
  José M. Aguilar

.NET

• Behind the scenes of dotnet run app.cs
  Andrew Lock
• AutoMapper and MediatR Roadmaps
  Jimmy Bogard
• Getting Started With HotChocolate GraphQL For Building a Social Media Platform
  Anton Martyniuk
• Importing JSON Files Into A C# Project
  Barret Blake
• Functional Programming in C#—Exploring Advanced Topics
  Assis Zang
• Rejigs: Making Regular Expressions Human-Readable
  Omar Zawahry

Estimados amigos y amigas:

Es un inmenso placer informaros de que Microsoft ha decidido honrarme de nuevo con el galardón MVP (Most Valuable Professional) por mis contribuciones a la comunidad de desarrolladores, en esta ocasión en las categorías de Desarrollo Web y .NET.

Es el decimoquinto año consecutivo en el que recibo este reconocimiento y aún no puedo evitar sentirme profundamente agradecido y afortunado por formar parte de una comunidad tan apasionada y generosa. Cada día es un privilegio poder compartir, aprender y crecer junto a todos vosotros.

Gracias de corazón a los que lo habéis hecho posible, por apoyarme y acompañarme en esta maravillosa etapa de mi vida.

Muchas gracias a los miembros del programa MVP @MVPAward, con la gran Cristina González (@crisgherrero), Program Manager en LATAM & Southern Europe, al frente, por considerarme merecedor de este galardón.

Muchas gracias también al resto de MVPs de Microsoft, por hacer una comunidad tan increíble y por todo lo que comparten con nosotros. Y enhorabuena a los que en estas mismas fechas han sido galardonados por primera vez, porque están viviendo un momento que no olvidarán.

Muchas gracias a mi familia, que me ha permitido dedicar tanto tiempo a mis aficiones y por su incondicional apoyo en todas mis aventuras.

Y, por supuesto, muchas gracias a todos los que me seguís a través de este blog u otros canales, porque sin vosotros nada de esto sería posible.

Ahora, ¡a celebrarlo! 😊🥳🎉🎆

Publicado en Variable not found.

Penúltima entrega de enlaces interesantes antes del parón vacacional, con más de cincuenta referencias a contenidos a los que vale la pena echar un vistazo.

Por destacar, en esta entrega, encontramos a Marc Rubiño hablando sobre cómo aplicar el enfoque ágil de las startups (probar pronto, equivocarse rápido y adaptarse), no sólo en el mundo de la tecnología. Y sobre todo, perder el miedo a equivocarnos.

Ricardo Peres hace una recopilación de tipos de colecciones presentes en la BCL de ,NET, y muestra las mejores prácticas a la hora de utilizarlas.

Chris Pietschmann nos recuerda la importancia de escribir código testeable, independientemente de que escribamos o no pruebas unitarias.

Y por último, echamos un vistazo en profundidad a las diferencias entre las funciones ordinarias y las funciones flecha en JavaScript, de la mano de James Sinclair.

El resto de enlaces, a continuación.

Por si te lo perdiste...

• El operador 'with': mutaciones no destructivas en C#
  José M. Aguilar
• Redirecciones HTTP 303, 307 y 308: ¿las conoces?
  José M. Aguilar

.NET

• Monitor your A/B test in .NET
  Bart Wullems
• Design Patterns Guide in .NET Using C# -Part II: Real-Time Project-Enterprise Notification System
  Bhargava Koya
• Testcontainers Best Practices for .NET Integration Testing
  Milan Jovanović
• Adding test description for data-driven tests in xUnit
  Steven Giesel
• Exploring the features of dotnet run app.cs
  Andrew Lock
• How to Find Public Symbols That Can Be Internal Using Roslyn
  Gérald Barré
• Evolving Text: Solving the “Hello World” Puzzle with a C# Genetic Algorithm
  Chris Woodruff
• .NET Collections
  Ricardo Peres

El compilador de C# es listo, muy listo. Es capaz de analizar en tiempo real nuestro código para comprender lo que estamos haciendo y su contexto y, en muchas ocasiones, advertirnos de posibles errores antes de que seamos conscientes de que están ahí.

Pero lamentablemente aún no es adivino, y en algunas ocasiones tenemos que ayudarlo a que conozca nuestras intenciones. Para estos casos, existen una serie de atributos que añaden metadatos al código y que el compilador puede utilizar para realizar un análisis más preciso.

Hoy vamos a hablar de uno de estos atributos, MemberNotNullWhenAttribute, que nos permite dar pistas al compilador sobre la nulabilidad de un miembro de una clase en función del valor de otro miembro, algo que puede resultarnos muy útil en ciertos escenarios, como veremos a continuación.

De alguna forma, los desarrolladores somos como relojeros: construimos sistemas complejos utilizando piezas diminutas que van encajando armoniosamente unas con otras para formar una máquina que funciona como un todo y aporta valor a nuestros usuarios. Quizás por eso me ha llamado la atención un precioso y trabajado artículo interactivo de Bartosz Ciechanowski, al que he llegado a través de MicroSiervos, sobre cómo funcionan los relojes mecánicos.

Continuando con la serie "cómo funcionan las cosas", Mia Koring nos explica cómo funciona la compresión de texto usando el algoritmo de codificación Huffman, uno de los muchos que existen para que nuestros datos ocupen menos espacio.

También esta semana, Martin Fowler ha publicado una reflexión, que comparto totalmente, sobre cómo los LLMs tienen la capacidad de redefinir lo que entendemos como "programación". De la misma forma que el ensamblador nos alejó de los ceros y unos, o los lenguajes de alto nivel nos fueron aislando cada vez más de la máquina permitiéndonos jugar con abstracciones superiores, los LLMs son una capa de abstracción aún mayor, que incluso nos permite alejarnos de los detalles de implementación y centrarnos más en la lógica y el diseño de alto nivel... eso sí, a costa de la indeterminación. Un artículo muy interesante que no te puedes perder.

Por último, me ha alegrado leer en el post de David Ortinau que .NET 10 va a reducir la verbosidad del XAML usado en páginas y componentes MAUI, algo que siempre me ha parecido más farragoso de la cuenta... sobre todo cuando vienes de la web y usas sintaxis superconcisas como Razor.

El resto de contenidos interesantes recopilados la semana pasada, a continuación.

Por si te lo perdiste...

• Un ejemplo de uso elegante del operador "null coalescing assignment" de C#
  José M. Aguilar
• Extendiendo claims de usuarios en ASP.NET Core
  José M. Aguilar

.NET

• Wire Up XUnit Logging for Crazy Integration Testing
  Jeremy D. Miller
• Legacy Code Survival Guide: Visual Basic and .NET in 2025
  DeeDee Walsh
• Task.WhenAll or Parallel.ForEach?
  Fati Iseni
• Day 11: Implementing a C# Mutation Operator for Genetic Algorithms
  Chris Woodruff
• Managing Secrets in .NET Applications with Azure Key Vault & Managed Identities
  Sudhir Mangla
• .NET 8.0.17 Upgrades, Forwarded Headers, and Unknown Proxy Issues
  Khalid Abuhakmeh & Wesley Cabus
• .NET Channels as a In-Memory Message Bus – Beware!
  Derek Comartin

Estamos acostumbrados a usar el operador await de C# para esperar la finalización de tareas asíncronas representadas por objetos de tipo Task, Task<T>, ValueTask o ValueTask<T>, pero, ¿sabíais que en realidad podemos usarlo con cualquier tipo de objeto?.

En este artículo vamos a ver que es bastante sencillo, y lo ilustraremos con un ejemplo muy simple: cómo esperar un segundo usando la expresión await 1000 o await TimeSpan.FromSeconds(1) en lugar del clásico await Task.Delay(1000).

Una vez más, vamos con los contenidos interesantes recopilados durante la semana pasada 🙂

En esta ocasión, me vais a permitir a destacar un post propio que, aunque tiene más de un año de vida y es bastante básico, creo sigue siendo muy válido y puede ser de ayuda para algunos desarrolladores que siguen malgastando recursos. En "¡No uses ContainsKey() en un diccionario .NET para ver si existe un elemento antes de obtenerlo!" demostramos de forma empírica lo absurdo de realizar una comprobación de existencia de un elemento en un diccionario .NET antes de obtenerlo, un detalle en los que a veces no caemos.

También destacaremos algunos contenidos relacionados con MCP, que sin duda es la palabra de moda de los últimos tiempos. Primero, Aaron Stannard nos cuenta en qué consiste este estándar y para qué podamos usarlo en la práctica, eliminando el hype que le rodea. 

Juan Luis Guerrero continúa explorando la implementación y uso de servidores MCP, esta vez usando como modelo Google Gemini 2.5.

Rhea Patel nos cuenta que el modo agente ya está disponible de forma general en Visual Studio. 

Y el equipo de Visual Studio Code ha publicado un catálogo de servidores MCP listos para usar en el modo agente del editor, instalables con un único click.

El resto de enlaces, a continuación.

Por si te lo perdiste...

• ¡No uses ContainsKey() en un diccionario .NET para ver si existe un elemento antes de obtenerlo!
  José M. Aguilar
• Renderizar una vista Razor a un string en ASP.NET Core MVC
  José M. Aguilar

.NET

• .NET 10 Performance Edition
  Steven Giesel
• Song recommendations from C# combinators
  Mark Seemann
• Getting started with Open Telemetry in .NET with Jaeger and Seq
  Anton Martyniuk
• 16 common mistakes C#/.NET developers make (and how to avoid them)
  Ali Hamza Ansari
• Temporal.IO in .NET
  Marek Sirkovský
• RunJS: An MCP server that lets LLMs generate and execute JavaScript safely in an embedded .NET runtime sandbox using the Jint library.
  Charles Chen
• 7 Underrated C# 12 and C# 13 Features Every Developer Should Know!
  Saravanan Madheswaran
• Kickstarting your libraries with the .NET Library Starter Kit Dennis Doomen
  Dennis Doomen
• How to use frozen collections in C#
  Joydip Kanjilal
• Unpacking Zip Folders into Windows Long File Paths
  Rick Strahl

Si os gusta trastear con las previews de .NET en el mismo equipo en el que estáis desarrollando proyectos que usan versiones estables, es posible que al compilar encontréis en la consola o ventana Output de vuestro IDE favorito un mensaje de error parecido al siguiente:

NETSDK1057: You are using a preview version of .NET. See: https://aka.ms/dotnet-support-policy

Básicamente, el sistema nos está informando de que estamos usando un SDK que aún está en fase de pruebas, o preview. Aunque esto no debería ser un problema porque el SDK debería ser totalmente compatible hacia atrás, simplemente es un recordatorio de que no es la versión estable y siempre podríamos encontrarnos algún problema.

Esto ocurre porque los comandos del SDK utilizan la última versión instalada en el equipo, por lo que, si hemos instalado una versión preliminar, será ésta la que se utilice. Podemos comprobarlo fácilmente ejecutando el siguiente comando en consola, que nos mostrará la versión del SDK que se está utilizando por defecto:

 C:\> dotnet --version
10.0.100-preview.5.25277.14

Normalmente, el mensaje NETSDK1057 podemos ignorarlo sin problema, pero si por cualquier motivo queremos eliminarlo o simplemente queremos forzar el uso de una versión determinada del SDK de .NET en algún proyecto o de forma global, podremos hacerlo usando un archivo llamado global.json.

Buena cosecha la semana pasada, con mucho contenido interesante 🙂

Destacamos el lanzamiento de la quinta preview de .NET 10, que esta vez incluye cambios en C#, ASP.NET Core, Blazor, .NET MAUI y otras áreas.

Rick Strahl nos enseña a añadir paquetes NuGet en tiempo de ejecución a una aplicación, algo que puede ser muy útil en sistemas con plugins o extensiones.

Vale la pena también echar un vistazo a Next Edit Suggestions, una nueva característica de GitHub Copilot para Visual Studio y Code que sugiere la siguiente edición en el código, lo que puede mejorar la productividad de los desarrolladores.

Shalitha Suranga comparte sus reflexiones sobre el declive de los blogs técnicos y cómo los desarrolladores somos los únicos que podemos hacer algo para que no desaparezcan.

Finalmente, Ricardo Peres nos presenta RazorSharpener, un componente que simplifica la compilación y renderización de componentes Razor en tiempo de ejecución.

Más contenidos interesantes, a continuación.

Por si te lo perdiste...

• Procesar secuencias por lotes, o cómo usar chunks en C#
  José M. Aguilar
• Autenticación JWT en APIs con ASP.NET Core
  José M. Aguilar

.NET

• .NET 10 Preview 5
  James Montemagno
• Adding Runtime NuGet Package Loading to an Application
  Rick Strahl
• Don't reinvent the wheel
  Josef Ottosson
• Federated Identity in .NET: A Complete Guide for Software Architects
  Sudhir Mangla
• Converting a Microsoft XNA 3.1 game to MonoGame
  Andrew Lock
• How to Create and Convert PDF Documents in ASP.NET Core
  Anton Martyniuk
• Are Your LINQ Queries Slowing Down Your App? Here's How to Fix Them
  Meena Alagiah
• Repeating a test multiple times in C#
  Bart Wullems
• C# Tip: Handling exceptions with Task.WaitAll and Task.WhenAll
  Davide Bellone
• Queue-Based Load Leveling Pattern in C#: Cloud Stability, Scalability & Best Practices
  Sudhir Mangla
• Domain-Driven Design Principles: Value Objects in ASP.NET Core
  Assis Zang
• Run C# Scripts With dotnet run app.cs (No Project Files Needed)
  Milan Jovanović

Desde la aparición de Blazor y sus distintos tipos de hosting de componentes (SSR, Server, WebAssembly), se intentó promover que estos fueran agnósticos respecto a su modo de ejecución. Sin embargo, en la práctica esto no es siempre posible, y en ocasiones necesitamos saber en qué modo se está ejecutando un componente para poder adaptarlo a las necesidades de la aplicación.

Hace más de un año, cuando aún Blazor 8 era la versión más reciente de este framework, vimos por aquí un truco para detectar si un componente Blazor estaba ejecutándose de forma estática (SSR) o interactiva. Y algunos años antes, ya habíamos visto también distintas formas para detectar si un componente interactivo estaba corriendo sobre Blazor Server o Blazor WebAssembly.

Aunque las soluciones propuestas funcionaban bien y solucionaban nuestro problema, eran simplemente trucos (o "hacks", algo retorcidos en algunos casos) para cubrir unas necesidades que no estaban bien resueltas desde el propio framework.

Con .NET 9 esto cambió, y desde esta versión de Blazor ya existen mecanismos nativos para detectar cuándo un componente se ejecuta en modo estático o interactivo, y en este último caso, qué modo de renderizado se está utilizando.

Vamos a ver cómo conseguirlo.

Aquí está ya la recopilación semanal de enlaces a contenidos a los que vale la pena echarles un vistazo, sobre .NET, patrones, buenas prácticas, acceso a datos, IA, desarrollo web y tooling, entre otros temas.

Esta semana destacamos un interesante post de Chema Alonso sobre cómo saltarse las restricciones de ChatGPT y otros LLMs para obtener imágenes prohibidas utilizando el conocimiento que ya tienen del mundo.

También, José Manuel Alarcón nos cuenta en un detallado artículo las novedades que podemos encontrar en el recién lanzado Angular 20.

Gregor Sutttie nos habla de una de las novedades presentadas en Microsoft Build 2025: los asistentes de actualización de .NET, que nos ayudarán a modernizar nuestras aplicaciones y migrarlas a las últimas versiones.

Me ha llamado la atención el log buffering, una característica de .NET 9 que desconocía y que permite retrasar el momento en que se emiten las trazas. Nos lo cuenta Evgenii Fedorov en su post Emit logs on-demand with log buffering.

Y por último, Braulio Díez nos recuerda la importancia de saber decir que no.

El resto, a continuación 🙂

Por si te lo perdiste...

• Probar scripts en producción sin desplegar nada, y otros usos interesantes de Fiddler
  José M. Aguilar
• Deserializar un objeto JSON a un diccionario .NET con System.Text.Json
  José M. Aguilar

.NET

• Why is enumerating over List faster than IList?
  Steven Giesel
• Boost Your .NET Projects: Enhance Your Workflow with AssemblyHelper in Spargine
  David McCarter
• Creating your first sample game with MonoGame
  Andrew Lock
• Sniffing HttpClient
  Sergio León
• Upgrading Your .NET Applications: Exploring .NET Upgrade Assistants at Microsoft Build
  Gregor Suttie
• IEnumerable vs. IAsyncEnumerable in .NET: Streaming vs. Buffering
  Ali Hamza Ansari
• Deep C# - Delegates
  Mike James
• Automating Null-Forgiving Operator Removal in C# Projects
  Gérald Barré
• Making Event Sourcing with Marten Go Faster
  Jeremy D. Miller
• Catch Up on Microsoft Build 2025: Essential Sessions for .NET Developers
  .NET Team
• Emit logs on-demand with log buffering
  Evgenii Fedorov