Variable not found

Enlaces interesantes 643

2026-04-13T08:01:00.001+02:00

Tras una semana de parón debido a las fiestas, volvemos con una nueva entrega de enlaces interesantes. En esta ocasión, al tratarse de dos semanas de cosecha, tenemos una recopilación bastante cargadita de contenidos a los que vale la pena echar un vistazo.

Pero como siempre, destacaremos unos cuantos.

José Manuel Alarcón nos habla de que el uso de la IA sin un control adecuado podría introducir deuda técnica en nuestros proyectos, y nos ofrece una guía para evitarla.

Con tanta novedad en el mundo de las herramientas IA para desarrolladores, a veces no es fácil distinguir conceptos que a priori parecen similares, pero en realidad son muy diferentes. Para ayudarnos un poco con esto, Juan Luis Guerrero nos explica las diferencias entre agentes, skills y comandos en el contexto de herramientas como Claude Code, Codex, Copilot CLI y Gemini CLI.

Fernando Escolar nos recuerda la importancia de mejorar continuamente nuestro código con pequeños cambios, que, aunque no sean espectaculares, pueden marcar una gran diferencia en la calidad y mantenibilidad de nuestro software.

Gerson Azabache nos habla de "workers" o tareas en segundo plano para lograr que nuestras aplicaciones respondan de forma rápida y eficiente, consiguiendo una experiencia de usuario más fluida, y luego nos enseña cómo implementarlos en .NET con IHostedService.

Y para terminar, todo un clásico: ¿quieres mostrar una dirección de correo electrónico en tu sitio web sin que los spammers se ceben con ella? Spencer Mortensen nos cuenta las técnicas de ofuscación de correo electrónico que siguen funcionando en 2026.

El resto de contenidos interesantes, a continuación.

Enlaces interesantes 643

2026-03-30T08:02:00.001+02:00

Pues nos vamos de Semana Santa con unos cuantos enlaces interesantes para entretenernos durante las vacaciones, en caso de haberlas 😎

Y como siempre me gusta destacar algunos, comencemos por Mark Seemann, que trata un tema algo controvertido, pero interesante: si usamos agentes IA para generar nuestro código sin supervisión, ¿quién es responsable de ese código? ¿podríamos ir a prisión por un código generado por una IA? Spoiler: ándate con cuidado, por si acaso.

José Manuel Alarcón nos cuenta esta semana qué son los proyectos greenfield y brownfield, términos usados últimamente con mucha frecuencia. Y de paso, también nos envía una llamada de atención sobre el cambio de política de datos de GitHub, que les permitirá en poco tiempo utilizar nuestro código para entrenar a sus modelos de IA, y nos cuenta cómo evitarlo.

Daniel Rosenwasser ha anunciado TypeScript 6.0, la última versión del lenguaje antes de dar el esperado salto a Go, previsto para TypeScript 7.0. En esta nueva versión se han incluido mejoras en el lenguaje y el sistema de tipos y soporte para nuevas APIs.

Nick Cosentino nos lleva a las bases explicando las diferencias entre el patrón Singleton y las clases estáticas en C# y cuándo deberíamos usarlas.

Y la frikada de la semana la encontramos en el blog de Chema Alonso, que nos cuenta cómo es posible guardar, descargar y ejecutar el juego Doom desde el DNS de Cloudflare.

El resto de enlaces a contenidos que no puedes perderte, a continuación.

Por si te lo perdiste...

Forzar casts imposibles con C#
José M. Aguilar
Constructores con parámetros en entidades EF Core
José M. Aguilar

.NET

Feature Flags en .NET: Controla tu Código Sin Hacer Deploy
Gerson Azabache Martínez
Singleton vs Static Class in C#: Key Differences Explained
Nick Cosentino
SOLID Principles in C#: Beginner Guide with .NET Examples
Dirk Strauss
Speed Up .NET CI with Test Sharding
Gérald Barré
C# Tip: How to JSON Serialize and Deserialize values as DateTime, DateTimeOffset, DateOnly and TimeOnly
Davide Bellone
Introducing NtpTick: A lightweight NTP client for .NET
Jiří Činčura
Improving .NET Security Code with C# 14 Property Extensions
Wesley Cabus
Build an AI-Powered Excel Translator in C# Using OpenAI and XlsIO
Mohan Chandran
Compile-Time options validation with the OptionsValidator source generator
Bart Wullems
Generating Structured Code Using Azure, OpenAI and .NET
Ricardo Peres

ASP.NET Core / ASP.NET / Blazor

Versionamiento de APIs: conceptos, estrategias y trade-offs & Versionamiento de APIs en .NET: guía práctica de implementación
Gerson Azabache Martínez
Designing business rules that don't leak into controllers
Ali Hamza Ansari
Privacy Health Checks: Beyond Database Connectivity
Martin Stühmer
ASP.NET Core Output Cache: How to Speed Up Your API with In-Memory Cache and Redis
Anton Martyniuk
Top 3 Errores comunes al hacer APIs en .NET (y cómo evitarlos)
Gerson Azabache Martínez
Scaling SignalR With a Redis Backplane
Milan Jovanović
Announcing Aspire 13.2
Maddy Montaquila
A Simple .NET CLI Web Server
Bryan Hogan
Build an ASP.NET Core AI Assistant API with GitHub Copilot SDK in C#
Nick Cosentino
What’s New for Blazor in .NET 11 Preview Releases 1 and 2
Jon Hilton

Azure / Cloud

Aspire on Azure App Service is now Generally Available
Tulika Chaudharie

Conceptos / Patrones / Buenas prácticas

What Are WebSockets and How Are They Different From HTTP?
Liz Acosta
Stop Deploying Garbage to Production
Martin Stühmer

Data

Composite Index SQL: How to Improve Query Speed
Deepak Vohra
CPU percentage vs SQL instance CPU percent: The Portal’s Favorite Misunderstanding
Shaurya Singh
How to Work With Dapper in .Net
Grant Riordan

Machine learning / IA

Cuando la IA intenta arreglar el mismo bug diez veces… el problema ya no es el bug
Alberto Díaz Martín
Tips y buenas prácticas usando IA
Juan Irigoyen
Ten Months with Copilot Coding Agent in dotnet/runtime
Ron Darziv
Will you go to prison for an AI?
Mark Seemann
Stop Wasting Tokens: Smart Tool Routing for LLMs with MCPToolRouter
Bruno Capuano

Web / HTML / CSS / Javascript / Design

Announcing TypeScript 6.0
Erkan Okman
Redux vs Zustand: Choosing the Right React State Manager
Manikanda Akash Munisamy
Experimenting With Scroll-Driven corner-shape Animations
Daniel Schwarz
Two Circles, One Arrow, and Anchor Positioning
Temani Afif
Shadow DOM Focus Delegation: Getting delegatesFocus Right
Rob Levin
Testing Font Scaling For Accessibility With Figma Variables
Ruben Ferreira Duarte
Contravariance on TypeScript Function Parameters
Dhananjay Kumar

Visual Studio / Complementos / Herramientas

¿Tu IA aprende de ti?: Cómo evitar que GitHub Copilot use tu código para entrenar a sus modelos
José Manuel Alarcón
Dependabot te dice que es vulnerable… ¿pero es explotable de verdad?
Gisela Torres
ReSharper 2026.1 Release Candidate Released!
Sasha Ivanova
Essential Studio UI Edition Now Available For Dev Essentials Subscribers & Essential Studio Enterprise Edition Now Available For Select Visual Studio Enterprise and Professional Subscribers
Meena Alagiah
Visual Studio Shortcuts: Complete Guide to Coding Faster
Dirk Strauss
Resolve Merge Conflicts the Easy Way
Phil Haack
Windows: Choose Where To Get Apps
Eric Lawrence

Otros

¿Qué son los proyectos greenfield y brownfield en software (y por qué se oyen tanto, también en España)?
José Manuel Alarcón
Doom over DNS: O cómo guardar, descargar y ejecutar Doom desde el DNS (de Cloudflare)
Chema Alonso
Windows 95 defenses against installers that overwrite a file with an older version
Raymond Chen
A quarter of a billion NuGet downloads
Mattias Karlsson

Publicado en Variable not found.

Enlaces interesantes 642

2026-03-23T08:02:00.029+01:00

La semana pasada encontré gran cantidad de contenidos interesantes sobre desarrollo web, .NET, IA, acceso a datos, MAUI y otros temas, aunque me gustaría destacar varios artículos, todos relacionados con la inteligencia artificial, a los que, como mínimo, deberías echarles un vistazo.

En primer lugar, Fernando Escolar nos explica detalladamente las distintas piezas que componen un agente de IA, y cómo se relacionan entre sí.

Braulio Díez, citando a Sabina, reflexiona sobre el modelo de negocio de los proveedores de IA como OpenAI o Anthropic, y cómo pueden permitirse perder cantidades ingentes de dinero en sus operaciones, en busca de un beneficio futuro astronómico.

Miguel Durán comparte un proyecto personal que ha creado para comprobar qué modelos de IA podemos ejecutar en nuestra máquina local, muy útil para usar IA generativa sin pasar por caja y sin enviar datos hacia fuera.

Por último, Addy Osmani nos habla de la deuda de comprensión que se genera al usar código generado por IA, y cómo esto puede afectar a los desarrolladores a largo plazo.

El resto de enlaces, a continuación.

Por si te lo perdiste...

Aprovecha al máximo los archivos .http en Visual Studio usando variables dinámicas
José M. Aguilar
Backing fields en Entity Framework Core
José M. Aguilar

.NET

C# class types explained with examples
David Grace
CoreSync: a .NET library that provides data synchronization between databases
Adolfo Marinucci
records ToString and inheritence
Steven Giesel
Implementing RFC-compliant HTTP caching for HttpClient in .NET
Gérald Barré
C# 14 New Features: A Developer Guide for .NET 10
Dirk Strauss
Writing a .NET Garbage Collector in C# - Part 9: Frozen segments and new allocation strategy
Kevin Gosse
Local LLM Chat Completions in .NET — Just C#
Bruno Capuano
Implementing the Strategy Pattern with .NET Dependency Injection
Ricardo Peres

ASP.NET Core / ASP.NET / Blazor

Code Blocks in Blazor Rich Text Editor: Setup and Best Practices
Saravanan G.
Blazor Basics: Implementing a Theme Switch in Blazor (Dark Mode)
Claudio Bernasconi
Green Dashboard, Dead Application
Martin Stühmer

Azure / Cloud

Your Azure SQL Backups Won't Save You (Here's Why)
Martin Stühmer
Lost Your SSH Key to an Azure VM? Don’t Panic. Here’s the Fix.
Shannon B. Kuehn
How to Evaluate, Test, and Demo Azure Local
Thomas Maurer

Conceptos / Patrones / Buenas prácticas

Scrum en la era de la IA: la síntesis que viene
Juan Palacio Bañeres
Decorator Design Pattern in C#: Complete Guide with Examples
Nick Cosentino
The unwritten laws of software engineering
Anton Zaides
Look Bro, I Know How to Write Good Code
Rob Conery

Data

How to Seed Data to EF Core
Ricardo Peres
Dapper in Depth with ASP.NET Core 10
Soumyadip Majumder
Optimizing Bulk Database Updates in .NET: From Naive to Lightning-Fast
Milan Jovanović
When NOT to use the repository pattern in EF Core
Ali Hamza Ansari
Entity Framework Extensions Options Explained: Everything You Can Customize
Anton Martyniuk
Deploy SQL Scripts Effectively in Production
Jared Westover
Microsoft.Data.SqlClient 7.0 Is Here: A Leaner, More Modular Driver for SQL Server
David Levy

Machine learning / IA

Subvencioname un pico de IA
Braulio Díez
Anatomía de un agente de IA
Fernando Escolar
CanIRun.ai — Can your machine run AI models?
Miguel Durán
Introducing OpenAI’s GPT-5.4 mini and GPT-5.4 nano for low-latency AI
OpenAI
What's New in Agent Skills: Code Skills, Script Execution, and Approval for Python
Sergey Menshykh
Random Forest Regression Using C#
James McCaffrey
AI Benefits - But at What Cost?
Steve Smith
How Large Language Models Are Built and Work — Complete Technical Guide
CostlyInfra
Comprehension Debt — the hidden cost of AI generated code
Addy Osmani

Web / HTML / CSS / Javascript / Frontend

Angular 16 y programación funcional para código limpio
David Filipe Lopes Domingues
Native Random Values in CSS
Alvaro Montoro
4 Reasons That Make Tailwind Great for Building Layouts
Zell Liew
Building dynamic toggletips using anchored container queries
Daniel Schwartz
Flexbox Masonry Layout (Explained with Math)
Ibrahim Bendebka
BaseWatch — Track CSS & Browser Feature Support, Get Baseline Alerts
Filippo Tinnirello
JavaScript for Everyone: Destructuring
Mat Marquis
Image Gallery with Popovers and AIM (Anchor-Interpolated Morph)
Chris Coyier
Modal vs. Separate Page: UX Decision Tree
Vitaly Friedman
Introducing Angular Testing Library Zoneless
Tim Deschryver
Text scaling support in Chrome Canary
Chris Coyier
Dropdowns Inside Scrollable Containers: Why They Break And How To Fix Them Properly
Godstime Aburu

Visual Studio / Complementos / Herramientas

Awesome GitHub Copilot just got a website, and a learning hub, and plugins!
Matt Soucoup
How VS Code Builds with AI
Pierce Boggan

.NET MAUI

MAUI Avalonia Preview 1
Tim Miller
Pin Clustering in .NET MAUI Maps
David Ortinau
How to Implement Accessibility in .NET MAUI
Leomaris Reyes
When Visual Studio Forgets Your Phone: Building an Automated Solution
Chris Miller
Logging in .NET MAUI Apps
Tomasz Cielecki
Accelerating .NET MAUI Development with AI Agents
Agus Riyadi
How to Extract Data from PDFs in .NET MAUI iOS Apps Using C#
Sumathi Uthayakumar
Build Once, Run Everywhere: Blazor Hybrid PDF Viewer for WinForms, WPF, and .NET MAUI
Parthipan R.

Otros

Java 26: menos es más — Guía completa de novedades para desarrolladores
CampusMVP

Publicado en Variable not found.

¡Ojo a los parámetros IEnumerable<T>!

2026-03-17T08:02:00.000+01:00

En .NET, es bastante habitual que nuestros métodos o funciones reciban objetos de tipo IEnumerable<T> con la intención de que iteremos sobre ellos para lograr el comportamiento deseado. Esta abstracción es muy poderosa, ya que nos permite trabajar con cualquier colección o secuencia de datos sin preocuparnos por su implementación concreta, pero, si no somos cuidadosos, puede llevarnos a errores y comportamientos inesperados.

Por ejemplo, es muy frecuente realizar múltiples enumeraciones sobre la misma instancia de IEnumerable<T>, algo que a veces puede ocurrir de forma inconsciente, y se convierte en un problema cuando la secuencia es muy extensa o su contenido no es replicable. De hecho, muchas herramientas y entornos de desarrollo nos advierten sobre este problema durante la edición y compilación para que estemos atentos.

Otro problema común es asumir que la secuencia es finita, algo que no tiene por qué ser siempre cierto. Las enumeraciones en este caso pueden llevar a bucles infinitos o a un consumo excesivo de recursos.

En este artículo exploraremos distintos escenarios que pueden darse y cómo podemos evitarlos.

¿Qué es una enumeración múltiple?

Una enumeración múltiple ocurre cuando un método o función recorre una secuencia de datos más de una vez. Esto puede suceder de forma explícita, por ejemplo, si tenemos dos bucles foreach que iteran sobre la misma secuencia, o de forma implícita, como cuando llamamos a varios métodos como Count(), ToList(), Last(), etc. sobre la misma colección.

Cuando se trata de una colección en memoria, como una lista o un array, no suele haber problema al realizar enumeraciones múltiples, ya que estas estructuras permiten recorrerlas tantas veces como sea necesario sin incurrir en un coste significativo.

Sin embargo, si la secuencia es generada dinámicamente, como una consulta LINQ a una base de datos o aquellas producidas por un iterador, cada operación de enumeración puede implicar un coste considerable, tanto en términos de rendimiento como de recursos, lo que hace que la enumeración múltiple pueda ser problemática.

Pero además, el contenido de la secuencia puede variar entre distintas enumeraciones, lo que puede llevar a resultados inconsistentes o errores inesperados. Es lo que llamamos "secuencias no replicables".

¿Qué es una secuencia no replicable?

Una secuencia no replicable es aquella que no puede ser recorrida múltiples veces de manera segura. Un ejemplo típico es una consulta LINQ que se ejecuta contra una base de datos, datos procedentes de un stream o una secuencia generada por un iterador que produce valores bajo demanda. En ninguno de esos casos podemos garantizar que la secuencia se mantenga igual entre diferentes enumeraciones, o incluso que esté disponible para una segunda enumeración (por ejemplo, los datos podrían haber cambiado en la base de datos).

Por ejemplo, observad una función como la siguiente, que recibe un objeto IEnumerable<int>, muestra el número de elementos recibidos e itera dos veces sobre ellos para procesarlos:

static void Process(IEnumerable<int> numbers)
{
    Console.WriteLine($"Processing {numbers.Count()} numbers");
    Console.WriteLine("First pass");
    foreach (var number in numbers)
    {
        Console.WriteLine($"  Doing something with {number}");
        DoSomething(number);
    }

    Console.WriteLine("Second pass");
    foreach (var number in numbers)
    {
        Console.WriteLine($"  Doing another thing with {number}");
        DoAnotherThing(number);
    }
}

Si el objeto enviado a la función Process() se encontraba ya en memoria, por ejemplo en forma de una lista (List<int>) o array (int[]), el código anterior funcionará sin problemas. La ejecución será consistente y predecible, los elementos se contarán de forma correcta y ambos bucles foreach los recorrerán, por lo que la salida en consola será idéntica en las dos vueltas.

Process([1, 2, 3]);

Processing 3 numbers 
First pass
  Doing something with 1
  Doing something with 2
  Doing something with 3
Second pass
  Doing another thing with 1
  Doing another thing with 2
  Doing another thing with 3

Sin embargo, imaginad que lo que enviamos es una consulta LINQ que se ejecuta contra una base de datos. En ese caso, la llamada a Count() ejecutará la consulta para obtener el número de elementos. Tras ello, el primer foreach ejecutará de nuevo la consulta y obtendrá los resultados, y el segundo foreach volverá a ejecutarla. Esto, además de suponer potencialmente un problema de rendimiento, puede devolver en cada caso un conjunto diferente de resultados o incluso lanzar una excepción si la conexión a la base de datos ya no está disponible.

Lo mismo puede ocurrir si la secuencia es generada por un iterador que produce valores bajo demanda, como en el siguiente ejemplo. Como podéis ver, se trata de una función generadora que devuelve entre 3 y 7 números aleatorios en el rango 1-9 cada vez que se itera sobre ella:

static IEnumerable<int> GenerateNumbers()
{
    for (int i = 0; i < Random.Shared.Next(3, 8); i++)
    {
        yield return Random.Shared.Next(1, 10);
    }
}

En este caso, cada llamada a GenerateNumbers() produce una secuencia diferente de números. Por lo tanto, si pasamos esta función generadora a nuestro método Process(), veremos que cada vez que enumeramos la secuencia obtenemos resultados distintos, tanto en el número de elementos como en los propios valores:

Process(GenerateNumbers());

Processing 2 numbers
First pass
  Doing something with 9
  Doing something with 8
  Doing something with 2
  Doing something with 3
  Doing something with 4
  Doing something with 9
  Doing something with 8
Second pass
  Doing another thing with 5
  Doing another thing with 3
  Doing another thing with 2

Observad que, en este caso, cada enumeración de la secuencia ha producido un conjunto diferente de números, lo que puede llevar a comportamientos inesperados en nuestro código, como el que vemos en la salida anterior.

Por tanto, cuando escribimos un método o función que acepta parámetros de tipo IEnumerable<T>, debemos ser conscientes de que estamos abriendo la puerta a que un consumidor realice invocaciones enviando secuencias no replicables.

¿Qué son las secuencias infinitas?

Otra situación problemática es cuando la secuencia recibida es infinita. Esto puede ocurrir, por ejemplo, si la secuencia es generada por un iterador que produce valores de forma indefinida, como la siguiente:

static IEnumerable<int> InfiniteNumbers()
{
    int i = 0;
    while (true)
    {
        yield return (i++) % 10;
    }
}

Esta secuencia generará números indefinidamente, repitiendo los dígitos del 0 al 9, por lo que cualquier intento de recorrerla por completo derivará en un bucle infinito. De hecho, si pasamos esta secuencia a nuestro método Process(), la llamada a Count() intentará contar todos los elementos y dará lugar a un bloqueo de la aplicación.

¿Qué podemos hacer para evitar estos problemas?

Afortunadamente, hay soluciones sencillas para evitar los comportamientos inesperados cuando trabajamos con parámetros de tipo IEnumerable<T>.

La opción más recomendable sería intentar refactorizar el método para que no sea necesario realizar más de una enumeración de la secuencia recibida. En el caso anterior es complicado porque el Count() inicial ya implica una enumeración, pero quizás funcionalmente podría ser prescindible o sustituible por otro enfoque similar:

static void Process(IEnumerable<int> numbers)
{
    var count = 0;
    foreach (var number in numbers)
    {
        count++;
        Console.WriteLine($"  Doing something with {number}");
        DoSomething(number);
        Console.WriteLine($"  Doing another thing with {number}");
        DoAnotherThing(number);
    }
    Console.WriteLine($"{count} numbers processed");
}

Sin duda esta es la mejor opción porque evita todos los problemas de raíz, sin sacrificar rendimiento ni la flexibilidad de recibir un objeto de tipo IEnumerable<T>. Además, permitiría detener la enumeración en cualquier momento, cuando ya no sea necesario procesar más elementos, sin necesidad de recorrer la secuencia completa.

Sin embargo, no siempre será posible.

Otra opción es bajar el nivel de abstracción y cambiar el tipo de datos del parámetro, para asegurar que solo se puedan enviar colecciones que ya estén materializadas en memoria y que, por tanto, sean replicables. Por ejemplo, podríamos cambiar la firma del método para recibir objetos IReadOnlyCollection<T> o IReadOnlyList<T>, lo que garantiza que la colección es fija y puede ser recorrida múltiples veces sin problemas.

La diferencia principal entre IReadOnlyCollection<T> e IReadOnlyList<T> es que la primera solo garantiza que la colección tiene un tamaño definido y puede ser contada, mientras que la segunda también permite acceder a los elementos por índice. En este caso, cualquiera de las dos opciones sería válida.

static void Process(IReadOnlyCollection<int> numbers)
{
    ... // El resto del código permanece igual
}

A veces, esto requerirá que los consumidores del método tengan que adaptar su código para enviar colecciones materializadas, pero a cambio evitamos cualquier riesgo de múltiples enumeraciones inesperadas. También estaremos protegiéndonos contra secuencias infinitas, ya que ningún consumidor podrá enviar una secuencia que no tenga un tamaño definido.

// Código del consumidor
var items = GenerateNumbers().ToList(); // Materializamos la secuencia
Process(items);

Si ninguna de las opciones anteriores es viable, siempre podemos optar por materializar la secuencia recibida al inicio del método, almacenándola en una lista o array. De esta forma, nos aseguramos de que cualquier enumeración posterior se realice sobre una colección fija y replicable.

static void Process(IEnumerable<int> numbers)
{
    var materializedNumbers = numbers.ToList(); // Materializamos la secuencia
    ... // El resto del código permanece igual, pero usando materializedNumbers
}

El inconveniente de esto es que, si la secuencia original es muy grande, podríamos estar consumiendo una cantidad significativa de memoria. Tampoco tendremos protección contra secuencias infinitas, ya que la llamada a ToList() intentará recorrer toda la secuencia para materializarla.

Conclusión

En resumen, cuando trabajamos con parámetros de tipo IEnumerable<T>, debemos ser conscientes de los posibles problemas que pueden surgir debido a múltiples enumeraciones o secuencias infinitas. Adoptar buenas prácticas y elegir la estrategia adecuada según el contexto nos ayudará a evitar errores y a escribir código más robusto y predecible.

Publicado en: www.variablenotfound.com.

Enlaces interesantes 641

2026-03-16T08:02:00.030+01:00

Esta semana me he topado con bastantes contenidos interesantes 😊

Por citar algunos, ya tenemos aquí la segunda preview de .NET 11, con novedades interesantes como el runtime asíncrono, soporte nativo para trazas alineadas con OpenTelemetry, mejorillas en Blazor, soporte para OpenAPI 3.2.0, nuevas plantillas de proyecto, mejoras en rendimiento y más. Si quieres conocer todos los detalles, no te pierdas el anuncio oficial.

Bipin Joshi nos habla de las Minimal APIs una vez pasó el hype inicial: qué nos aportan, las ventajas e inconvenientes de su ausencia de código ceremonial y sus escenarios de uso ideales.

Gurveer Arora continúa exprimiendo el potencial de HTML y CSS con su serie NoJS, y en esta ocasión nos trae un clon de Flappy Bird hecho sin una sola línea de JavaScript. Porque poderse, se puede.

También me ha parecido interesante la lectura de The WebAssembly Component Model, una arquitectura para la construcción de librerías y aplicaciones interoperables utilizando WebAssembly.

Y Ricardo Peres continúa explorando las APIs de sincronización en .NET, y en esta ocasión nos habla de las herramientas que tenemos a nuestra disposición para sincronizar distintos procesos, como Mutex, Semaphore y EventWaitHandle.

El resto de enlaces, a continuación.

Por si te lo perdiste...

¡Cuidado con las excepciones no controladas de servicios en segundo plano (BackgroundService) en ASP.NET Core!
José M. Aguilar
Antipatrones de asincronía en C#
José M. Aguilar

.NET

.NET 11 Preview 2 is now available!
.NET Team
Splitting the NetEscapades.EnumGenerators packages: the road to a stable release
Andrew Lock
FullJoin in .NET 11
Steven Giesel
.NET Synchronisation APIs - Part 2 - Out-of-Process Synchronisation
Ricardo Peres

ASP.NET Core / ASP.NET / Blazor

Minimal APIs: Fix missing OpenAPI response documentation
David Grace
How to Create Fillable PDF Forms in C# for Server-Side .NET Apps
Arun Kumar Chandrakesan
How to use refresh tokens in ASP.NET Core
Joydip Kanjilal
Secure a C# MCP Server with Auth0
Andrea Chiarelli
Minimal APIs After the Hype: What Remains When Boilerplate Is Gone?
Bipin Joshi

Azure / Cloud

Invite Guest users in a Entra ID Multi-tenant setup
Damien Bowden
Protecting Against Concurrent Updates in Azure Blob Storage with ETags
Mark Heath

Conceptos / Patrones / Buenas prácticas

Querying and Performing Transactions Across Multiple Database Schemas in a Modular Monolith
Anton Martyniuk
Nobody Runs Your Cleanup Script (And Regulators Know It)
Martin Stühmer
Async Does Not Mean Scalable
Irina Scurtu
Your Stack Traces Are Love Letters to Attackers
Martin Stühmer
5 Architecture Tests You Should Add to Your .NET Projects
Milan Jovanović
Vertical Slices doesn’t mean “Share Nothing”
Derek Comartin

Data

EF Core: tu query funciona, tus pruebas pasan… y estás leyendo 50,000 filas para devolver 3
Isaac Ojeda
SQL Server TempDB: What it is and how it works
M. A. A. Mehedi Hasan
IDENTITY vs SEQUENCE in SQL Server - which should you use?
Greg Low
SQL String Functions for Data Transformation
Muhammad Hassan Arshad
Fixing SQL Server 2025 LocalDB in Visual Studio 2026: Enabling REGEXP and VECTOR Support
Erik Ejlskov Jensen

Machine learning / IA

El nuevo paradigma de la Ingeniería de Software con IA
Juan Irigoyen
MCP Vulnerabilities Every Developer Should Know
Composio
Build a real-world example with Microsoft Agent Framework, Microsoft Foundry, MCP and Aspire
Justin Yoo
Quadratic Regression with SGD Training Using JavaScript
James McCaffrey

Web / HTML / CSS / Javascript

Source Maps: Shipping Features Through Standards
Jon Kuperman
Abusing Customizable Selects
Patrick Brosset
Temporal: The 9-Year Journey to Fix Time in JavaScript
Jason Williams
The Value of z-index
Amit Sheen
Form-Associated Custom Elements in Practice
Rob Levin
The Enforced Accessibility of the Geolocation Element
Chris Coyier
The WebAssembly Component Model
Bytecode Alliance
Beyond border-radius: What The CSS corner-shape Property Unlocks For Everyday UI
Brecht De Ruyte
Vite 8.0 is out!
Vite Team
Moving From Moment.js To The JS Temporal API
Joe Attardi
Make custom elements behave with scoped registries
Jayson Chen & Patrick Brosset
Using CSS animations as state machines to remember focus and hover states with CSS only
Patrick Brosset
NoJS 3 - The dawn of Flappy Bird. Making a Flappy Bird clone using pure HTML and CSS, no JavaScript
Gurveer Arora
The Web’s Most Tolerated Feature
Mike Pennisi

Visual Studio / Complementos / Herramientas

Kubernetes soluciona el caos de la programación de pods con su nuevo controlador de nodos
CampusMVP
Mi configuración de Dev Container para desarrollar plugins de WordPress
Gisela Torres
Extend your coding agent with .NET Skills
Tim Heuer
Modernize .NET Anywhere with GitHub Copilot
Mika Dumont
Configuring Claude Code for Real .NET Projects
Matt Mattei

.NET MAUI

Build a Profile Picture Editor in .NET MAUI with the Image Editor
Karthick Mani
5 UX Tips for .NET MAUI Developers
Leomaris Reyes

Publicado en Variable not found.

Enlaces interesantes 640

2026-03-09T08:05:00.027+01:00

Ya he publicado los enlaces a contenidos interesantes que he ido descubriendo a lo largo de la semana pasada 😊

En esta entrega, destacamos el repaso de Martin Stühmer a los errores más comunes en la gestión de sesiones en aplicaciones ASP.NET Core y cómo evitarlos para mejorar su seguridad de nuestras aplicaciones.

Se ha lanzado la versión 1.0 del SDK oficial de MCP para C#. Aún no he tenido tiempo de probarlo, pero así al vistazo parece que puede facilitarnos un poco la vida a la hora de integrar nuestras aplicaciones con modelos de lenguaje y otros servicios de IA.

Y seguimos con más lanzamientos, Jetbrains han anunciado ReSharper para Visual Studio Code, Cursor y editores compatibles. Como fan incondicional de esta herramienta desde hace años, me alegra que ahora esté también disponible más allá de Visual Studio.

Por último, Gerson Azabache nos recuerda la importancia de hacer ejercicio, especialmente para los desarrolladores, que pasamos muchas horas sentados frente al ordenador y a menudo descuidamos nuestra salud física.

Muchos más enlaces a contenidos interesantes, a continuación.

Por si te lo perdiste...

.NET

Why IEnumerable Can Kill Performance in Hot Paths
Ali Hamza Ansari
Creating case-sensitive folders on Windows using C#
Gérald Barré
Writing a .NET Garbage Collector in C#
Kevin Gosse

ASP.NET Core / ASP.NET / Blazor

YARP as API Gateway in .NET: 7 Real-World Scenarios You Should Know
Anton Martyniuk
TryParse error when using Minimal APIs
Bart Wullems
How to secure ASP.NET Core APIs with Basic Authentication
David Grace
Stop Re-Entering Your Token in Swagger UI: EnablePersistAuthorization in ASP.NET Core
Juan Luis Guerrero
Rate Limiting IdentityServer Endpoints
Maarten Balliauw
Cleaner Minimal API Endpoints with [AsParameters]
Bart Wullems
Customizing the New ReconnectModal Component in Blazor 10
Héctor Pérez
Your Logout Button Is Lying: ASP.NET Session Security Done Right
Martin Stühmer

Azure / Cloud

Azure Trusted Signing Revisited with Dotnet Sign
Rick Strahl
Introducing GPT-5.4 in Microsoft Foundry
Naomi Moneypenny

Conceptos / Patrones / Buenas prácticas

Data

How C# Strings Silently Kill Your SQL Server Indexes in Dapper
Kevin W. Griffin
Managing multiple SQL Server instances from SQL Server Management Studio
Bart Wullems

Machine learning / IA

GPT-5.3 Instant: conversaciones cotidianas más fluidas y útiles & Introducing GPT-5.4
OpenAI
Decision Trees
Jared Wilber & Lucía Santamaría
So whats the next word, then?
Matthias Kainer
Give Your Agents Domain Expertise with Agent Skills in Microsoft Agent Framework
Sergey Menshykh
Release v1.0 of the official MCP C# SDK
Mike Kistler
Model Context Protocol (MCP): Building AI Integrations in .NET Using the C# SDK
Arulraj Aboorvasamy
MicrosoftDocs/Agent-Skills: Curated Agent Skills for Microsoft & Azure – giving AI coding assistants structured, real-time expertise from Microsoft Learn docs
Microsoft

Web / HTML / CSS / Javascript

TanStack Query en Angular: caché y rendimiento
David Filipe Lopes
Announcing TypeScript 6.0 RC
Daniel Rosenwasser
Popover API or Dialog API: Which to Choose?
Zell Liew
Navigation API - a better way to navigate, is now Baseline Newly Available
Ray Rungta
The Odometer Effect (without JavaScript)
Preethi Sam
New to the web platform in February
Rachel Andrew
Quick tip: hosting HTML/CSS/JS demos from source code on GitHub Pages
Christian Heilmann
You can use newline characters in URLs
Daniel Lemire
Security Advisory: Addressing Recent Vulnerabilities in Angular
Angular Team
Sticky Grid Scroll: Building a Scroll-Driven Animated Grid
Theo Plawinski
Singleton or Not? Understanding Angular Services
Dhananjay Kumar
The Different Ways to Select <html> in CSS
Daniel Schwarz
The Big Gotcha of Anchor Positioning
Chris Coyier

Visual Studio / Complementos / Herramientas

From idea to pull request: A practical guide to building with GitHub Copilot CLI
Ari LiVigni
ClockTray – Hide or Show Your Windows Clock with One Click (yes, in C#)
Bruno Capuano
ReSharper for Visual Studio Code, Cursor, and Compatible Editors Is Out
Sasha Ivanova & Alexander Kurakin

.NET MAUI

How to Stream Real-Time Data into a .NET MAUI DataGrid Using Firebase
Shalini Suresh
.NET 10: Secondary Toolbar Items for iOS, macOS in .NET MAUI
Leomaris Reyes

Otros

¿Quieres programar mejor? Empieza por entrenar tu cuerpo
Gerson Azabache Martínez
Crawling a billion web pages in just over 24 hours
Andrew Chan

Publicado en Variable not found.

C# bizarro, episodio 7: crisis de identidad

2026-03-03T08:05:00.006+01:00

Vamos con una entrega más (siete llevamos ya) de la serie C# bizarro, estos divertidos posts donde ponemos a prueba nuestros conocimientos del lenguaje mientras exploramos algunas de sus características extrañas o poco conocidas.

En esta ocasión, os propongo que le echéis un vistazo al siguiente código, en especial a su método ChangeIdentity(), que pretende cambiar la identidad de una persona por la de otra que le llega como parámetro:

var john = new Person() { Name = "John" };
var peter = new Person() { Name = "Peter" };

john.ChangeIdentity(peter);
Console.WriteLine(john.Equals(peter));

struct Person
{
    public string Name;

    public void ChangeIdentity(Person otherPerson)
    {
        this = otherPerson; // WFT!?!?
    }
}

En efecto, en el cuerpo del método estamos asignando un nuevo valor a this. ¿Pensáis que esto compilará? Y en caso afirmativo, ¿qué veríamos en la consola al ejecutarlo, true o false?

Deteneos un poco en el código y pensad en la respuesta, que, aunque tiene algo de truco, seguro que podéis encontrarla porque no es muy retorcida. Pero si se resiste o no lo tenéis claro, siempre podréis pulsar aquí para leer la solución 👇👇

El código, efectivamente, compila sin problema. Aunque la asignación de this pueda parecer extraña, es perfectamente válida en C# porque estamos en el interior del método de instancia de una estructura. No compilaría, en cambio, si Person fuera una clase.

Esto se debe a que internamente las estructuras son tipos valor, por lo que this representa una copia completa del valor de la estructura en memoria. Al asignar this = otherPerson, estamos copiando el valor de otherPerson sobre this, lo que en la práctica significa que estamos copiando el valor de todos los campos de la estructura origen sobre la actual, aunque sin tener que hacerlo de forma manual 🙂

En clases, sin embargo, this es una referencia (o puntero) inmutable a la instancia del objeto en memoria, por lo que no se puede reasignar para ponerla apuntando a otro objeto.

Ahora vamos con la segunda parte de la pregunta, ¿qué veremos en la consola al ejecutar el código que utiliza el método ChangeIdentity()?

var john = new Person() { Name = "John" };
var peter = new Person() { Name = "Peter" };

john.ChangeIdentity(peter);
Console.WriteLine(john.Equals(peter));

Seguro que habéis adivinado que la respuesta es true. Fijaos que si hubiésemos utilizado clases en lugar de estructuras, el resultado habría sido false, ya que john y peter serían punteros a objetos distintos en memoria y la igualdad por referencia nunca sería cierta. Pero al ser estructuras, la comprobación de igualdad se realiza por valor, es decir, comparando los valores de todos sus campos.

Y dado que anteriormente hemos copiado los valores de todos los campos de peter sobre la estructura john, ambos objetos son idénticos en memoria y, por tanto, la operación de comparación devuelve true.

Qué, ¿lo habíais adivinado? 😄

Publicado en Variable not found.

Enlaces interesantes 639

2026-03-02T08:01:00.027+01:00

Una semana más, vamos con los enlaces a contenidos interesantes que he ido recopilando durante estos días, entre los que destaco algunos posts.

Juan Irigoyen comparte sus experiencias utilizando IA para optimizar SQL Server, en un interesante recorrido por la preparación de un agente Claude capaz de analizar y optimizar consultas SQL, con resultados bastante prometedores.

La depuración puede ser una labor compleja, intensa, a veces frustrante y otras gratificante, pero sin duda forma parte de nuestro día a día. En este artículo, Jeremy D. Miller reflexiona sobre el proceso de depuración, compartiendo consejos para abordar los problemas de manera efectiva-

Y para terminar, una frikada épica a la que llego a través de Microsiervos: un procesador x86 completo implementado únicamente con CSS, sin una sola línea de código JavaScript, y que es capaz de ejecutar código ensamblador compilado para ese procesador.

El resto de contenidos interesantes, a continuación.

Por si te lo perdiste...

Trocear predicados para mejorar la legibilidad
José M. Aguilar
Shadow properties en Entity Framework Core
José M. Aguilar

.NET

Logging Profesional en .NET con Serilog: Minimalismo Bien Hecho
Gerson Azabache Martínez
When to Use Builder Pattern in C#: Decision Guide with Examples
Nick Cosentino
A smarter way to learn .NET without reading the docs
David Grace
.NET 11 Preview 1 Arrives with Runtime Async, Zstandard Support, and C# 15 Features
Almir Vuk
Recording metrics in-process using MeterListener
Andrew Lock
Cleaner switch expressions with pattern matching in C#
Bart Wullems
Vector Data in .NET - Building Blocks for AI Part 2
Jeremy Likness
Is it faster to index into an array or use switch statement for lookups?
Jiří Činčura
Semantic Kernel in C#: Complete AI Orchestration Guide
Nick Cosentino
.NET Synchronisation APIs - Part 1
Ricardo Peres
Brave new C#
PVS-Studio
Developing an MCP Server with C#: A Complete Guide
NDepend Team

ASP.NET Core / ASP.NET / Blazor

Cookie Banners Won't Save You From ISO 27701
Martin Stühmer
Stop Wrestling with JavaScript: htmxRazor Gives ASP.NET Core the Component Library It Deserves
Chris Woodruff

Azure / Cloud

How to Troubleshoot Azure Functions Not Visible in Azure Portal
Vikas Gupta
Optimising AI Costs with Microsoft Foundry Model Router
Lee Stott

Conceptos / Patrones / Buenas prácticas

Rename, para entender mejor
Fran Iglesias
Read Replicas Are NOT CQRS (Stop Confusing This)
Peter Ritchie
How to Avoid Code Duplication in Vertical Slice Architecture in .NET
Anton Martyniuk
TDD as induction
Mark Seemann
On Debugging Problems
Jeremy D. Miller

Data

Optimización en Sql Server usando IA
Juan Irigoyen
Emulating GETDATE() on Azure SQL Database
Joe Obbish
Polymorphic Relationships in EF Core: Three Approaches
Ali Hamza Ansari
The Hidden Work Behind SELECT TOP in SQL Server
Jared Westover

Machine learning / IA

Primeros pasos con Microsoft Agent Framework: construyendo un chatbot de soporte con C#
Isaac Ojeda
Microsoft Agent Framework is Release Candidate! Let’s Go
Bruno Capuano
Redefining the Software Engineering Profession for AI
Mark Russinovich & Scott Hanselman
[TIP] How to Add MCP Servers to Claude Code and Gemini CLI on Windows
Juan Luis Guerrero

Web / HTML / CSS / Javascript

Playing CSS-defined animations with JavaScript
Ben Hatsor
Loading Smarter: SVG vs. Raster Loaders in Modern Web Design
Mariana Beldi
Virtual Scroll-Driven 3D Scenes
Gunnar Bachelor
Goodbye innerHTML, Hello setHTML: Stronger XSS Protection in Firefox 148 - Mozilla Hacks
Tom Schuster, Frederik Braun & Christoph Kerschbaumer
A Complete Guide to Bookmarklets
Declan Chidlow
An Exploit ... in CSS?!
Lee Meyer
A Guide to Jakob’s Law in Web Development
Adrew Peterson
React 19 Suspense for Data Fetching: A New Model for Async UI
Prashant Yadav
We deserve a better streams API for JavaScript
James M. Snell
Yet Another Way to Center an (Absolute) Element
Juan Diego Rodríguez
The Hidden Trick of Style Queries and if()
Temani Afif
Building Async Page Transitions in Vanilla JavaScript
Valentin Mor

Visual Studio / Complementos / Herramientas

cURL para desarrolladores .NET: guía práctica, real y profesional
Gerson Azabache Martínez
GitHub Copilot CLI is now generally available
GitHub Copilot Team
The Dongle Died at Midnight – WinForms Agent Saved my German Mom's Business Trip
Klaus Loeffelmann
Introducing Agentic UI Builder: Build Complete Enterprise UIs with Syncfusion MCP Servers
Lokeshwaran Ragavan
Run OpenClaw Securely in Docker Sandboxes
Oleg Selajev
XAML.io v0.6: Share Running .NET Code With a Link
XAM.io Team
Stop Drawing Architecture Diagrams Manually: Meet the Open-Source AI Architecture Review Agents
Shivam Goyal
VS Code: Building Long-Distance Next Edit Suggestions
Vikram Duvvur, Gaurav Mittal & Benjamin Simmonds

.NET MAUI

Simplifying Grid Layout in .NET MAUI Using Extension Methods
Leomaris Reyes
C# Expressions in XAML: throw out your converters
Steven Thewissen
How to Add Email and Toast Reminders to a .NET MAUI Scheduler
Yuvaraj Gajaraj

Otros

What is egoless programming?
Ivan Kranjec
x86 CPU made in CSS
Lyra Rebane

Publicado en Variable not found.

Enlaces interesantes 638

2026-02-23T08:02:00.030+01:00

Otra semana de contenidos interesantes en la web 🙂

Según Milan Milanović, solo 3–4 horas al día son realmente productivas al programar, porque el resto del tiempo se pierde por límites cognitivos, reuniones e interrupciones. Si conseguimos optimizar ese tiempo, mejorará nuestro rendimiento y la calidad del software que desarrollemos, mucho más que intentar trabajar más horas.

Bruno Capuano nos habla sobre la generación de embeddings, tanto de texto como de imágenes, en nuestro equipo local, y nos presenta una biblioteca de código abierto que ha desarrollado para facilitar esta tarea en .NET.

¿En qué se diferencian las colecciones Readonly de las Immutables? ¿Y qué son las colecciones Frozen? Pues aunque parezcan lo mismo, Davide Bellone nos muestra que son cosas muy diferentes.

La primera preview de .NET 11 ya trae algunas novedades interesantes. Steven Giesel nos muestra que el nuevo runtime async es una realidad, y que va a mejorar mucho el rendimiento de las aplicaciones asíncronas.

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

Por si te lo perdiste...

Propiedades semi-automáticas en C#
José M. Aguilar
Evaluación en cliente de EF Core: sus peligros y cómo evitarla
José M. Aguilar

.NET

Logging profesional en .NET: Diseña Telemetría, no Prints
Gerson Azabache Martínez
Collection Expression Arguments in C# 15 are "out"
Steven Giesel
Writing a native VLC plugin in C#
Martin Finkel
Introducing the Coding Agent Explorer (.NET)
Tore Nestenius
New runtime async is hitting .NET 11
Steven Giesel
Exploring .NET 11 Preview 1 Runtime Async: A dive into the Future of Async in .NET
Laurent Kempé
How to Implement Abstract Factory Pattern in C#: Step-by-Step Guide
Nick Cosentino
Creating standard and "observable" instruments
Andrew Lock
Readonly vs Immutable vs Frozen in C#: differences and (a lot of) benchmarks
Davide Bellone
Deep C# - Multicast Delegates and Events
Mike James
T4 templates on modern .NET
Ian Griffiths
Getting Started with .NET Scheduling in Hangfire
Peter Ritchie
NuGet Packages: The Suppliers You Forgot to Audit
Martin Stühmer

ASP.NET Core / ASP.NET / Blazor

Swagger's missing in .NET 10
David Grace
What's new for the Microsoft Fluent UI Blazor library 4.14
Vincent Baaij
Add application security to the swiyu generic management verifier APIs using OAuth
Damien Bowden
ASP.NET Core with Needlr: Simplified Web Application Setup
Nick Cosentino
How to Set Up Production-Ready Monitoring With ASP.NET Core Health Checks
Anton Martyniuk
Creating Drag-and-Drop ListBoxes in Blazor
Héctor Pérez
Building Real-World Web Apps with ASP.NET Core Razor Pages
David Ramel

Azure / Cloud

Your Azure SQL Is Public Right Now. ISO 27017 Demands You Fix It
Martin Stühmer

Conceptos / Patrones / Buenas prácticas

Timsort Algorithm
Neo Kim

Data

SQL Server Long-Running Query Detection: How to Find and Monitor Slow Queries
Edward Pollack
ASP.NET Core warmup EF Core
Karen Payne

Machine learning / IA

Presentamos GPT‑5.3‑Codex‑Spark
OpenAI
Gemini 3.1 Pro: Announcing our latest Gemini AI model
Gemini Team
Local Embeddings in .NET — The Easy Way & Building RAG in .NET with Local Embeddings — 3 Approaches, Zero Cloud Calls & * Local Image Embeddings in .NET — CLIP + ONNX
Bruno Capuano
The Most Popular AI Tools: What Developers Use and Why
Conrad Schwellnus
WebMCP – a much needed way to make agents play with rather than against the web
Christian Heilmann
I Intercepted 3,177 API Calls Across 4 AI Coding Tools. Here's What's Actually Filling Your Context Window.
Lars de Ridder
Decision Tree Regression from Scratch Without Pointers or Recursion Using C#
James McCaffrey
Microsoft Agent Framework Reaches Release Candidate
Shawn Henry
Migrate your Semantic Kernel and AutoGen projects to Microsoft Agent Framework Release Candidate
Dmytro Struk & Shawn Henry

Web / HTML / CSS / Javascript

Accesibilidad web 2026: WCAG 2.2, IA y ley europea
Marco Romero
Performance-Optimized Video Embeds with Zero JavaScript
Stefan Bauer
jQuery 4.0.0 Support: What’s New + Kendo UI Has You Covered
Nikolay Penev
Fun with TypeScript Generics
Adam Rackis
Anchored Menus and a Lesson in Scoping
Chris Coyier
Optimizing JavaScript for the Edge Runtime
Jonathan Gamble
Justifying text-wrap: pretty
Alex Kladov
Choosing a React Animation Library: Performance Trade-Offs in Real Apps
Sumankumar G.
Spiral Scrollytelling in CSS With sibling-index()
Lee Meyer
Interop 2026
Geoff Graham
New to the web platform in January
Rachel Andrew
Three Plug-N-Play CSS Libraries
Raymond Camden
Distinguishing "Components" and "Utilities" in Tailwind
Zell Liew
Angular 21: Internal Mechanics, ARIA, and AI-Powered Coding!
Angular Team
API Security Best Practices: A Developer’s Guide to Protecting Your APIs
The Postman Team
Potentially Coming to a Browser :near() You
Daniel Schwarz
Death to Scroll Fade!
Chris Coyier

Visual Studio / Complementos / Herramientas

Tus contenedores no son tan seguros como crees: estrategias de mitigación para Docker y Kubernetes
CampusMVP
Dear Copilot, can you help me with SQL?
Thiago Henrique da Silva

.NET MAUI

.NET 11 Preview for .NET MAUI: Simplify XAML with Inline C# Expressions
Sri Radhesh Nag Subash Sankar

Otros

Autómatas victorianos, gargantas de cuero y redes neuronales: Anatomía secreta de las máquinas parlantes
María Gómez
You can code only 4 hours per day. Here’s why.
Milan Milanović
SaaSpocalipsis: el mercado ya ha descontado algo que muchos desarrolladores aún no han interiorizado
Alberto Díaz Martín

Publicado en Variable not found.

Lambdas estáticas en C#: cómo y cuándo usarlas

2026-02-17T08:05:00.002+01:00

No es algo que se utilice habitualmente, y a veces incluso es un detalle desconocido por los desarrolladores, pero las funciones lambda de C# pueden ser estáticas. Y no es porque sea algo nuevo, pues esta característica se introdujo en la versión 9.0 del lenguaje en 2020... simplemente son esos pequeños detalles que se van añadiendo al lenguaje sin hacer mucho ruido, y que a veces pasan desapercibidos.

De hecho, el uso de lambdas estáticas puede ayudarnos a escribir un código más seguro y predecible, además de tener cierto impacto en el rendimiento de nuestras aplicaciones, por lo que merece la pena conocerlas y saber cuándo y cómo usarlas.

En este post vamos a ver qué son las lambdas estáticas, cómo se implementan y cuándo y por qué deberíamos usarlas.

Lambdas estáticas

Al igual que ocurre con los métodos o funciones en C#, las funciones lambda pueden ser estáticas, es decir, pueden vivir fuera del contexto de una instancia de clase, y se implementan simplemente añadiendo la palabra clave static delante de la definición de la lambda:

var suma = static (x, y) => x + y;

Esto mismo podemos verlo en escenarios más complejos, como en consultas LINQ sobre colecciones u orígenes de datos, ya sea usándolas como delegados o bien como árboles de expresión:

int[] nums = [1, 2, 3, 4, 5];
var sum = nums.Where(static x => x % 2 == 0).Sum(); // Suma los pares
Console.WriteLine(sum); // Imprime 6

En cualquier caso, la declaración de una lambda como estática hace que aparezcan ciertas restricciones en su implementación. En primer lugar, las lambdas estáticas no pueden capturar variables de instancia, pues no tienen acceso a this ni a las variables o métodos de instancia de la clase en la que se definen.

Tampoco pueden capturar variables locales ni parámetros del método que las contiene, a menos que se pasen explícitamente como argumentos.

En otras palabras, deben ser funciones puras, que dependen únicamente de sus parámetros de entrada.

Esto, que a priori puede parecer una limitación, en realidad es una de las principales ventajas de las lambdas estáticas, ya que, al no depender de ningún factor externo, su comportamiento será más predecible y fácil de implementar y depurar.

Observa por ejemplo el siguiente caso, en el que la lambda duplicate captura la variable factor del contexto que la contiene, y hace que su valor dependa de ella:

int factor = 2;
var duplicate = (int x) => x * factor; // No captura el valor de 'factor', 
                                       // sino la referencia a la variable

Console.WriteLine(duplicate(2)); // Imprime 4
factor = 3;
Console.WriteLine(duplicate(2)); // Imprime 6

Fíjate que aunque llamamos a la lambda duplicate con el mismo parámetro, el resultado es diferente porque la variable factor ha cambiado su valor en el segundo caso.

Esto puede provocar errores difíciles de detectar y depurar. De hecho, el entorno de desarrollo (IDE) nos avisa de que la lambda está capturando una variable del contexto cuyo valor es modificado, por lo que puede provocar efectos inesperados:

Al convertir la lambda en estática, el compilador nos avisará de que no puede capturar variables del contexto, por lo que nos veremos obligados a usar constantes o bien a pasar los valores como parámetros; en cualquiera de los dos casos, la lambda será siempre una función pura y su comportamiento será totalmente predecible:

int factor = 2;
var duplicate = static (int x) => x * factor; // Error CS8820: A static anonymous function
                                              // cannot contain a reference to 'factor'.

var duplicate = static (int x) => x * 2; // Correcto, factor es un valor constante
var multiply = static (int x, int factor) => x * factor; // Correcto, factor se pasa como parámetro

Pero además, es importante saber que, cuando se invoca una lambda que captura alguna referencia externa, el compilador genera un objeto de cierre (o closure) para almacenar esas referencias, lo que implica una sobrecarga adicional en tiempo de ejecución y un mayor consumo de memoria.

Por tanto, cuando usemos lambdas estáticas, además de tener un código más seguro y determinista, podemos estar seguros de que no se generará ningún objeto de cierre, por lo que el rendimiento y consumo de memoria serán óptimos.

Benchmarks

El impacto del uso de objetos de cierre en el rendimiento y consumo de memoria puede ser significativo en escenarios donde se usan muchas lambdas que capturan referencias, como en bucles o en operaciones con colecciones. Esto puede verse en el siguiente resultado de un benchmark, donde comparamos cuatro escenarios diferentes:

una lambda normal sin capturas,
otra lambda normal que captura una propiedad de instancia,
una tercera que captura una variable local,
y una lambda estática sin capturas.

| Method                       | Mean      | Error     | StdDev    | Median    | Gen0   | Allocated |
|----------------------------- |----------:|----------:|----------:|----------:|-------:|----------:|
| NormalLambdaWithNoCapture    | 0.0031 ns | 0.0033 ns | 0.0027 ns | 0.0023 ns |      - |         - |
| NormalLambdaWithCapture      | 4.8063 ns | 0.0654 ns | 0.0612 ns | 4.8035 ns | 0.0077 |      64 B |
| NormalLambdaWithLocalCapture | 7.0980 ns | 0.1036 ns | 0.0969 ns | 7.0805 ns | 0.0105 |      88 B |
| StaticLambda                 | 0.0039 ns | 0.0035 ns | 0.0033 ns | 0.0046 ns |      - |         - |

Lo primero que llama la atención es que las lambdas normales que capturan referencias (ya sean de instancia o locales) son muchísimo más lentas que las que no capturan nada, y además generan consumo de memoria (reservan memoria en el heap y provocan recolecciones de basura).

Las lambdas que no capturan referencias prácticamente consiguen el mismo rendimiento, con una diferencia inapreciable. Y, eso sí, ninguna de las dos genera sobrecarga ni consumo de memoria.

Entonces, ¿cuándo deberíamos usar lambdas estáticas?

En general, salvo que necesitemos capturar referencias del contexto, será conveniente utilizar lambdas estáticas siempre, ya que nos aseguramos de que nuestro código es más seguro y predecible, sin perder en eficiencia o consumo de memoria.

Publicado en Variable not found.

Enlaces interesantes 637

2026-02-16T08:05:00.057+01:00

Mucho contenido interesante en la recopilación de enlaces de esta semana, entre los que me gustaría destacar algunas lecturas a las que, como mínimo, vale la pena echar un vistazo.

Ha llegado la primera preview de .NET 11, con un buen puñado de novedades en el runtime, librerías, SDK, C#, ASP.NET y Blazor. En el post del anuncio oficial podéis encontrar el listado completo y enlaces para profundizar en cada una de ellas.

Tenemos un doblete de Ricardo Peres sobre Entity Framework Core. Primero, profundiza en la forma de mapear distintos tipos de relaciones y las novedades que se han introducido en las últimas versiones para facilitar esta tarea, y luego nos habla sobre la validación de estado de entidades en este framework.

GitHub Copilot es indudablemente una herramienta alucinante, pero a veces no es fácil saber qué modo de uso es el más adecuado para cada tarea. José Manuel Alarcón nos lo explica en este artículo.

Y siguiendo con dobletes, el mismo autor nos trae un interesante artículo analizando cómo determinadas narrativas negativas amplificadas en redes sociales pueden generar frustración y malas decisiones en desarrolladores júnior, y propone estrategias prácticas para reconocer ese sesgo y protegerse de él.

Por último, James Randall comparte cómo ha cambiado la programación en 40 años y cómo ha cambiado también su relación con ella. Si tienes ya unos añitos, probablemente te sentirás identificado.

El resto de enlaces, a continuación.

Por si te lo perdiste...

Invalidar el contenido cacheado por el tag helper "cache" de ASP.NET Core MVC
José M. Aguilar
Abrir Gmail y Google Calendar con una cuenta específica, y cómo anclarlos en la barra de tareas de Windows
José M. Aguilar

.NET

.NET 11 Preview 1 is now available!
.NET Team
Autentication y Authorization en .NET
Fernando Escolar
Abstract Factory vs Factory Method Pattern in C#: Key Differences Explained
Nick Cosentino
Global Phone Number and Postal Code Validation Made Easy
David McCarter
Implementing strongly-typed IDs in .NET for safer domain models
Ali Hamza Ansari
How to Start a New .NET Project in 2026
Anton Martyniuk
Automatic Service Discovery in C# with Needlr: How It Works
Nick Cosentino
Writing a .NET Garbage Collector in C# - Part 7: Marking handles
Kevin Gosse

ASP.NET Core / ASP.NET / Blazor

ASP.NET Core Security Explained: Modern Authentication, Authorization, and JWT
Arulraj Aboorvasamy
Isolate the swiyu Public Beta management APIs using YARP
Damien Bowden
Secure Image Uploads in Blazor Rich Text Editor Using JWT
Saravanan G.
Customizing Validation Messages in Blazor Forms
Héctor Pérez
Mastering the ASP.NET Core Request Pipeline: Middleware, Endpoint Filters, and Scalable API Architecture
Sudhir Mangla
Implementing Zero Trust with Resource Isolation
Maarten Balliauw
Announcing Blazorise 2.0
Mladen Macanović

Azure / Cloud

Cloudflare for Startups: Hasta 250.000 USD en servicios para tu proyecto
Chema Alonso
Announcing Application Insights SDK 3.x for .NET
MattMC

Data

Cuando usar FindAsync o FirstOrDefaultAsync en EF Core
Gerson Azabache Martínez
Modern Mapping with EF Core & EF Core State Validation
Ricardo Peres
How LeftJoin and RightJoin Work in EF Core .NET 10
David Grace
Entity Framework Core 10 provider for Firebird is ready
Jiří Činčura
SQL SERVER – Execution Plans and Indexing Strategies – Quick Guide
Pinal Dave
Azure SQL’s Native JSON Type: Optimized for Performance
Shrusti Kolsur
Stop Hoarding Personal Data in Entity Framework
Martin Stühmer

Machine learning / IA

Haz que tus custom agents sean subagents de GitHub Copilot
Gisela Torres
Building an AI Skills Executor in .NET with Azure OpenAI
Rand Random
Microsoft Agent Framework: Exposing an Existing AI Agent as an MCP Tool – Jamie Maguire
Jamie Maguire
Testing ads in ChatGPT
OpenAI

Web / HTML / CSS / Javascript

Announcing TypeScript 6.0 Beta
Daniel Rosenwasser
Trying to Make the Perfect Pie Chart in CSS
Juan Diego Rodríguez
What to Expect in Angular 22
Kelly Vatter
Integrating HTMX with React and Next.js for Dynamic HTML Updates
Satheeskumar S.
How to Open and Render DOCX Files in the Browser with React
Ramkumar Ravy
Approximating contrast-color() With Other CSS Features
Kevin Hamer
Image Optimization in Angular Applications
Christian Nwamba
Making a Responsive Pyramidal Grid With Modern CSS
Temani Afif

Visual Studio / Complementos / Herramientas

GitHub Copilot: cuándo usar los modos Ask, Edit, Agent y Plan según la tarea
José Manuel Alarcón
5 open-source Windows 11 apps you didn't know you needed
Mauro Huculak
How to Convert an HTML to an EXE file
Alex Marin
GitHub Copilot Testing for .NET Brings AI-powered Unit Tests to Visual Studio 2026
McKenna Barlow
Unlock language-specific rich symbol context using new find_symbol tool
Mike Gine

.NET MAUI

Visualizing Supply Chain Metrics in .NET MAUI with Charts and Gauges
Hariram Subramanian
Why Your .NET MAUI Layout Breaks Across Devices and How to Fix It
Anandh Ganesan
Exploring Compiled Bindings in .NET MAUI
Leomaris Reyes
Building a Support Ticket Dashborad with .NET MAUI DataGrid
Farjana Parveen

Otros

Desarrollador junior y frustrado con tu trabajo: cómo evitar el sesgo de negatividad online
José Manuel Alarcón
I Started Programming When I Was 7. I'm 50 Now, and the Thing I Loved Has Changed
James Randall

Publicado en: www.variablenotfound.com.

Enlaces interesantes 636

2026-02-09T08:02:00.022+01:00

En los enlaces interesantes de esta semana, creo que vale la pena destacar el post de Peter Steinberger anunciando OpenClaw, el nuevo nombre de Moltbot, que a su vez fue un nuevo nombre para Clawd. En cualquier caso, una plataforma abierta que, con sus luces y sus sombras, ha traído aire fresco al mundo de los agentes personales inteligentes alojados en nuestra propia infraestructura.

También, gracias a Kevin W. Griffin, esta semana he descubierto la función COUNT(*) OVER() de SQL Server, que permite obtener el número total de filas en una consulta sin necesidad de hacer una consulta previa adicional, muy útil para paginación de datos.

Teresa Torres, por su parte, ha publicado un post muy interesante explicando cómo funciona ChatGPT, con un lenguaje bastante más accesible para humanos "normales" que lo que solemos encontrar por la red.

Por último, David Grace nos recuerda que nuestras excepciones pueden exponer información sensible que podría ser utilizada por algún desalmado, y cómo evitarlo utilizando herramientas proporcionadas por ASPNET Core.

El resto de enlaces, a continuación.

Por si te lo perdiste...

El código fuente de .NET muy a mano: source.dot.net
José M. Aguilar
Registro y obtención de múltiples implementaciones de servicios en ASP.NET Core, y un caso práctico
José M. Aguilar

.NET

Exploring the (underwhelming) System.Diagnostics.Metrics source generators
Andrew Lock
Automatic Dependency Injection in C#: The Complete Guide to Needlr
Nick Cosentino
.NET Framework 3.5 Moves to Standalone Deployment in new versions of Windows
Tara Overfield & Brett Lopez
Your Encryption Is Broken — .NET Data Protection Done Right
Martin Stühmer
Reliably Refreshing the WebView2 Control
Rick Strahl
Encrypting Properties with System.Text.Json and a TypeInfoResolver Modifier (Part 2)
Steve Gordon

ASP.NET Core / ASP.NET / Blazor / Aspire

Use client assertions in ASP.NET Core using OpenID Connect, OAuth DPoP and OAuth PAR
Damien Bowden
AI-Powered Smart TextArea for ASP.NET Core: Smarter Typing with Intelligent Autocompletion
Arun Kumar Chandrakesan
Getting Started With .NET Aspire 13: Building and Deploying an App With PostgreSQL, Redis, and Docker Compose
Anton Martyniuk
Are exceptions exposing vulnerabilities in your .NET App?
David Grace
Securing Aspire Apps with Microsoft Entra ID
Jean-Marc Prieur

Conceptos / Patrones / Buenas prácticas

Your appsettings.json Is a Compliance Violation
Martin Stühmer
Your Idempotent Code Is Lying To You
Derek Comartin
Hierarchical Navigable Small Worlds
Amandeep Singh

Data

SQL Server Pagination with COUNT(*) OVER() Window Function
Kevin Griffin
I Just Don’t Understand Why You Don’t Update SSMS
Brent Ozar
SQL Concatenate String using Double Pipe (||) Operator in SQL Server 2025
Rajendra Gupta
Enable Soft Delete in Azure SQL
Jerry Nixon

Machine learning / IA

MCP Server como Proxy de otro MCP Server
Gisela Torres
Presentamos la aplicación Codex
OpenAI
Claude Opus 4.6
Anthropic
Introducing OpenClaw
Peter Steinberger
OpenClaw Full Tutorial for Beginners
Beau Carnes
Linear Regression with Pseudo-Inverse Training Using JavaScript
James McCaffrey
How Does ChatGPT Work? A Guide for the Rest of Us
Teresa Torres

Web / HTML / CSS / Javascript / UX

Incremental Hydration in Angular: Build SSR Apps That Feel Instantly Interactive
Ankit Sharma
Build a Full-Featured PDF Editor in Angular for Modern Web Apps
Arun Kumar Chandrakesan
Combobox vs. Multiselect vs. Listbox: How To Choose The Right One
Vitaly Friedman
Making interesting borders with CSS corner-shape
Peter Ritchie
React Basics: Memoization in React
David Adeneye Abiodun
CSS Bar Charts Using Modern Functions
Preethi
Vue Basics: A Comprehensive Guide to Vue 3 Directives
David Adeneye Abiodun
CSS @scope: An Alternative To Naming Conventions And Heavy Abstractions
Blake Lundquist
Why Your UI Won’t Update: Debugging Stale Data and Caching in React Apps
Oluwadamisi Samuel

Visual Studio / Complementos / Herramientas

No-Hassle Visual Studio Code Theming: Building an Extension & Publishing an Extension
Zell Liew
Roadmap for AI in Visual Studio (February)
Rhea Patel
WinGet Configuration: Set up your dev machine in one command
Rob Bernstein

.NET MAUI

Introducing Bindable Property Source Generators
Brandon Minnick
Loading Dynamic Data into a .NET MAUI ComboBox with JSON and REST APIs
Sudarsan Muthuselvan
Replicating a Valentine-Inspired Login UI in .NET MAUI
Leomaris Reyes

Otros

Publicado en Variable not found.

¿Cuántos parámetros son demasiados parámetros?

2026-02-03T08:05:00.001+01:00

Muchas veces habéis escrito métodos o funciones en las que recibís un parámetro, dos parámetros, tres, cuatro... Y seguro que alguna vez habéis llegado a un punto en el que habéis tenido la sensación de que el número de parámetros se os ha ido de las manos. En este momento, estaremos percibiendo el code smell llamado "Long Parameter List" o "Lista de Parámetros Larga", todo un clásico en el aromático arte de la programación ;)

Porque, indudablemente, cuando un método o función recibe demasiados parámetros puede volverse difícil de leer, entender y mantener, y son muy propensos a errores de codificación, sobre todo si los tipos de datos de los parámetros son similares o si su orden no es claro o intuitivo.

Pero, ¿cuántos parámetros son demasiados parámetros? ¿Cinco? ¿Diez? ¿Veinte? Como suele ocurrir, no existe una respuesta única y categórica sobre el tema, aunque sí existen algunas recomendaciones que pueden ayudarnos a tomar una decisión cuando nos enfrentamos a esta situación.

Los problemas de tener demasiados parámetros

Un método o función que recibe demasiados parámetros se considera generalmente un code smell. No es un error en sí mismo, pero suele indicar que algo no está bien diseñado y que probablemente necesite una revisión o refactorización.

El problema más evidente de tener demasiados parámetros es que automáticamente es más difícil de leer y entender. Cada parámetro adicional añade complejidad y puede hacer que el propósito del método o función sea menos claro, lo que puede llevar a confusiones y errores al utilizarlo. También, el código será más extenso, lo que puede extender el aroma a otros smells como Long Method, Primitive obsession, Feature Envy y más fragancias desagradables.

Además, si los parámetros son de tipos similares o tienen nombres poco descriptivos, es fácil que al invocar la función se ordenen de forma incorrecta, lo que en muchos casos puede provocar errores difíciles de detectar y corregir.

Y por supuesto, puede generar problemas de mantenimiento y escalabilidad del código. Si un método o función tiene muchos parámetros, cualquier cambio en su firma (añadir, eliminar o modificar parámetros) puede requerir cambios en múltiples ubicaciones, lo que aumenta la complejidad y el riesgo de introducir nuevos errores.

Pero también tiene implicaciones en el diseño de nuestro software. Usar demasiados parámetros puede ser un indicativo de que estamos violando el principio de responsabilidad única (SRP, por sus siglas en inglés), lo que significa que está haciendo demasiadas cosas a la vez y debería ser dividido en métodos más pequeños y específicos. Podría indicar igualmente una baja cohesión, porque es posible que los parámetros no estén relacionados entre sí y el ámbito del método sea demasiado amplio.

Pero, ¿cuántos parámetros son demasiados?

Como comentaba algo más arriba, no existe una respuesta única y definitiva a esta pregunta, pero sí hay algunas recomendaciones generales que pueden servirnos de guía.

Robert C. Martin, también conocido como "Uncle Bob", sugiere que el número ideal de parámetros es cero. Está claro, si un método no recibe ningún parámetro, no dependerá de ningún dato externo, por lo que no existirá código de validación, ni transformaciones de datos, ni la lógica dependerá de ellos. En definitiva, el método será más simple y directo y, a lo sumo, podrá operar con datos internos de su objeto o valores constantes; el código será más conciso, fácil de leer y entender. Todo ventajas 😉

Sin embargo, en el mundo real es un objetivo difícil de alcanzar, por lo que en la mayoría de escenarios, que nuestros métodos o funciones no tengan parámetros es más una aspiración teórica que otra cosa.

A partir de ese límite ideal, está claro que conforme va creciendo el número de parámetros, la complejidad del método también aumenta, y con ella la dificultad para entenderlo y mantenerlo. En su clásico libro Clean Code, Martin dice que usar más de tres parámetros debería requerir una justificación bien argumentada.

En general, la comunidad de desarrolladores está más o menos de acuerdo en que el ideal es que un método o función no reciba más de 3 o 4 parámetros. A partir de ahí, el código comienza a ser difícil de leer y mantener y es cuando se empieza a considerar que estamos ante un "code smell" que puede traernos problemas.

Steve McConnell, en su libro "Code Complete", establece que el máximo número de parámetros debería rondar los siete, basándose en el número mágico de la psicología cognitiva, propuesto por George A. Miller en 1956, que sugiere que el número de elementos que una persona puede retener en su memoria a corto plazo es de aproximadamente siete (más o menos dos).

Por tanto, la cosa queda así:

Número de parámetros	Comentario
0	Ideal, aunque poco probable
1-3	Bien, fácil de entender y mantener
4-7	Sólo en casos justificados
8+	❌ Evitar a toda costa

Pero ojo, porque, como siempre, existen casos que pueden romper estas reglas generales. Un ejemplo clásico podría ser una función como la siguiente:

public int SumNineNumbers(
    int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9) 
{
    return n1 + n2 + n3 + n4 + n5 + n6 + n7 + n8 + n9;
}

Si su misión es realizar una acción concreta que requiere un determinado número de valores de entrada, ¿sería incorrecto definirla con nueve parámetros? ¿O es lo que esperaríamos, dado el nombre de la propia función? En mi opinión, en este caso estaría totalmente justificado; cualquier refactorización para reducir el número de parámetros sería introducir una complejidad innecesaria.

¿Y qué alternativas tenemos?

Cuando ya estamos ante un método o función que define o va a definir demasiados parámetros, es importante detenernos a pensar cómo podemos mejorarlo.

En primer lugar, debemos preguntarnos por qué nuestro código necesita tantos datos de entrada. ¿Estamos haciendo quizás demasiadas cosas en el mismo método? ¿Tiene demasiadas dependencias? Si es así, es posible que estemos violando el principio de responsabilidad única (SRP) y deberíamos considerar dividirlo en varios más pequeños y específicos.

// Refactorizar esto:
public void ProcessAndNotifyOrder(
    string orderId, string customerName, DateTime orderDate, 
    string notificationEmail, string notificationMessage)
{
    // Lógica para procesar el pedido
    // Lógica para notificar al cliente
}

// A esto:
public void ProcessOrder(string orderId, string customerName, DateTime orderDate)
{
    // Lógica para procesar el pedido
}
public void NotifyCustomer(string notificationEmail, string notificationMessage)
{
    // Lógica para notificar al cliente
}

Pero si realmente necesitamos recibir todos esos argumentos, existen distintas técnicas que pueden ayudarnos a reducir el número de parámetros y evitar problemas.

Por ejemplo, si estamos recibiendo siempre el resultado de haber usado un método, función o propiedad, quizás esa llamada debería realizarse desde dentro de nuestro propio código, como se muestra a continuación:

// Refactorizar esto:
public void Log(string message, string level, string source, DateTime now)
{
    // Lógica para registrar el mensaje
}

// A esto:
public void Log(string message, string level, string source)
{
    DateTime now = DateTime.Now; // Obtenemos el timestamp dentro del método
    // Lógica para registrar el mensaje
}

También, si nuestro método o función recibe parámetros booleanos, deberíamos considerar revisarlo. Como vimos hace tiempo en el post "¿Usar booleanos? ¿Sí, no, a veces?", este tipo de parámetros suele introducir ambigüedad y confusión, ya que no siempre está claro qué significa cada valor. En su lugar, quizás podríamos usar dos funciones diferentes, cada una con un propósito claro y específico:

// Refactorizar esto:
public void Log(string message, string level, string source, bool isError)
{
    // Lógica para registrar el mensaje
}

// A esto:
public void LogInfo(string message, string level, string source)
{
    // Lógica para registrar el mensaje
}
public void LogError(string message, string level, string source)
{
    // Lógica para registrar el mensaje
}

Otra posibilidad, que seguro habréis visto con cierta frecuencia, es el caso de métodos que reciben argumentos procedentes de un mismo objeto. En estos casos, podríamos considerar recibir el objeto completo en lugar de sus propiedades individuales:

// Refactorizar esto:
public void ProcessOrder(
    string orderId, string customerName, string customerEmail, DateTime orderDate)
{
    // Lógica para procesar el pedido
}

// A esto:
public void ProcessOrder(Order order)
{
    // Lógica para procesar el pedido
}

Otra solución bastante habitual es usar la refactorización conocida como Introduce Parameter Object. Esta técnica consiste en agrupar varios parámetros relacionados en un único objeto, lo que reduce el número de parámetros y mejora la legibilidad del código.

Por ejemplo, podemos ver el resultado de aplicar esta técnica en el siguiente código:

// Refactorizar esto:
public Task<IEnumerable<Customer>> GetCustomersAsync(
    int pageNumber, int pageSize, string sortBy, string filter, bool includeInactive)
{
    // Lógica para obtener los clientes
}

// A esto:
public Task<IEnumerable<Customer>> GetCustomersAsync(CustomerQuery query)
{
    // Lógica para obtener los clientes
}

Aparte, si el objeto de parámetros es muy complejo, puede ser útil combinar este enfoque con el patrón Builder, que permite construirlo paso a paso. Por ejemplo, podríamos tener un código como el siguiente:

// Refactorizar esto:
var query = new CustomerQuery
{
    PageNumber = 1,
    PageSize = 20,
    SortBy = "Name",
    IncludeInactive = false,
    IncludeOrders = false,
    IncludeAddresses = true
};
var customers = await GetCustomersAsync(query);

// A esto:
var query = new CustomerQueryBuilder()
    .WithPageNumber(1)
    .WithPageSize(20)
    .SortedByName()
    .IncludeAddresses()
    .Build();
var customers = await GetCustomersAsync(query);

¡Espero que os haya resultado interesante!

Publicado en Variable not found.

Enlaces interesantes 635

2026-02-02T08:05:00.029+01:00

Aquí tenemos la colección de enlaces a contenidos interesantes que he recopilado a lo largo de la semana pasada 🙂

En esta ocasión, me gustaría destacar el artículo de Jose Manuel Alarcón sobre la charla de Demis Hassabis y Dario Amodei, CEOs de Google DeepMind y Anthropic respectivamente, en el Foro Económico Mundial de Davos 2026, donde hablaron sobre la llegada de la AGI y su impacto en el desarrollo de software y otras áreas. Muy interesante.

Continuando con gurús, Anders Hejlsberg, el arquitecto detrás de C# y TypeScript, compartió en una entrevista reciente algunas lecciones aprendidas a lo largo de su carrera: retroalimentación temprana, renunciar a preferencias personales, colaboración abierta y muchas otras.

También vale la pena echar un vistazo al post de Braulio Díez, donde describe la a la que se enfrentan a diario las personas que deciden emprender en el mundo tecnológico, ya sea como autónomos o como empresa. Y es que, muy a menudo, desde fuera solo vemos la punta del iceberg.

Volviendo a terrenos más técnicos, encontramos un artículo de Grant Riordan sobre cómo implementar uniones de tipos seguros en C# utilizando la biblioteca OneOf. Muy útil para quienes buscan mejorar la seguridad de tipos en sus aplicaciones.

Y muy interesante también la extensión Renamifier para Visual Studio, creada por Calvin Allen, que permite renombrar proyectos de forma segura, evitando las tareas manuales y problemas habituales asociados con este proceso.

El resto de artículos, a continuación.

Por si te lo perdiste...

La interfaz IMiddleware: Middlewares tipados per request en ASP.NET Core
José M. Aguilar
Los nuevos métodos LINQ en .NET 9: CountBy(), AggregateBy() e Index()
José M. Aguilar

.NET

Missed these 12 new C# features?
David Grace
How to Implement Type Safe Unions in C# With OneOf
Grant Riordan
Passing parameters to a hosted MCP Server in C#
Bart Wullems
Creating and consuming metrics with System.Diagnostics.Metrics APIs
Andrew Lock
Microsoft Agent Framework (Preview): AI Agent Development for .NET
Arulraj Aboorvasamy
Introducing OpenSilver 3.3: Blazor Components Now Run Directly Inside XAML Applications
OpenSilver Team
.NET AI Essentials - The Core Building Blocks Explained
Jeremy Likness
Building an MCP App with C# – A Color Picker Sample
Bruno Capuano
Internationalization Architecture for Global .NET Applications
Sudhir Mangla
The Grand Mystery of the Missing 18 Bytes
Steve Gordon

ASP.NET Core / ASP.NET / Blazor

Force step up authentication in web applications
Damien Bowden
Your [Authorize] Attribute Is Compliance Theater
Martin Stühmer
Building a Design System on Top of Blazorise
Mladen Macanović
New in .NET 10 and C# 14: Multi-Tenant Rate Limiting
Ali Hamza Ansari
Getting Started with the Blazor Diagram Component
Héctor Pérez
Audit Logging That Survives Your Next Security Incident
Martin Stühmer
Changing how ASP.NET generates OpenAPI schema names
Tim Deschryver

Azure / Cloud

¿Qué novedades nos trae Azure Local 2601?
David Rivera
.NET 10 Becomes Available on AWS Lambda as Managed Runtime and Base Image
Almir Vuk
Minimum Usage in Azure App Testing
Nikita Nallamothu

Conceptos / Patrones / Buenas prácticas

From pixels to characters: The engineering behind GitHub Copilot CLI’s animated ASCII banner
Aaron Winston
Best Practices for Creating User-Friendly Data Grids
Suzanne Scacca
Patterns of Distributed Systems in C# and .NET: A New Series for People Who Ship Real Systems
Chris Woodruff

Data

Why Every EF Core Developer Needs to Try Entity Framework Extensions
Anton Martyniuk
Modernizing Stored Procedure-Heavy Applications: When to Move Logic to .NET
Sudhir Mangla
Getting Started with SQL Database Project Power Tools
Erik Ejlskov Jensen

Machine learning / IA

Hassabis-Amodei en Davos 2026: El día después de la AGI y su impacto en el desarrollado de software
José Manuel Alarcón
Cyphering Prompts & Answers para evadir Guardarraíles
Chema Alonso
The Hidden Memory Architecture of LLMs
Hazem Ali
Shrinking a language detection model to under 10 KB
David Gilbertson
Google Introduces TranslateGemma Open Models for Multilingual Translation
Daniel Domínguez

Web / HTML / CSS / Javascript

There is No Need to Trap Focus on a Dialog Element
Zell Liew
Unstacking CSS Stacking Contexts
Gabriel Shoyombo
How to Style the New ::search-text and Other Highlight-y Pseudo-Elements
Daniel Schwarz
Vue Basics: Ultimate Guide to Vue 3 Reactivity
David Adeneye Abiodun
ReliCSS
Geoff Graham
How Browsers Work
Dmytro Krasun

Visual Studio / Complementos / Herramientas

Cómo generar changelogs automáticos para tus releases en GitHub
Gisela Torres
Testing your MCP server with Visual Studio HTTP Files
Bart Wullems
Visual Studio January Update
Simona Liao
Visual Studio Enterprise Partner Benefits – a Heads-Up!
Michael Morten Sonne
ReSharper and Rider 2025.3.2 Updates Out Now!
Anna Ruban
ProjectRenamifier: A Visual Studio extension that allows you to safely rename a project
Calvin Allen

.NET MAUI / Cross-platform

Welcoming Web Content to Native Apps
Sam Basu
6 .NET MAUI Properties You Didn’t Know Work with Buttons
Leomaris Reyes

Otros

La punta del Iceberg
Braulio Díez
7 learnings from Anders Hejlsberg: The architect behind C# and TypeScript
Aaron Winston

Publicado en: www.variablenotfound.com.

Enlaces interesantes 634

2026-01-26T08:05:00.032+01:00

La entrega semanal de los enlaces interesantes ya está disponible, con cerca de cincuenta referencias a contenidos a los que creo que merece la pena echar un vistazo.

Y por destacar, en primer lugar, la interesante reflexión de Braulio Díez sobre las nuevas posibilidades y peligros que ofrece la IA generativa en el ámbito de la programación, y algunas predicciones sobre lo que veremos en 2026 a este respecto.

La invalidación de una caché distribuida es un problema complejo. Milan Jovanović nos explica cómo solucionarlo usando Redis e HybridCache.

Davide Bellone abre un interesante debate sobre la necesidad (o no) de usar el sufijo Async en los métodos asíncronos de C#. Yo soy de Async, ¿y tú?

También vale mucho la pena dedicar un ratillo a leer el informe de Cloudflare 2025 Year in Review, donde, desde su privilegiada posición, analizan lo que ven pasar por sus redes. Spoiler: mucho tráfico, mucha IA, mucho ataque DDoS, incremento de uso de encriptación post-cuántica, etc.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

Mejora el rendimiento de HybridCache mediante la reutilización de objetos
José M. Aguilar
El hosting in-process de ASP.NET Core
José M. Aguilar

.NET

.NET 10: Zip and GZip API Improvements
Anthony Giretti
Solving the Distributed Cache Invalidation Problem with Redis and HybridCache
Milan Jovanović
.NET 10: Post-Quantum Cryptography Comes to .NET
Anthony Giretti
.NET 10 and C# 14 — Unbound generic types and nameof
Henrique Siebert Domareski
Making foreach on an IEnumerable allocation-free using reflection and dynamic methods
Andrew Lock
10 Reasons to Upgrade to .NET 10
Anton Martyniuk
Code opinion: why I prefer avoiding the Async suffix in C# asynchronous methods
Davide Bellone
New in .NET 10 and C# 14: Fast Model Validation for APIs
Ali Hamza Ansari
Why ISO Standards Actually Matter for .NET Developers
Martin Stühmer

ASP.NET Core / ASP.NET / Blazor

Modern Authentication in 2026: How to Secure Your .NET 8 and Angular Apps with Keycloak
UnknownX
Implementing Level of Identification (LoI) with ASP.NET Core Identity and Duende
Damien Bowden
Enterprise Patterns for ASP.NET Core Minimal API: Data Transfer Object Pattern
Chris Woodruff
5 Minimal API myths and the real truth
David Grace
Building Webhooks in ASP.NET Core: Delivery Guarantees, Retries, Security, and Scalable Architecture
Sudhir Mangla
Getting Started with the Blazor Skeleton Component
Héctor Pérez
Responsive Layout Strategies Using Blazorise Grid & Breakpoints
Mladen Macanović

Conceptos / Patrones / Buenas prácticas

You Can’t Future-Proof Software Architecture
Derek Comartin

Data

Using ClientConnectionId to Correlate .NET Connection Attempts in Azure SQL
Kalyan Singh Bondili
Announcing GitHub Copilot code completions in SQL Server Management 22.2.1
Erin Stellato

Machine learning / IA

Lo que diga Claudia
Braulio Díez
Introduction to Generative AI: Attention Mechanism
Harris Amjad

Web / HTML / CSS / Javascript

The Wasm Breach: Escaping Backend WebAssembly Sandboxes
InstaTunnel Team
What's new in Next.js 16: Turbo Builds, Smart Caching, AI Debugging
Arulraj Aboorvasamy
The State of WebAssembly – 2025 and 2026
Gerard Gallant
I Learned The First Rule of ARIA the Hard Way
Hashim Quraishi
How Execution Context Works in JavaScript – A Handbook for Devs
Sumit Saha
Create, Edit, and Sign PDFs in JavaScript - No Backend Required
Anand Panchamoorthi
Updated Candidate Recommendation: Web Neural Network (WebNN) API
W3C
CSS in 2026: The new features reshaping frontend development
Jemima Abu
Responsive Hexagon Grid Using Modern CSS
Temani Afif
When will CSS Grid Lanes arrive? How long until we can use it?
Jen Simmons

Visual Studio / Complementos / Herramientas

.NET 10 support in Visual Studio 2022
Mike Irving
Introducing the 'Git Ranger' Visual Studio extension!
Calvin Allen
Top 5 AI Tools for Visual Studio 2026
David Ramel
Now in Public Preview: GitHub Copilot build performance for Windows
David Li
Essential Programmer Utilities
Jesse Liberty
Color‑Driven Code Navigation
Mark Downie
Bringing work context to your code in GitHub Copilot
Kayla Cinnamon
Codex Is Now Integrated Into JetBrains IDEs
Anton Semenkin
Introducing the Azure Cosmos DB Agent Kit: Your AI Pair Programmer Just Got Smarter
Sajeetharan Sinnathurai

.NET MAUI

Building a Gated Multi-Step Wizard in .NET MAUI with Tab View
Sneha Kumar
Adding External Fonts in .NET MAUI
Leomaris Reyes

Otros

What was the secret sauce that allows for a faster restart of Windows 95 if you hold the shift key?
Raymond Chen
Cloudflare Radar 2025 Year in Review
Cloudflare

Publicado en Variable not found.

Usar factorías para devolver la misma instancia desde el contenedor de servicios de .NET

2026-01-20T08:05:00.002+01:00

Normalmente, cuando registramos un servicio en el inyector de dependencias de .NET, lo hacemos una única vez. A veces registramos directamente el servicio, aunque lo habitual es que lo asociemos a una interfaz, de forma que en futuro podamos sustituir la implementación sin tener que cambiar el resto del código:

// Registramos el servicio asociado a una interfaz:
builder.Services.AddScoped<IInvoiceIssuer, InvoiceServices>();

Sin embargo, nada impide que el mismo servicio lo registremos varias veces asociándolo a distintas abstracciones, sobre todo si tenemos nuestras clases de servicio son muy extensas y estamos haciendo segregación de interfaces (la "I" de los principios SOLID):

// Registramos el servicio asociado a varias interfaces, de forma
// que en otros servicios sólo será necesario inyectar la interfaz 
// concreta que necesitemos:
builder.Services.AddScoped<IInvoiceIssuer, InvoiceServices>();
builder.Services.AddScoped<IInvoiceSender, InvoiceServices>();
builder.Services.AddScoped<IInvoicePrinter, InvoiceServices>();
...

Pero fijaos que esto está introduciendo un sutil problema: cada vez que se inyecte una de estas interfaces, se creará una nueva instancia de InvoiceServices, lo cual, además de consumir más recursos, puede ser un problema si a su vez el servicio depende de otros componentes que no puedan o deban ser compartidos:

public class DoSomething
{
    public DoSomething(IInvoiceIssuer issuer, IInvoiceSender sender, IInvoicePrinter printer)
    {
        // Aquí se habrán creado tres instancias de InvoiceServices
    }
}

¿Cómo podemos solucionarlo?

Para estos casos, podemos usar el parámetro implementationFactory que encontramos en los métodos AddScoped(), AddSingleton() y AddTransient() de IServiceCollection. Este parámetro es un delegado que podemos usar para crear la instancia a retornar cuando se requiera un objeto del tipo solicitado. Pero lo más interesante es que, dado que recibe como parámetro una referencia al proveedor de servicios, podemos utilizarlo para obtener la instancia de otro servicio ya registrado:

builder.Services.AddScoped<IInvoiceIssuer, InvoiceServices>(
    services => 
    {
        // Usamos "services" para obtener el servicio ya registrado,
        //  en vez de instanciar uno nuevo cada vez
        ...
    }   
);

En nuestro caso, podríamos registrar el servicio InvoiceServices una única vez de forma genérica, definiendo su tiempo de vida (singleton, scoped, transient) y sin asociarlo a ninguna interfaz concreta. Luego, a la hora de registrar las distintas abstracciones, usar el proveedor de servicios para obtener una instancia del tipo registrado:

// Registramos el servicio una única vez:
builder.Services.AddScoped<InvoiceServices>();

// A continuación, usamos para cada interfaz la factoría, 
// que retorna la instancia del servicio registrado:
builder.Services.AddScoped<IInvoiceIssuer, InvoiceServices>(
    services => services.GetRequiredService<InvoiceServices>()
);

builder.Services.AddScoped<IInvoiceSender, InvoiceServices>(
    services => services.GetRequiredService<InvoiceServices>()
);

builder.Services.AddScoped<IInvoicePrinter, InvoiceServices>(
    services => services.GetRequiredService<InvoiceServices>()
);

Obviamente, si se crean o no instancias nuevas de InvoiceServices dependerá de cómo se haya registrado este servicio en el contenedor de dependencias. Por ejemplo, si está registrada como singleton, se devolverá siempre la misma instancia, independientemente de cómo se haya registrado la interfaz; si es transient, se creará una nueva instancia cada vez que se solicite. En el caso anterior, como se ha registrado como scoped, se devolverá la misma instancia en el ámbito actual (si estamos en una petición ASP.NET Core, mientras ésta esté siendo procesada).

Sencillo, ¿eh?

Publicado en Variable not found.

Enlaces interesantes 633

2026-01-19T08:05:00.031+01:00

Ya tenemos lista la recopilación de enlaces a contenidos que he ido descubriendo a lo largo de la semana pasada. Como siempre, mucha información interesante para seguir aprendiendo y estar al día.

Merece la pena destacar el post de José Manuel Alarcón descubriéndonos por qué muchos desarrolladores usamos el punto y coma, y dónde está su origen.

Muy interesante y curioso el artículo interactivo de Alex Harri sobre la representación de imágenes usando caracteres ASCII, el ASCII-art de toda la vida.

Y me ha llamado la atención el vigésimo aniversario de jQuery, todo un clásico que, aunque ha dejado de ser la opción por defecto para muchos, sigue siendo la biblioteca más usada de la web, y continúa su evolución presentando la versión 4.0.0.

En resto de contenidos, a continuación.

Por si te lo perdiste...

¿Se pueden introducir directivas o lógica de inicialización en todas las vistas y páginas sin duplicar código?
José M. Aguilar
Task.WhenEach() en .NET 9: Procesa tareas conforme se van completando
José M. Aguilar

.NET

Recent updates to NetEscapades.EnumGenerators: new APIs and System.Memory support
Andrew Lock
Mastering Memory Management and Garbage Collection in .NET
Nemorize
Add Headers, Footers, and Page Numbers to PDFs in C#
Chinnu Muniyappan
Generate an Open Graph Profile Image with C#
Joseph Guadagno
Collection Expression Arguments in C# 15+
Steven Giesel
Explaining Contract Tracked Changes Automatically Using .NET C# and AI
Bjoern Meyer
Announcing DotnetPsCmds - PowerShell CmdLets for .NET
Peter Ritchie
Compile Time Checking of String Parameters in C#
Kevin Logan
Deep C# - The Console
Mike James
New in .NET 10 and C# 14: Enhancements in APIs Request/Response Pipeline
Ali Hamza Ansari
Encrypting Properties with System.Text.Json and a TypeInfoResolver Modifier (Part 1)
Steve Gordon

ASP.NET Core / ASP.NET / Blazor

Set the amr claim when using passkeys authentication in ASP.NET Core
Damien Bowden
How Do I Improve Performance in ASP.NET Core APIs?
Mahesh Chand
Enterprise Patterns for ASP.NET Core Minimal API: Lazy Load Pattern & E Front Controller and MVC Pattern
Chris Woodruff
Implementing Level of Authentication (LoA) with ASP.NET Core Identity and Duende
Damien Bowden
Collaborative Editing in Blazor Diagram Using SignalR and Redis
Suganthi Karuppannan
File logging in ASP.NET Core made easy with Serilog
David Grace
Aspire for JavaScript developers
Paulo Pinto
Practical Blazor SSR + WASM Hybrid Architecture for High-Performance .NET Frontends
Sudhir Mangla
Getting Started with the Blazor Inline AI Prompt Component
Héctor Pérez
Building Resilient APIs with the Retry Pattern
Assis Zang
AI-Powered Smart Paste: A Smarter Way to Fill ASP.NET Core Forms
Arun Kumar Ragu

Azure / Cloud

Introducing Google Cloud SQL
Greg Robidoux

Conceptos / Patrones / Buenas prácticas

Context Is the Bottleneck in Software Development
Derek Comartin
Alphabet Soup: The Format Buffet Nobody Ordered
Martin Stühmer
Solving Message Ordering from First Principles
Milan Jovanović

Data

Manejo de ubigeos en .NET con EF Core
Gerson Azabache Martínez
EF Core Lazy Loading Performance Gotcha
Mark Heath
EF Core MongoDB Queryable Encryption and Vector Search Explained
Rafael Veronezi
Named Global Query Filters Were Updated in EF Core 10
Anton Martyniuk

Machine learning / IA

Google multiplica por 5 el límite de tamaño de la File API de Gemini... pero ha hecho algo mucho mejor todavía
José Manuel Alarcón
Generative AI: The Future of Consumer Technology
S. Majumder
Don't fall into the anti-AI hype
Antirez
MCP Is a Transport, Not an Architecture (English)
Scott Galloway

Web / HTML / CSS / Javascript

Adiós al "Revisa tu Correo": el nuevo protocolo de verificación de email (EVP) para desarrolladores web (explicado a fondo)
José Manuel Alarcón
Servir contenido estático desde GitHub con la CDN jsDelivr GRATIS
Gisela Torres
Future CSS: :drag (and Maybe ::dragged-image?)
Sunkanmi Fafowora
“Everything’s Async” Until Your RAM Explodes: The JavaScript Backpressure Problem
Gabor Koos
Understanding React's useEffectEvent: A Complete Guide to Solving Stale Closures
Peter Kellner
Conditional TypeScript Generics in React Components
Meme Monday
Focus rings with nested contrast-color()?
Dave Rupert
Smashing Animations Part 8: Theming Animations Using CSS Relative Colour
Andy Clarke
JavaScript Canvas - WebGL A 3D Cube
Ian Elliot
What’s !important
Daniel Schwarz
How to Preview Videos Before Uploading Files in Angular File Upload
UdhayaKumar Duraisamy
Aurelia 2 Release Candidate: It's Finally Happening
Dwayne Charrington
jQuery 4.0.0
Timmy Willison

Visual Studio / Complementos / Herramientas

Use Agent Skills in VS Code
VS Code Team
The Windows File Explorer replacement, File Pilot, is awesome
Andrew Lock

.NET MAUI

How to Build Android Widgets with .NET MAUI
Toine de Boer
Choosing the Right .NET MAUI Picker: Date, Time, and Lists Made Simple
Hariram Subramanian
Gauge Controls: Real-time Performance Tracking, Player Stats
Leomaris Reyes

Otros

El punto y coma en programación: ¿necesario o un dolor de cabeza?
José Manuel Alarcón
Building a Computer That’s Older Than the Internet
Pawel Kadluczka
ASCII characters are not pixels: a deep dive into ASCII rendering
Alex Harri

Publicado en Variable not found.

.NET

Custom Scripting for Web Applications
Nevio Medancic, Enzo Grubisa & Vassili Kaplan
Dynamically Changing Decimal & Thousand Separators At Runtime
Conrad Akunga
TUnit: The New Sheriff in Town for .NET Testing
Vladan Petrovic
Refactoring Legacy C# Codebases: Modernizing Async, Collections, and Architecture for Safe, Maintainable .NET
Sudhir Mangla
C# Tip How to create and access custom C# Attributes by using Reflection
Davide Bellone
Creating a .NET CLR profiler using C# and NativeAOT with Silhouette
Andrew Lock
.NET Job Scheduling — Choosing the Right Framework
Martin Stühmer
New in .NET 10 and C# 14: Optimizations in log aggregation jobs
Ali Hamza Ansari
Angular Signals, But Better Now for .NET
I Looked Inside .git and You Won't Believe What I Found
How to Analyse Large CSV Files with Local LLMs in C# (English)
Scott Galloway
Stop Typing: The .NET CLI Tab Completion You've Been Missing
Martin Stühmer
Flatten your models with Facet .NET
Tim Maes
Fetching and Analysing Web Content with LLMs in C#
Scott Galloway
Streams Record Truth. Queues Do Work: A .NET Way To Keep Them Straight
Christopher Johnson
Your cache is not protected from cache stampede
Alexey Fedorov
The New Features and Enhancements in .NET 10
Joydip Kanjilal

ASP.NET Core / ASP.NET / Blazor

.NET 10 en el desarrollo de APIs REST modernas: Qué aporta realmente en la industria
Gerson Azabache Martínez
MinimalWorker: simplify background worker registration in ASP.NET Core and .NET applications
Joshua Jesper Krægpøth Ryder
Showing custom metrics in Aspire
Bart Wullems
Blazor SaaS Starter Kits Compared: When to Choose Brick Starter for Full‑Stack C#
Brick Starter Team
Clean Architecture for Blazor with DDD & CQRS
Aliaksandr Marozka
MVVM vs MVU in Blazor for Enterprise Apps
Aliaksandr Marozka
Deploy Aspire to Azure Container Apps using the Aspire CLI
Aspire Team
Managing Content Security in Telerik ASP.NET Core Applications
Peter Vogel
Blazor WebAssembly Using Local Storage in Offline Scenarios
Claudio Bernasconi

Azure / Cloud

JSON Web Token (JWT) Validation in Azure Application Gateway: Secure Your APIs at the Gate
Pierre Roman

Conceptos / Patrones / Buenas prácticas

Why “Microservices” Debates Miss the Point
Derek Comartin

Data

One Minute Knowledge: Is ToArrayAsync or ToListAsync faster for Entity Framework?
Steven Giesel
Introducing Kepler.Core — Smart Field Selection for EF Core APIs
Mohammad Ali Ebrahimzadeh
EF Core Bulk Data Retrieval: 5 Methods You Should Know
Anton Martyniuk
EF Core 10 Turns PostgreSQL into a Hybrid Relational-Document DB
Stefan Mitic

Machine learning / IA

Introducing GPT-5.2-Codex
OpenAI Team
What Building AI Agents in .NET Taught Me in 2025
Bruno Capuano
Prompt Noise Is Killing Your AI Accuracy: How to Optimize Context for Grounded Output
Chris Pietschmann
GPT-5.2 Prompting Guide
Mandeep Singh & Emre Okcular
Local AI Power: Vision and Function Calling with Microsoft Agent Framework and Ollama
Bruno Capuano
Understanding RAG (Retrieval-Augmented Generation)
Hassan Djirdeh

Web / HTML / CSS / Javascript

Responsive List of Avatars Using Modern CSS, Part 1 & Part 2
Temani Afif
What’s !important #1: Advent Calendars, CSS Wrapped, Web Platform Updates, and More
Daniel Schwarz
New to the web platform in December
Rachel Andrew
Forced Colors Mode
Chris Ferdinandi
JWT Authentication in React: Secure Routes, Context, and Token Handling
Prashant Yadav
Smashing Animations Part 7: Recreating Toon Text With CSS And SVG
Andy Clarke
Add Some Class to Your JavaScript
Paul Sheriff
CSS Layout: How To 'Center a Div,' the Old School Way
Steven J. Vaugha
My HTML Web Component boilerplate for 2026
Chris Ferdinandi
Vite vs. Webpack for react apps in 2025: A senior engineer’s perspective
Peter Aideloje
Masonry Layout is Now grid-lanes
Sunkanmi Fafowora

Visual Studio / Complementos / Herramientas

Productividad avanzada con GitHub Copilot en el desarrollo backend con .NET
Gerson Azabache Martínez
16 Tips for Writing AI-Ready C# Code
Matt Eland
A visual editor for the Cursor Browser
Cursor Team
Microsoft.Testing.Platform Now Fully Supported in Azure DevOps
Jeff Bowman
Visual Studio 2026: Debugging with Copilot
David Kahler
Behind the scenes of the Visual Studio feedback system
Mads Kristensen
Microsoft Quietly Kills IntelliCode as AI Strategy Shifts to Subscription Copilot
David Ramel
Investigating a deadlock in Visual Studio
Kevin Gosse

.NET MAUI

How to Build iOS Widgets with .NET MAUI
Toine de Boer
.NET 10 for .NET MAUI: Exploring New Diagnostics and Metrics
Leomaris Reyes

Otros

Sobre velocidad y coste de desarrollo
Juan María Hernández
A los desarrolladores de software se les fue de las manos cómo lo bautizan. Y ahora todos pagamos un 'impuesto cognitivo' por ello
Marcos Merino

Publicado en Variable not found.

¿Estás usando tus expresiones regulares en .NET de forma óptima?

2025-12-16T08:05:00.005+01:00

La relación de muchos desarrolladores con las expresiones regulares es de amor-odio. Aunque indudablemente son una herramienta muy potente, su uso puede ser complicado y a menudo se convierten en un dolor de cabeza.

Pero hoy no vamos a hablar de su (oscura) sintaxis, ni de lo difícil que es depurarlas, ni de cómo utilizarlas en .NET, sino de distintas técnicas que pueden ayudarnos a disparar su velocidad de proceso, algo bastante importante si las utilizamos en los procesos críticos o hot paths de nuestra aplicación.

En este artículo vamos comparar el rendimiento de distintos escenarios de uso de expresiones regulares, y cómo podemos optimizar su uso en .NET.

Chequear direcciones de email usando expresiones regulares

Como punto de partida, echemos un vistazo al siguiente código, un ejemplo donde definimos la clase estática EmailValidator, con un método IsValid() que utiliza la clase RegEx para validar el email que recibe como parámetro:

Console.WriteLine(EmailValidator.IsValid("john@server.com")); // true
Console.WriteLine(EmailValidator.IsValid("john@smith@server.com")); // false

public static class EmailValidator
{
    public static bool IsValid(string email)
    {
        string emailPattern = @"^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|""(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*"")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$";
        var regex = new Regex(emailPattern, RegexOptions.IgnoreCase);
        return regex.IsMatch(email);
    }
}

No vamos a entrar en el debate de si la expresión regular que hemos utilizado es la mejor para validar un email. Simplemente es la recomendación de un LLM asegurando que cumple la RFC 5322, y, para la prueba que queremos hacer es totalmente válida porque tiene una cierta complejidad.

Si ejecutamos el código anterior, veremos que la expresión regular funciona correctamente y el método IsMatch() nos devuelve true o false dependiendo de si el email es válido o no. Y además, aparentemente la ejecución es bastante rápida, suficiente si no es algo que se vaya a ejecutar con mucha frecuencia.

Sin embargo, internamente, cada vez que llamamos a ese método estático IsValid(), estamos instanciando la clase Regex suministrándole el patrón de la expresión regular, que es parseado, verificado, optimizado, compilado y posteriormente ejecutado por un intérprete para realizar la validación que le estamos solicitando. Todo este proceso puede ser costoso en términos de rendimiento, sobre todo si esa parte del código se ejecuta con mucha frecuencia.

Seguro que podemos mejorar esto...

Primera mejora: reutilización de `Regex`

La primera optimización que podemos aplicar en este punto es reutilizar la instancia de Regex. De esta forma, evitaremos la sobrecarga de crear una nueva instancia cada vez que llamamos al método IsValid() y evitaremos el proceso de verificación y compilación de la expresión regular.

Esto podríamos conseguirlo fácilmente insertando en la clase anterior el siguiente código:

public static class EmailValidator
{
    private const string EmailPattern = @"^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|""(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*"")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$";
    private static Regex SharedInstance = new Regex(EmailPattern, RegexOptions.IgnoreCase);

    public static bool IsValid_Shared(string email)
    {
        return SharedInstance.IsMatch(email);
    }
}

Si ejecutamos de nuevo la aplicación, veremos que el funcionamiento es exactamente el mismo, y que aparentemente sigue siendo igual de rápido. Pero si usamos BenchmarkDotNet para medir el rendimiento de las dos implementaciones, nos llevaremos una sorpresa:

| Method          | Mean       | Error     | StdDev    | Gen0    | Allocated |
|-----------------|-----------:|----------:|----------:|--------:|----------:|
| IsValid         | 206.716 us | 1.5089 us | 1.2600 us | 27.3438 |  233969 B |
| IsValid_Shared  |   2.742 us | 0.0312 us | 0.0276 us |       - |         - |

Esta segunda implementación se ejecuta casi 80 veces más rápido que la primera, sin consumo de memoria adicional. Impresionante, ¿verdad? Realmente se trata de una mejora brutal a cambio de muy poco esfuerzo de implementación.

Hay que tener en cuenta que las cifras no son siempre tan espectaculares, y que el rendimiento de la primera implementación puede variar dependiendo de la complejidad del patrón de la expresión regular. En expresiones más simples, la diferencia de rendimiento puede ser mucho menor, pero en cualquier caso habrá mejoras.

Pero... ¿aún podemos hacerlo mejor?

Segunda mejora: compilación de la expresión regular

Por defecto, las expresiones regulares se compilan a una serie de instrucciones de alto nivel que indican las operaciones que deben realizarse para comprobar si la cadena de texto suministrada coincide con el patrón de la expresión regular. Luego, en cada llamada a IsMatch() o métodos similares, un intérprete ejecuta esas instrucciones para realizar la validación.

Sin embargo, la clase Regex también permite compilar la expresión regular a código IL, por lo que el runtime de .NET puede ejecutarlo directamente e incluso, gracias al JIT, generar y ejecutar el código máquina nativo para la plataforma donde corre la aplicación, a cambio, eso sí, de consumir un poco más de memoria y tiempo durante su inicialización.

Esto lo conseguimos de nuevo con muy poco esfuerzo, simplemente añadiendo el RegexOptions.Compiled a la llamada al constructor de la clase Regex:

private static Regex SharedCompiledInstance 
  = new Regex(EmailPattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);

Si volvemos a llevarnos las tres opciones a BenchmarkDotNet, y medimos su rendimiento, veremos que en este último caso hemos mejorado algo más el rendimiento:

| Method            | Mean       | Error     | StdDev    | Gen0    | Allocated |
|------------------ |-----------:|----------:|----------:|--------:|----------:|
| IsValid           | 202.007 us | 2.4068 us | 2.2513 us | 27.3438 |  233969 B |
| IsValid_Shared    |   2.606 us | 0.0276 us | 0.0258 us |       - |         - |
| IsValid_Compiled  |   2.570 us | 0.0141 us | 0.0132 us |       - |         - |

En este caso la diferencia es mínima, pero es algo que también depende de la complejidad de las operaciones que hay que realizar para validar los valores contra la expresión regular. Por ejemplo, si en lugar de usar la expresión regular que hemos visto anteriormente para detectar emails, ejecutamos el mismo benchmark para un patrón aparentemente simple como "(\d+)*\1" y hacemos que se compruebe un string numérico muy largo (unos 100.000 dígitos), la diferencia de rendimiento es mucho más notable:

| Method           | Mean     | Error    | StdDev   | Allocated |
|----------------- |---------:|---------:|---------:|----------:|
| IsValid          | 65.70 ms | 1.107 ms | 1.088 ms |    5401 B |
| IsValid_Shared   | 63.74 ms | 0.925 ms | 0.772 ms |      57 B |
| IsValid_compiled | 19.52 ms | 0.147 ms | 0.130 ms |      12 B |

La expresión regular "(\d+)*\1" permite buscar cadenas que contengan un número seguido de un número repetido, como por ejemplo 123123, 456456, 789789, etc. Esta expresión regular es ejemplo conocido por dar lugar al llamado catastrophic backtracking, un problema que puede dar lugar a un rendimiento muy bajo en ciertas expresiones regulares, que incluso puede ser explotado en ataques de denegación de servicio (DoS) en aplicaciones web.

Estos resultados son fácilmente explicables: la diferencia de rendimiento entre la primera y segunda opción es pequeña, porque la expresión regular es muy simple y, por tanto, el coste de su compilación es bajo. Pero el rendimiento se multiplica por tres en la tercera opción porque la ejecución de la expresión regular se beneficia de la compilación a código IL.

Hasta aquí, hemos comprobado cómo realizando un par de modificaciones simples en el código podemos lograr mejorar considerablemente el rendimiento de las expresiones regulares en .NET. Pero aún hay más...

Tercera mejora: compilar la expresión regular en tiempo de diseño

La compilación de la expresión regular a código IL es una mejora muy interesante, pero tiene un coste adicional el términos de memoria y proceso, que se produce en el momento de la inicialización de la expresión regular, es decir, en tiempo de ejecución.

De hecho, también podemos realizar un benchmark del tiempo de creación de la instancia de Regex con y sin compilación, y veremos que la diferencia es prácticamente del triple, tanto en tiempo de proceso como en consumo de memoria:

| Method              | Mean     | Error    | StdDev   | Gen0    | Gen1   | Allocated |
|-------------------- |---------:|---------:|---------:|--------:|-------:|----------:|
| CreateRegex         | 28.64 us | 0.204 us | 0.170 us |  3.4180 |      - |  29.27 KB |
| CreateRegexCompiled | 99.51 us | 0.973 us | 0.863 us | 10.7422 | 1.4648 |     90 KB |

Si queremos evitar este sobrecoste, a partir de .NET 7 podemos compilar la expresión regular en tiempo de diseño usando source generators. De esta forma, el compilador de C# generará el código C# necesario para ejecutar la expresión regular, y lo incluirá en el ensamblado de la aplicación, por lo que no pagaremos ningún coste adicional en tiempo de ejecución. Pero además, como veremos algo más adelante, el código generado será mucho más eficiente que la versión compilada en tiempo de ejecución 🙂

Para conseguirlo, en una clase cualquiera debemos un método parcial de tipo Regex y asignarle el atributo [GeneratedRegex] especificando el patrón de la expresión regular y las opciones que queramos utilizar. Por ejemplo, en el siguiente código podemos ver el método al que hemos llamado GeneratedEmailRegex() sobre la clase estática parcial EmailRegex (ambos nombres son arbitrarios):

public static partial class EmailRegex
{
    [GeneratedRegex(@"^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|""(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*"")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$", RegexOptions.IgnoreCase)]
    public static partial Regex GeneratedEmailRegex();
}

Podéis ver fácilmente el código generado ejecutando la aplicación y, en el explorador de soluciones de Visual Studio, desplegando la carpeta "External Sources", el ensamblado de la aplicación, y abriendo el archivo RegexGenerator.g.cs, o bien, siguiendo estos pasos.

Una vez tenemos este método disponible, para utilizar la expresión regular simplemente debemos usar la instancia de Regex retornada por el mismo, por ejemplo así:

public static class EmailValidator
{
    public static bool IsValid(string email)
    {
        return EmailRegex.GeneratedEmailRegex().IsMatch(email);
    }
}

Y si de nuevo nos llevamos estos cambios a BenchmarkDotNet, y medimos el rendimiento de las distintas implementaciones, de nuevo nos llevaremos una alegría:

| Method                    | Mean         | Error       | StdDev      | Gen0    | Allocated |
|-------------------------- |-------------:|------------:|------------:|--------:|----------:|
| IsValid_Initial           | 213,564.0 ns | 1,532.91 ns | 1,280.05 ns | 27.3438 |  233969 B |
| IsValid_Shared_Instance   |   2,667.7 ns |    39.86 ns |    35.33 ns |       - |         - |
| IsValid_Compiled_Instance |   2,745.5 ns |    37.81 ns |    35.37 ns |       - |         - |
| IsValid_UsingGenerators   |     788.3 ns |     7.91 ns |     7.40 ns |       - |         - |

¡Uau! De nuevo hemos conseguido dividir por tres el tiempo de ejecución de la expresión regular respecto a la versión compilada en tiempo de ejecución. Y bueno, si lo comparamos con la versión inicial, la que implementamos sin pensar en ninguna optimización, es cerca de 300 veces más eficiente.

Conclusiones

A veces, el código que escribimos puede no ser el más óptimo: a veces por costumbre, a veces por comodidad, u otras simplemente porque no conocemos fórmulas mejores. En algunos casos no importará demasiado porque quizás nuestros requisitos de rendimiento no son excesivamente exigentes, pero en otros muchos escenarios sí debemos prestar atención a este tipo de detalles.

Lo que hemos visto en este post es un claro ejemplo de cómo las mejoras que se van introduciendo en el framework y el SDK de .NET pueden ayudarnos a mejorar el rendimiento de nuestras aplicaciones con muy poco esfuerzo.

Publicado en: www.variablenotfound.com.

Enlaces interesantes 631

2025-12-15T08:42:00.001+01:00

La semana pasada estuve unos días fuera y no publiqué la habitual recopilación de los lunes. Pero ya me he puesto al día, y, como se me acumuló el trabajo, en esta entrega tenemos más de ¡100! enlaces a contenidos a los que vale la pena echar un vistazo.

Por destacar algunos, en primer lugar el profundo análisis que está llevando a cabo Martin Stühmer sobre soluciones de scheduling en .NET, muy interesantes para estar al tanto de las opciones disponibles.

También Gerson Azabache ha publicado varios artículos interesantes sobre ASP.NET Core, como la comparativa entre Minimal APIs y controladores, resultados tipados y algunas buenas prácticas en el desarrollo de APIs empresariales.

Braulio Díez comparte sus reflexiones y experiencias sobre el impacto de la IA en la programación y el futuro de los desarrolladores de software, que igual no es tan malo como algunos pintan.

Y en la misma línea, José Manuel Alarcón habla sobre cómo los juniors deben enfocar su proceso de aprendizaje, integrando la IA como una aliada imprescindible.

Muchos más enlaces, a continuación.

Por si te lo perdiste...

Mi controlador tiene muchos parámetros en el constructor, ¿estoy haciendo algo mal?
José M. Aguilar
HybridCache, la nueva caché híbrida de .NET 9
José M. Aguilar

.NET

C# 14 New Feature: Field-Backed Properties
Ian Griffiths
Recent updates to NetEscapades.EnumGenerators: [EnumMember] support, analyzers, and bug fixes
Andrew Lock
“Classic” .NET Domain Events with Wolverine and EF Core
Jeremy D. Miller
.NET Job Scheduling: Quartz.NET for Enterprise Scale & Coravel and Fluent Simplicity & NCronJob and Native Minimalism & TickerQ and Modern Architecture
Martin Stühmer
How to Build a Production-Ready Invoice Builder in .NET Using IronPDF
Anton Martyniuk
How can my process read its own standard output?
Raymond Chen
Mime Type Helper in .NET 11
Steven Giesel
Single File Test Suites in Dotnet Csharp
Steve Smith
Create Types on Demand and Cecilifier
Roman Stoffel
Creating a custom MSBuild SDK to reduce boilerplate in .NET projects
Gérald Barré
Debug Dumps in Visual Studio
Stephen Cleary
Building Modular .NET Applications with CShells
Sipke Schoorstra
.NET 10 Networking Improvements
Marie Píchová
What the heck is a \\.\nul path and why is it breaking my Directory Files Lookup?
Rick Strahl
.NET 10 Validation
Ricardo Peres
.NET Performance: Efficient Async Code
Nick Kovalenko
.NET 10 and Memory: Less Heap, Smarter GC, Faster Apps
Hazem Ali
Immutable Collection Add() Trap: Don’t Get Burned — Use a Builder Instead
David McCarter
How .NET 10.0 boosted AIS.NET performance by 7%
Ian Griffiths
Resolving Overload Ambiguity with Collection Expressions
Gérald Barré
Typemock Architecture: Inside the .NET Isolator Engine (Part 2)
Eli Lopian
Cleaner Code: C# 14 Null-Conditional Assignment Operator
Dave Brock

ASP.NET Core / ASP.NET / Blazor

Minimal APIs vs Controllers en .NET 10: la guía corta y honesta & Por qué tus APIs en .NET deberían usar Result Contracts (Typed Results) & Las 5 mejores prácticas modernas para APIs empresariales en .NET (2026)
Gerson Azabache Martínez
Enterprise Patterns for ASP.NET Core Minimal API: Transaction Script Pattern – The Shortcut That Quietly Reshapes Your System
Chris Woodruff
How to upload files in an ASP.NET Core Web API
David Grace
Stop Letting Your Controllers Talk to SQL: Layered Architecture in ASP.NET Core
Chris Woodruff
Best Practices For Building REST APIs
Anton Martyniuk
How to Choose the Best Blazor Dropdown Component for Your Web App
Prince Oliver
mostlylucid.MinimalBlog - How Simple Can an ASP.NET Blog Really Be? (English)
Scott Galloway
Enterprise Patterns for ASP.NET Core Minimal API: Domain Model Pattern – When Your Core Rules Deserve Their Own Gravity
Chris Woodruff
Load Testing ASP.NET Core Applications with k6: Introduction & Practical Implementation
Scott Galloway
How Aspire composes itself: an overview of Aspire's Docker Compose integration
Safia Abdalla
Migrating from Bootstrap Blazor or MudBlazor to Blazorise
Mladen Macanović
Using Strategy Pattern with Dependency Injection in ASP.NET Core
Ali Hamza Ansari
Getting Started with the Aspire CLI - A Complete Guide
Chris Ayers

Azure / Cloud

You Can't Use Azure Migrate to Move Between Tenants (Even if you Try to Run it in Azure)
Shannon B. Kuehn
How to Deploy a Spreadsheet Server on Azure App Service Using Visual Studio and Docker
Parthasarathy Ranjan

Conceptos / Patrones / Buenas prácticas

Domain-Driven Design Misconceptions
Derek Comartin
Treat test code like production code
Mark Seemann
Aggregates in DDD: Model Rules, Not Relationships
Derek Comartin
10 Habits That Make You a Great Programmer
Shalitha Suranga
12 Essential Distributed System Design Patterns Every Architect Should Know
Anton Martyniuk
Power of Ten Rules: More Relevant Than Ever for .NET
Martin Stühmer
Stop Naming Your Variables "Flag": The Art of Boolean Prefixes
Christopher Johnson

Data

Data Access in .NET: Comparing ORMs and Mapping Strategies (Part 1 & * Comparing ORMs and Mapping Strategies (Part 2
Scott Galloway
Debugging Entity Framework Core: 8 Real-World Query Anti‑Patterns (and How to Fix Them)
Chris Woodruff
Named global query filters in Entity Framework Core 10
Tim Deschryver
DbContext is Not Thread-Safe: Parallelizing EF Core Queries the Right Way
Milan Jovanović
Why your EF Core queries are slow and how to fix them
David Grace

Machine learning / IA

Meet EuroLLM: Large language model made in Europe built to support all official 24 EU languages
EuroLLM
Introducing: Devstral 2 and Mistral Vibe CLI
Mistral
Introducing GPT-5.2
OpenAI
Introducing the Microsoft Agent Framework – A Dev-Friendly Recap
Bruno Capuano
Introducing Data Ingestion Building Blocks (Preview)
Luis Quintanilla
Anomaly Detection Using K-Means Clustering with JavaScript
James McCaffrey

Web / HTML / CSS / Javascript

Cómo probar tu aplicación con Vue en GitHub Pages
Gisela Torres
Prevent a page from scrolling while a dialog is open
Geoff Graham
Getting Creative With “The Measure”
Andy Clarke
Scrollytelling on Steroids With Scroll-State Queries
Lee Meyer
Masonry: Things You Won’t Need A Library For Anymore
Patrick Brosset
Frederik Braun: Why the Sanitizer API is just setHTML()
Frederik Braun
Creating Scroll-Based Animations in Full view()
Preethi
CSS Wrapped 2025
Chrome DevRel Team
Fit width text in 1 line of CSS
Geoff Graham
That Time I Tried Explaining HTML and CSS to My 5-Year Old Niece
Kevine Nzapdi
::target-text: An easy way to style text fragments
Saron Yitbarek
Stop using JavaScript to solve CSS problems
Chizaram Ken
Simulating the Enigma Machine
Andrew S. Erwin
Tailwind CSS: Targeting Child Elements (when you have to)
Christian Ekrem
How to Prevent XSS Attacks in React Rich Text Editor
Thangavel E.
What's wrong with this HTML, and is it valid?
Patrick Brosset
How to create Liquid Glass effects with CSS and SVG
Rahul Chhodde
What Else Could Container Queries... Query?
Daniel Schwarz
Denial of Service and Source Code Exposure in React Server Components – React
The React Team

Visual Studio / Complementos / Herramientas

Why changing keyboard shortcuts in Visual Studio isn’t as simple as it seems
Steven Miller
Unlock GitHub Copilot’s Full Potential: Why Every Repo Needs an AGENTS.md File
Chris Pietschmann
Progress on TypeScript 7 - December 2025
Daniel Rosenwasser
Introducing Stack Overflow AI Assist—a tool for the modern developer
Stack Overflow Team
Microsoft Learn MCP Server Elevates Development
Wendy Breiding
Trying out the Zed editor on Windows for .NET and Markdown
Andrew Lock
Previewing the JavaScript/TypeScript Modernizer for VS Code Insiders
Sayed Ibrahim Hashimi
DarkGPT: Malicious Visual Studio Code Extension Targeting Developers — Real-time Open Source Software Supply Chain Security
SafeDep Team
Streamlining your Git workflow with Visual Studio 2026
Mads Kristensen
Making Windows Terminal awesome with GitHub Copilot CLI
Linda Berns

.NET MAUI / Cross-Platform

Cross-Platform Age Verification in .NET MAUI Applications
Gerald Versluis
Securing Sensitive Mobile Operations with Device-Bound Request Signing
Fernando de Oliveira
Mastering Popups in .NET MAUI: Alerts, Action Sheets, Overlays & More
Jayaleshwari N.
Implementing Cross-Platform In-App Billing in .NET MAUI Applications
Gerald Versluis
How to Add and Remove Digital Signatures in PDF Using .NET MAUI
Rangarajan Ashokan
How to Integrate Google Maps in .NET MAUI: A Cross-Platform Guide Using the Google Maps Tile API
Jeyasri Murugan
Avalonia MAUI Progress Update
Tim Miller
.NET 10: Quick UI Changes Worth Noticing in .NET MAUI
Leomaris Reyes

Otros

El picar se va acabar
Braulio Díez
Aprende a programar en 2026: guía práctica para juniors (que tienen miedo a la IA, o no)
José Manuel Alarcón

Publicado en Variable not found.

Soporte para el TLD .localhost en ASP.NET Core 10

2025-12-02T08:05:00.018+01:00

Al desarrollar aplicaciones ASP.NET Core (APIs, MVC, Razor Pages o Blazor) y ejecutarlas en local, ya sabes que todas ellas comparten el mismo nombre de host: localhost, y lo único que las diferencia es el puerto en el que se encuentran a la escucha.

Esto puede dar lugar a ciertos problemas. Aparte de no ser sencillo identificarlas a partir de la URL mostrada en el navegador, hay ciertos recursos web que pueden mezclarse entre proyectos (por ejemplo, las cookies) y pueden dar lugar a comportamientos inesperados.

En ASP.NET Core 10 se ha puesto solución a esto añadiendo el soporte para el TLD (Top Level Domain) .localhost, lo que permite que cada aplicación pueda tener su propio nombre de host único.

Lo vemos a continuación.

Soporte para TLD .localhost en ASP.NET Core 10

El nombre .localhost es un dominio de nivel superior (TLD, Top Level Domain) reservado por las RFC 2606 y 6761 para ser utilizado en entornos de desarrollo y pruebas, y siempre está asociado a la dirección de loopback, es decir, a la dirección local del propio equipo.

Por tanto, cualquier nombre de host que termine en .localhost (por ejemplo, miapp.localhost, api.localhost, MyApp.dev.localhost, etc.) debería resolverse siempre a la dirección IP 127.0.0.1 o ::1, dependiendo de si se utiliza IPv4 o IPv6.

A partir de ASP.NET Core 10, Kestrel entenderá que todos los nombres de host que terminen en .localhost son alias válidos para localhost, por lo que podemos utilizarlos para configurar el servidor, definir las URLs de nuestras aplicaciones (tanto en launchSettings.json como en variables de entorno), etc. Esto nos permitirá usar distintos nombres de host para cada aplicación, evitando los problemas mencionados anteriormente.

Otro tema que han actualizado es el certificado HTTPS utilizado en desarrollo. Dado que el antiguo certificado solo era válido para localhost, al utilizar otros nombres de host el navegador mostraría advertencias de seguridad. Por esta razón, el certificado que se registra al instalar .NET 10 es un wildcard del dominio *.dev.localhost.

Observad que no han podido hacerlo directamente para soportar *.localhost. Han tenido que introducir el subdominio .dev por delante porque no es posible crear wildcards sobre top level domains como localhost.

En la práctica, esto implica que podremos asignar a nuestras aplicaciones ASP.NET Core nombres de host como miapp.dev.localhost, api.dev.localhost, etc., aunque no es algo que esté habilitado por defecto.

Para activar esta característica, debemos seleccionar la opción "Use the .dev.localhost TLD in the application URL" al crear una nueva aplicación, como se muestra en la siguiente imagen:

Al hacerlo, se configurará el launchsettings.json para que utilice el nombre de proyecto como subdominio. Por ejemplo, a continuación se muestra la configuración generada para el proyecto MyWebApplication, donde podemos ver el uso del host mywebapplication.dev.localhost:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://mywebapplication.dev.localhost:5244",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://mywebapplication.dev.localhost:7279;
                         http://mywebapplication.dev.localhost:5244",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

También podemos conseguir lo mismo si utilizamos la línea de comandos de .NET para crear los proyectos. Por ejemplo, el siguiente comando crea una aplicación MVC que utiliza el TLD .dev.localhost:

C:\MyProjects\MyWebApp>dotnet new web --localhost-tld
The template "ASP.NET Core Empty" was created successfully.

Processing post-creation actions...
Restoring C:\MyProjects\MyWebApp\MyWebApp.csproj:
Restore succeeded.


C:\MyProjects\MyWebApp>type .\Properties\launchSettings.json
{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://mywebapp.dev.localhost:5024",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://mywebapp.dev.localhost:7125;
                         http://mywebapp.dev.localhost:5024",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}
C:\MyProjects\MyWebApp>_

Con estas configuraciones, al lanzar el proyecto se utilizarán estos nombres de host exclusivos para el proyecto, evitando los problemas de compartir el mismo localhost entre varias aplicaciones.

C:\MyProjects\MyWebApp> dotnet run
Using launch settings from C:\MyProjects\MyWebApp\Properties\launchSettings.json...
Building...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://mywebapp.dev.localhost:5024
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5024
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\MyProjects\MyWebApp
_

Un último detalle importante: podremos utilizar los nombres de host personalizados cuando accedamos a las aplicaciones desde el navegador web, pero probablemente no desde otras herramientas como curl, Postman, etc., o al menos de directamente.

Esto se debe a que, aunque el TLD .localhost está reservado para este propósito, no todas las aplicaciones cliente o los sistemas operativos resuelven automáticamente estos nombres a la dirección de loopback. Por esta razón, en estos casos tendríamos que añadir entradas manuales en el archivo hosts de nuestro sistema operativo para que los nombres personalizados funcionen correctamente.

Afortunadamente, los navegadores web modernos implementan esta resolución de forma automática, por lo que funcionará directamente 🙂

Publicado en Variable not found.

Enlaces interesantes 630

2025-12-01T08:01:00.030+01:00

Esta semana me gustaría destacar en primer lugar el detallado análisis de Andrew Lock sobre el proceso de arranque de una aplicación .NET, muy interesante para saber cómo funcionan las cosas por dentro.

Bipin Joshi da un gran repaso a Kestrel, el motor de todas las aplicaciones ASP.NET Core: cómo configurarlo, tunearlo, ejecutarlo y buenas prácticas de uso.

Milan Jovanović nos recuerda que el happy path no es el único camino en nuestras aplicaciones, y nos muestra técnicas para desacoplar servicios para hacerlos más robustos.

Por último, Ricardo Peres nos habla de la relación entre tipos anulables y miembros requeridos en C#, algo que, cuando empezamos a trabajar con ellos, puede resultar algo confuso.

El resto de enlaces, a continuación.

Por si te lo perdiste...

Soporte para colecciones en parámetros param de .NET 9
José M. Aguilar
Establecer textos por defecto y localizados en validaciones de ASP.NET Core MVC
José M. Aguilar

.NET

TUnit — Why I Spent 2 Years Building a New .NET Testing Framework
Tom Longhurst
C# 14: User-Defined Compound Assignment Operators
Anthony Giretti
Under Pressure: How Queueing Systems Handle Backpressure with Examples in C#
Scott Galloway
Precision Matters in C#: Correctly Handling Money, Time Zones, and Date Ranges
Sudhir Mangla
Exploring the .NET boot process via host tracing
Andrew Lock
.NET Job Scheduling — The Landscape
Martin Stühmer
Why Do You Need To Write Architecture Tests in .NET
Anton Martyniuk
Fetching GitHub content from C#
Thomas Ardal
Using CSX Scripts for Quick C# Testing (English)
Scott Galloway
The Worst Security Vulnerability in Akka.NET
Aaron Stannard
IDistributedCache (Redis)
Josef Ottosson
Adding Intelligence to Blazor with Telerik Smart Components
Héctor Pérez
How to ensure your expert C# knowledge doesn't make you a TypeScript noob
Lewis Cianci
Ix.NET v7.0: .NET 10 and LINQ for IAsyncEnumerable<T>
Ian Griffiths
Real-Time Recommendation Engines in .NET: Hybrid Retrieval, Deep Learning, and Vector Search
Sudhir Mangla
One shot tool execution in .NET 10
Bart Wullems
.NET Job Scheduling — Hangfire and Persistent Reliability
Martin Stühmer
Nullable and Required Types
Ricardo Peres
Unit Testing HttpClient WITHOUT Mocks
Scott Galloway

ASP.NET Core / ASP.NET / Blazor

Multitenancy Techniques for the UI in ASP.NET Core
Ricardo Peres
Why you must use Minimal APIs over Controllers for new apps
David Grace
Mastering Kestrel: From Configuration to Cloud
Bipin Joshi
Securing Apps with the Telerik UI for ASP.NET Core OTP Control
Héctor Pérez
Optimizing Rendering and Reconciliation in Large Blazor Apps
Mladen Macanović
Performance Tuning in ASP.NET Core: Best Practices for 2025
Arulraj Aboorvasamy
HTMX with ASP.NET Core Partials: The Server-Side Renaissance
Scott Galloway
Announcing ASP.NET Core OData 10.0.0 Preview 1
Samuel Wanjohi

Azure / Cloud

Azure MCP Server II - Configuración y primeros pasos
Juan Irigoyen

Conceptos / Patrones / Buenas prácticas

Minimal APIs, CQRS, DDD… Or Just Use Controllers?
Derek Comartin
WebSockets vs HTTP: Key Differences Explained
The Postman Team
The False Comfort of the "Happy Path": Decoupling Your Services
Milan Jovanović

Data

Announcing OData .NET (ODL) 9 Preview 3 Release
John Gathogo
Using sortable UUID / GUIDs in Entity Framework
Steven Giesel
You're Probably Doing EF Migrations wrong...
Scott Galloway
MSSQL Extension for VS Code: Introducing Edit Data (Public Preview)
Yo-Lei Chen

Machine learning / IA

Introducing Claude Opus 4.5 \ Anthropic
Anthopic
RAG in Practice: Building Real-World Applications
Scott Galloway
Building our first MCP Resources enabled MCP Server with C#
Bart Wullems

Web / HTML / CSS / Javascript

Angular 21: desarrollo web empresarial más rápido, inteligente y accesible
José Manuel Alarcón
Todo lo que el navegador web revela sin que se sepa
Álvaro Ibáñez
How to Create Interactive Fillable PDF Forms Using JavaScript PDF Viewer
Arun Kumar Chandrakesan
On Inheriting and Sharing Property Values
Daniel Schwarz
Shuffling a CSS grid using custom properties
Christian Heilmann
CSS Backgrounds Module Level 4 - Working Draft
Elika J. Etemad & Lea Verou & Sebastian Zartner
How to Simplify Your React Components with Derived State
Olaleye Blessing
Angular 21: My Favorite New Features, Demo, What’s Next
Alyssa Nicoll
You're doing JavaScript testing wrong
Chris Ferdinandi
Securing Apps with the Telerik UI for ASP.NET Core OTP Control
Héctor Pérez
Managing Side Effects: A JavaScript Effect System in 30 Lines or Less
Aycan Gulez
Angular 21 Is Here: How Syncfusion Delivers Compatibility Support
Sabari Anand S.
How to Hallucinate using Web Components—zachleat.com
Zach Leatherman
How Closures Work in JavaScript: A Handbook for Developers
Sumit Saha
New to the web platform in November
Rachel Andrew
WebGPU is now supported in major browsers
François Beaufort

Visual Studio / Complementos / Herramientas

Visual Studio – Built for the Speed of Modern Development
Paul Chapman
Manage Containers the Easy Way: Copilot + VS Code
Matt Hernandez
Automatically Signing a Windows EXE with Azure Trusted Signing, dotnet sign, and GitHub Actions
Scott Hanselman
How to Create an MSI Installer with Visual Studio 2026
Renato Ivanescu

.NET MAUI

Visualize Monthly Weather Forecasts with .NET MAUI Scheduler
Jeyasri Murugan
Replicating a Christmas UI in .NET MAUI
Leomaris Reyes

Otros

Scaling culture in a scale-up
Rob Nicholson

Publicado en Variable not found.

Enlaces interesantes 629

2025-11-24T08:05:00.058+01:00

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

ASP.NET Core / ASP.NET / Blazor

Multitenancy Techniques for ASP.NET Core
Ricardo Peres
Implement forgot your password using swiyu, ASP.NET Core Identity and Aspire
Damien Bowden
How to Add Video Preview to the Blazor File Upload Component
UdhayaKumar Duraisamy
OpenAPI.NET: The Biggest Update Ever
Darrel Miller
What’s New in ASP.NET Core 10 for .NET 10: Key Features and Enhancements
Arulraj Aboorvasamy
Blazor Basics: Building Drag-and-Drop Functionality
Claudio Bernasconi
How Blazor's Unified Rendering Model Shapes Modern .NET Web Apps
David Ramel
Securing WebSocket Connections in ASP.NET Core using Sec WebSocket Protocol Header
Bjoern Meyer

Azure / Cloud

Infinite scale: The architecture behind the Azure AI superfactory
Scott Guthrie

Conceptos / Patrones / Buenas prácticas

La Capa de Dominio en Clean Architecture: Qué debe contener y por qué
Gerson Azabache Martínez
Primitive Obsession
Fran Iglesias
Empirical software prototyping
Mark Seemann
A Developer’s Guide to OAuth 2.0 Workflows: Web, Mobile, SPA, Machine-to-Machine, and Device Flows
Subodh Shetty
Beyond SOLID in Modern C#: Smart Enums, Discriminated Unions & Railway-Oriented Programming
Sudhir Mangla

Data

SQL Server 2025 is Now Generally Available
Venkata Raj Pochiraju
How I Have Increased the Production Payment System Performance by 15x With One Line of Code in EF Core
Anton Martyniuk
Building Read Models with EF Core Projections
Ali Hamza Ansari

Machine learning / IA

GPT-5.1-Codex-Max: nuevo modelo hiperespecializado en programación
José Manuel Alarcón
Gemini 3: Introducing the latest Gemini AI model from Google
Sundar Pichai & Demis Hassabis & Koray Kavukcuoglu
Google brings Gemini 3 AI model to Search and AI Mode
Elizabeth Hamon Reid

Web / HTML / CSS / Javascript

Angular Signal Forms: un cambio de paradigma
Saúl Moro
Announcing Angular v21
Jens Kuehlers & Mark “Techson” Thompson
How to Fix Memory Leaks in JavaScript PDF Viewers: Best Practices and Debugging Tips
RajaVignesh BalaSankar
The “Most Hated” CSS Feature: asin(), acos(), atan() and atan2()
Juan Diego Rodríguez
Should We Even Have :closed?
Sunkanmi Fafowora
Keyframes Tokens: Standardizing Animation Across Projects
Amit Sheen
Six Things I Bet You Didn't Know You Could Do With Chrome's Devtools, Part 1 & Part 2
Rachel Kaufman
Typescript without Typescript
Chris Ferdinandi
Angular Signal Forms vs. Reactive Forms
Jonathan Gamble
React 19.2: The async shift is finally here
Jack Herrington
Practical Introduction to Async Generators in JavaScript
Peter Mbanugo

Visual Studio / Complementos / Herramientas

Spend Less Time Upgrading, More Time Coding in Visual Studio 2026
Narayan Subramanian
A step-by-step guide to modernizing .NET applications with GitHub Copilot agent mode
Jason Baginski
Supercharge Your Test Coverage with GitHub Copilot Testing for .NET
McKenna Barlow
tree-me: Because git worktrees shouldn’t be a chore
Phil Haack
Introducing the Visual Studio Code Private Marketplace: Your Team's Secure, Curated Extension Hub
Sean Iyer
Hands-on with MCP Resources in Visual Studio
Bart Wullems
Inspect and Validate JSON Web Tokens with the Duende JWT Decoder
Wesley Cabus

.NET MAUI

.NET 10 Improves MAUI Quality and Performance
Edin Kapić

Otros

¿Qué es Cloudflare y por qué su caída paraliza internet?
CampusMVP
Minivac 601 Simulator
Greg Sadetsky
Preserving code that shaped generations: Zork I, II, and III go Open Source
Stacey haffner & Scott hanselman

Publicado en Variable not found.

Novedades de C# 14

2025-11-18T07:54:00.055+01:00

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.

Miembros extensores

Hasta C# 13, los métodos extensores (extension methods) eran la única forma de añadir funcionalidad o características a tipos existentes sin necesidad de modificar su código fuente original. Sin embargo, esta técnica tenía limitaciones, como la imposibilidad de añadir propiedades o eventos, o definirlas sobre clases estáticas. Además, la forma en la que los implementábamos no favorecía especialmente la legibilidad del código.

En C# 14, los métodos extensores siguen siendo válidos y retrocompatibles a nivel de código, pero el concepto ha sido ampliado significativamente. A partir de esta versión, se han introducido los bloques extension como delimitadores para definir miembros extensores de un mismo tipo de una forma más estructurada y legible. Observa el siguiente código, donde podemos ver la comparativa entre la sintaxis clásica y la nueva:

// C# 13 y anteriores
public static class StringExtensions
{
    public static bool IsCapitalized(this string str) 
    {
        return !string.IsNullOrEmpty(str) && char.IsUpper(str[0]);
    }
    public static bool IsInteger(this string str) 
    {
        return int.TryParse(str, out _);
    }
}

// C# 14:
public static class StringExtensions
{
    extension(string str)
    {
        public bool IsCapitalized()
        {
            return !string.IsNullOrEmpty(str) && char.IsUpper(str[0]);
        }
        public bool IsInteger()
        {
            return int.TryParse(str, out _);
        }
    }
}

Pero la cosa no queda ahí 🙂. Además del bloque extension, C# 14 introduce la posibilidad de definir otros tipos de miembros extensores, tanto de instancia como estáticos:

public static class StringExtensions
{
    extension(string str)
    {
        // Propiedad extensora:
        public char? FirstCharacter
        {
            get => string.IsNullOrEmpty(str) ? null : str[0];
        }
    }

    extension(Math)
    {
        // Extensión de clase estática:
        public static int Factorial(int n)
        {
            if (n < 0) throw new ArgumentException("Invalid negative value", nameof(n));
            return n == 0 ? 1 : n * Factorial(n - 1);
        }
    }
}

Podéis leer más sobre miembros extensores en este post de hace unas semanas.

Asignaciones condicionales

Llevamos tiempo usando operadores como null coalescing (??), null coalescing assignment (??=) o safe navigation (?.) para lidiar con valores nulos de una forma más concisa y legible. En C# 14 se ha extendido este último para permitir su aplicación en el lado izquierdo de una asignación, permitiéndonos asignar valores a propiedades o campos de objetos que podrían ser nulos, sin necesidad de realizar comprobaciones explícitas.

// C# 13 y anteriores:
var friend = GetFriendOrNull(1);
if (friend != null)
{
    friend.Name = "John Doe";
}

// C# 14:
var friend = GetFriendOrNull(1);
friend?.Name = "John Doe"; // Si friend es nulo, no se lanza excepción y no se asigna valor

Si queréis profundizar algo más, hace algún tiempo hablamos de esta característica en este otro post.

Propiedades semi-automáticas

Las propiedades semiautomáticas son una mezcla entre las propiedades automáticas y las tradicionales con backing field, pero tomando lo mejor de ambos mundos. Gracias a esta característica podemos definir propiedades con un campo de respaldo generado automáticamente, pero al mismo tiempo nos dan la flexibilidad de acceder a él mediante la palabra clave contextual field, lo que nos permite personalizar los accesores get y set según nuestras necesidades.

// C# 13 y anteriores:
private int _age;
public int Age
{
    get { return _age; }
    set {
        if (value < 0) throw new ArgumentException("Age cannot be negative");
        _age = value;
    }
}

// C# 14:
public int Age
{
    get; // Retorna el valor del backing field generado automáticamente
    set
    {
        if (value < 0) throw new ArgumentException("Age cannot be negative");
        field = value; // 'field' es el backing field
    }
}

Para ver esta característica en mayor detalle, podéis consultar el post Propiedades semi-automáticas en C# que publiqué por aquí hace ya casi un año.

Uso de `nameof` con tipos genéricos

El operador nameof ha sido mejorado para permitir el uso de tipos genéricos sin especificar sus parámetros de tipo, algo que antes no era posible.

Console.WriteLine(nameof(List<>)); // Imprime "List"

Constructores y eventos parciales

También es interesante comentar que ahora se permite la implementación de constructores y eventos parciales. En la práctica, esto quiere decir que podemos definir este tipo de miembros en una parte de una clase parcial, y completarlos en otra.

Como podemos ver en el siguiente ejemplo, en la primera porción de la clase definimos los elementos como partial y en la segunda los implementamos. Fijaos que en el caso del evento, debemos definir los bloques add y remove para gestionar los suscriptores:

// Definición en una parte de la clase parcial:
public partial class MyClass
{
    public partial MyClass(string something); // Partial constructor declaration
    public partial event EventHandler? OnMyEvent; // Partial event declaration
}

// Implementación en otra parte de la clase parcial:
public partial class MyClass
{
    public partial MyClass(string something)
    {
        // Constructor implementation
    };

    private EventHandler? _onMyEvent;

    public partial event EventHandler? OnMyEvent
    {
        add
        {
            _onMyEvent += value; // Subscriber added
        }

        remove
        {
            _onMyEvent -= value; // Subscriber removed
        }
    }
}

Conversiones implícitas para `Span<T>` y `ReadOnlySpan<T>`

C# 14 introduce conversiones implícitas para los tipos Span<T> y ReadOnlySpan<T>, facilitando su uso y manipulación sin necesidad de conversiones explícitas.

Por ejemplo, el bloque de código mostrado a continuación no compila en versiones anteriores a C# 14, porque el método StartsWith() es un extensor del tipo ReadOnlySpan<int> y no existe en la clase Array. Sin embargo, en C# 14, gracias a las conversiones implícitas, este código funciona correctamente:

int[] arr = [1, 2, 3];
Console.WriteLine(arr.StartsWith(1)); // Muestra "True" en C# 14

Modificadores simplificados en parámetros lambda

En C# 14, se pueden usar modificadores de parámetros como scoped, ref, in, out, o ref readonly en expresiones lambda sin necesidad de especificar el tipo del parámetro, haciendo el código algo más conciso y legible.

Por ejemplo, observa la sutil diferencia entre C# 13 y 14 en la siguiente definición de un delegado que intenta parsear un valor:

// Definición del delegado
delegate bool TryParse<T>(string text, out T result);

// C# 13 y anteriores
TryParse<int> parser = (string text, out int result) => int.TryParse(text, out result);

// C# 14
TryParse<int> parser = (string text, out result) => int.TryParse(text, out result);

La segunda opción no compilará en versiones anteriores de C# porque en el parámetro out de la expresión lambda no se especifica el tipo int. En C# 14 es perfectamente válido, porque puede ser inferido del delegado.

Punto extra: ¿podemos usar C# 14 en proyectos .NET 9 o Visual Studio 2022?

Pues sí, es posible porque estamos hablando de características del lenguaje y no del framework, así que podremos aprovechar estas novedades en proyectos dirigidos a versiones anteriores de .NET y con Visual Studio 2022.

Para ello, simplemente debemos asegurarnos de configurar la versión del lenguaje en la propiedad LangVersion del archivo de proyecto (.csproj), especificando 14.0, como se muestra a continuación:

<PropertyGroup>
    <LangVersion>14.0</LangVersion>
</PropertyGroup>

Publicado en Variable not found.