Variable not found

Enlaces interesantes 652

2026-06-15T08:01:00.000+02:00

Esta semana hay que destacar tanto el anuncio a bombo y platillo de los modelos Claude Fable y Mythos 5 de Anthropic... como su retirada unos días después, debido una orden del gobierno de Estados Unidos por motivos de seguridad nacional. Un mundo curioso este 😉

También se ha lanzado .NET 11 Preview 5, con novedades interesantes como el soporte para JSONL, full outer joins en LINQ, mejoras en runtime asíncrono, una nueva plantilla de proyecto MCP, jerarquías cerradas en C#, validación en cliente y QuickGrid en Blazor SSR, parámetros proporcionados por variables de sesión y muchas más cosas, que podéis encontrar detalladas aquí.

Por último, destacar un artículo sobre el principio DRY, uno de los más utilizados mientras programamos, pero que a menudo se malinterpreta. Milan Jovanović nos explica por qué y cómo debemos aplicarlo correctamente.

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

Tipos unión: la novedad de C# 15 que siempre habías necesitado

2026-06-09T08:00:00.000+02:00

Todos hemos tenido que lidiar con situaciones en las que una función o método puede devolver diferentes tipos de datos dependiendo de ciertas condiciones. El ejemplo clásico es una función que puede devolver un resultado exitoso o un error, lo que a menudo se maneja con tipos como Result<T> o haciendo algunos malabarismos con composiciones de clases o herencia.

var result = GetUser(1);
if(result.Success) 
{
    var user = result.Value;
    // Hacer algo con el usuario
}
else 
{
    var error = result.Error;
    // Manejar el error
}

Son artificios que, aunque funcionan, dan trabajo, complican la legibilidad y ocultan la intención real del desarrollador a la hora de escribir código de procedimientos que manejen múltiples tipos de retorno.

Los tipos unión son una de las características más solicitadas en C# durante años, y finalmente los tendremos disponibles en la versión 15 del lenguaje, que vendrá de la mano de NET 11 en noviembre de 2026.

Con esta nueva capacidad, podremos crear tipos que pueden contener valores de varios tipos diferentes, con controles en tiempo de compilación y sin apenas complejidad adicional.

Lo vemos en detalle a continuación.

¿Qué son y cómo se usan los tipos unión?

Un tipo unión es un tipo de datos que puede contener valores de diferentes tipos. Un ejemplo clásico es el escenario que mostrábamos antes, donde una función puede devolver un resultado exitoso o un error. Con los tipos unión, podríamos definir un tipo que puede contener uno de los dos de manera más natural y legible.

En C#, un tipo unión se implementa mediante la palabra clave union, que permite definir un tipo de datos cuyas instancias pueden contener valores de uno de los tipos que se hayan especificado. Uf, es difícil de describir, pero seguro lo veremos más claro con unos ejemplos.

Podríamos definir un tipo unión para representar el resultado de una operación que puede devolver un usuario o un error:

public union GetUserResult (User, Error);

También podríamos usarlo para agrupar diferentes tipos de vehículos en un solo tipo, sin necesidad de crear abstracciones, como una jerarquía de clases o interfaces:

public union Vehicle (Car, Bike, Truck);

También podríamos representar un identificador que podría ser un número entero, una cadena o un GUID:

public union ItemIdentifier (int, string, Guid);

Como podréis intuir, no hay ningún límite. El tipo unión puede contener cualquier combinación de tipos, incluso tipos personalizados o tipos genéricos, y que no tengan ninguna relación entre ellos.

Uso de tipos unión

Una vez creado el tipo unión, podemos usarlo para declarar variables y asignarles valores de cualquiera de los tipos que lo componen, porque el lenguaje permitirá la conversión implícita:

ItemIdentifier id = 123; // Puede ser un entero

id = "abc"; // O una cadena
id = Guid.NewGuid(); // O un GUID

Aunque obviamente, no podremos hacerlo al revés. La conversión implícita solo funciona en un sentido, de los tipos incluidos en la unión hacia el tipo unión:

ItemIdentifier id = 123; // Correcto
int intId = id; // Error de compilación, no se puede convertir porque
                // no sabemos el tipo de datos que contiene la variable id

También, dado que se trata de un tipo de datos normal, podremos utilizarlo para enviar argumentos o retornar valores de funciones o métodos, como vemos en el siguiente ejemplo:

public union GetUserResult (User, Error);
...
public GetUserResult GetUser(int userId) 
{
     ... // Retorna un objeto User o un objeto Error
}

Fijaos que en este caso, podríamos estar tentados a retornar un object, pero entonces no tendríamos ningún control en tiempo de compilación, el código sería propenso a errores en tiempo de ejecución y menos legible, porque un consumidor nunca podría deducir qué tipos de datos puede esperar en el retorno. Usando tipos unión, se realizan comprobaciones en compilación, de modo que si desde GetUser() intentásemos retornar algo que no sea User o Error, fallará al compilar, y leyendo la firma del método quedarán claras nuestras intenciones.

Una vez tenemos un valor de tipo unión, la forma de uso habitual será realizar comparaciones de tipo para poder acceder a su valor y procesarlo adecuadamente. Lo normal en estos casos será utilizar pattern matching, como en el siguiente ejemplo:

ItemIdentifier id = GetItemIdentifier(); // Retorna el tipo unión ItemIdentifier
if(id is int intId) 
{
    Console.WriteLine($"El identificador es un entero: {intId}");
}
else if(id is string strId) 
{
    Console.WriteLine($"El identificador es una cadena: {strId}");
}
else if(id is Guid guidId) 
{
    Console.WriteLine($"El identificador es un GUID: {guidId}");
}

Sin embargo, lo más habitual será utilizar expresiones switch para manejar los diferentes casos, como en el siguiente ejemplo:

ItemIdentifier id = GetItemIdentifier(); // Retorna el tipo unión ItemIdentifier
Console.WriteLine(id switch 
{
    int intId => $"El identificador es un entero: {intId}",
    string strId => $"El identificador es una cadena: {strId}",
    Guid guidId => $"El identificador es un GUID: {guidId}"
});

La ventaja de esta sintaxis, además de ser concisa, es que el compilador puede verificar que se han manejado todos los casos posibles, y si no es así, nos avisará con un warning de compilación. Por ejemplo, si olvidamos manejar el caso de Guid, el compilador nos avisará de que no se ha manejado ese tipo:

warning CS8509: The switch expression does not handle all possible values of its input type
(it is not exhaustive). For example, the pattern 'System.Guid' is not covered.

Como veremos más adelante, los tipos unión generan un struct que cumple una serie de requisitos. Pero como estructura que es, también podemos añadirle métodos, propiedades o incluso operadores personalizados. Podemos observarlo en el siguiente ejemplo, donde definimos un tipo llamado SingleOrMany<T> que puede contener un solo valor del tipo T o una colección de Ts, y que además tiene un método para contar el número de elementos que contiene y otro para obtener los elementos como enumeración:

SingleOrMany<int> value;
value = 5;
Console.WriteLine($"Count: {value.Count()}");
Console.WriteLine($"Elements: {string.Join(", ", value.AsEnumerable())}");

value = new[] { 1, 2, 3, 4 };
Console.WriteLine($"Count: {value.Count()}");
Console.WriteLine($"Elements: {string.Join(", ", value.AsEnumerable())}");

public union SingleOrMany<T> (T, IEnumerable<T>)
{
    public int Count() 
    {
        if (Value is T) return 1;
        if (Value is IEnumerable<T> collection) return collection.Count();
        return 0;
    }

    public IEnumerable<T> AsEnumerable() 
    {
        return Value switch 
        {
            T single => [single],
            IEnumerable<T> collection => collection,
            _ => []
        };
    }
}

¿Cómo funciona esto por debajo?

Para poder entender bien esta característica, es importante saber cómo funciona bajo el capó. Vamos a verlo partiendo del tipo ItemIdentifier que hemos definido algo más arriba:

public union ItemIdentifier (int, string, Guid);

A partir de esta declaración, el compilador de C# se encargará de crear una estructura llamada ItemIdentifier, decorada con el atributo [Union] y que implementa la interfaz IUnion. El contrato de la interfaz solo obliga a tener una propiedad de lectura Value de tipo object?:

public interface IUnion
{
    object? Value { get; }
}

Esto implica que, en cualquier tipo unión, podremos acceder a la propiedad Value para obtener el object que contiene:

ItemIdentifier id = 123;
object? value = id.Value; // value es un object? que contiene el entero 123

Además de implementar dicha interfaz, la estructura generada proporciona constructores públicos para cada uno de los tipos que forman la unión, de forma que se puedan crear instancias de ItemIdentifier a partir de cualquiera de sus valores. El código completo generado por el compilador para el tipo unión ItemIdentifier sería algo así:

[Union]
public struct ItemIdentifier : IUnion
{
  public object? Value { get; }
  public ItemIdentifier(int value) => this.Value = (object) value;
  public ItemIdentifier(string value) => this.Value = (object) value;
  public ItemIdentifier(Guid value) => this.Value = (object) value;
}

Fijaos que en el código no aparecen los operadores de conversión implícita; las conversiones se realizan directamente a través del lenguaje, usando los constructores:

ItemIdentifier id = 123; // Se llama al constructor ItemIdentifier(int value)

El código que hemos visto arriba es el que genera el compilador por nosotros para los tipos unión declarados en C#, pero nosotros podemos crear tipos unión personalizados siguiendo este mismo patrón manualmente. Basta con decorar una clase, estructura o registro con el atributo [Union], implementar la interfaz IUnion y proporcionar constructores públicos para cada uno de los tipos que queramos incluir. Por ejemplo, el siguiente código define un tipo unión llamado Vehicle que puede contener un Car, una Bike o un Truck:

[Union]
public class Vehicle : IUnion
{
    public object? Value { get; }

    public Vehicle(Car value) => this.Value = (object)value;
    public Vehicle(Bike value) => this.Value = (object)value;
    public Vehicle(Truck value) => this.Value = (object)value;
}

Esta posibilidad puede ser útil en escenarios donde queramos tener un control total sobre la implementación del tipo unión, o cuando queramos incluir lógica adicional en los constructores o en la propiedad Value. Por ejemplo, dado que por defecto se utiliza un object para almacenar el valor de la unión, podríamos querer crear una implementación personalizada que evite el sobrecoste del boxing de tipos de valor.

¿Cómo puedo probar los tipos unión?

Para poder probar esta nueva característica del lenguaje a día de hoy, lo más sencillo es instalar la última versión de .NET 11 Preview, y habilitar las características preliminares de C# 15. Para ello, basta con añadir el siguiente elemento al archivo .csproj de nuestro proyecto:

<PropertyGroup>
  <LangVersion>preview</LangVersion>
</PropertyGroup>

En noviembre de 2026, cuando se lance oficialmente .NET 11, esta configuración ya no será necesaria, y podremos usar los tipos unión sin necesidad de habilitar nada, simplemente compilando con el SDK de .NET 11.

Hay que tener en cuenta que se trata de una característica del lenguaje, por lo que en realidad podría utilizarse en cualquier proyecto .NET, independientemente de su target framework, siempre que se compile con el SDK de .NET 11. Eso sí, en algunas preview tempranas de .NET 11 habrá que crear manualmente la interfaz IUnion y el atributo Union porque no estarán disponibles de forma nativa en las bibliotecas de clases de .NET.

En resumen

Los tipos unión son una nueva característica de C# 15 que nos permiten definir tipos de datos que pueden contener valores de diferentes tipos, con controles en tiempo de compilación y sin complicaciones adicionales.

Esta capacidad nos ayudará a escribir código más limpio, legible y seguro, especialmente en escenarios donde una función o método puede devolver diferentes tipos de resultados.

Referencias:

Publicado en: www.variablenotfound.com.

Enlaces interesantes 651

2026-06-08T08:02:00.000+02:00

El evento Microsoft Build 2026 ha sido el gran protagonista de la semana, con tantos anuncios interesantes que cuesta trabajo citar sólo unos pocos: siete nuevos modelos AI propios, el framework UI Reactor, GitHub Copilot para escritorio, novedades en Windows para desarrolladores y plataformas de agentes, una nueva versión del chip cuántico Majorana, Azure Cobalt VM, HorizonDB, Windows NVidia RTX Spark, e incluso un divertido sistema operativo cuyas herramientas se van autogenerando mediante alucinaciones de la IA 😄🤯

Pero aún así, se han publicado otras muchas cosas que no deberíamos dejar de leer. Por ejemplo, ahora que estamos intentando asimilar el giro brutal de la política de precios de Github Copilot, Bruno Capuano nos ofrece consejos basados en su propia experiencia sobre cómo usar GitHub Copilot de forma efectiva, sin quemar el presupuesto de tokens en un rato. Muy recomendable si usas esta herramienta y quieres sacarle el máximo partido.

¿Puede un endpoint de .NET manejar un millón de solicitudes por segundo? Patrick Kearns nos cuenta cuáles son los cuellos de botella reales si pretendemos alcanzar ese nivel de rendimiento, y qué podemos hacer para mejorar el rendimiento de nuestras aplicaciones ASP.NET Core.

Hector Pérez nos muestra cómo aprovechar las nuevas capacidades de validación de formularios en Blazor 10, con ejemplos prácticos y consejos para mejorar la experiencia de usuario.

Se ha presentado Angular 22, con el nuevo Signal Forms, primitivas de accesibilidad, reactividad asíncrona y otras mejoras, muchas enfocadas en facilitar el desarrollo mediante IA.

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

Por si te lo perdiste...

Cómo obtener el nombre de la clase actual en .NET
José M. Aguilar
Implementación por defecto en interfaces de C#8, un primer vistazo
José M. Aguilar

.NET

Microsoft.UI.Reactor: A declarative, component-based C# framework for building WinUI 3 desktop apps Microsoft
How to Use Build5Nines.SharpVector with Microsoft Agent Framework for Local RAG in C#
Chris Pietschmann
Introducing ReflectionIT.PropertyThrowGenerator - Add compile‑time validated properties to your C# classes with zero boilerplate
Fons Sonnemans
Pointers in C# and Memory Safety: Span vs. C# 16 unsafe
NDepend Team
Getting Started with Claude in .NET
Yohan Malshika

ASP.NET Core / ASP.NET / Blazor

Aspire 13.4 is here
Maddy Montaquila
Can a .NET endpoint handle a million requests per second?
Patrick Kearns
Lost ASP.NET Identity Cookies on IIS Application Pool Restarts
Rick Strahl
ASP.NET Core Web API in .NET: The Complete Guide
Nick Cosentino
Integration Testing ASP.NET Core APIs with WebApplicationFactory
Sudhir Mangla
Advanced Form Validation in Blazor 10
Héctor Pérez

Azure / Cloud

New Azure Cobalt 200 VMs deliver 50% performance improvement, fully optimized for modern agentic AI workloads
Arun Kishan & Selim Bilgin
Azure HorizonDB: Enterprise-Ready Postgres, Engineered for the AI Era
Charles Feddersen
Better Deployment Errors in az webapp deploy
Tulika Chaudharie
Understand What’s Happening with Your App Service for Linux Website Using Site Status
Tulika Chaudharie

Conceptos / Patrones / Buenas prácticas

When to Use Chain of Responsibility Pattern in C#: Decision Guide with Examples
Nick Cosentino
You're Shipping Bugs Faster, and Your Tests Are Helping & The Machine Writes. The Legacy Is Still Mine.
Martin Stühmer
40 Lessons I Learned in 12 Years as a .NET Developer
Anton Martyniuk
Modular Monolith Boundaries Done Wrong
Derek Comartin
JPEG compression
Sophie L. Wang

Data

PagedResults in EF Core: One class, endless reuse
David Grace
Pagination in EF Core, Continued: Sortable Grids, htmx, and the Indexing Cost
Chris Woodruff

Machine learning / IA

Bringing Gemma 4 12B to your Laptop: Unlocking Local, Agentic Workflows with Google AI Edge & Gemma 4 12B: The Developer Guide
Google
Welcome NVIDIA Cosmos 3: The First Open Omni-model for Physical AI Reasoning and Action
Asawaree & Atharva Joshi
Announcing Microsoft Web IQ
Microsoft
VibeOS - Fully Hallucinated Operating System
Steve Sanderson
Introducing Microsoft Scout: Your always-on personal agent
Omar Shahine
Building a hill-climbing machine: Launching seven new MAI models
Mustafa Suleyman
GitHub Copilot and tokens: how to keep using AI without burning your budget in three prompts (some personal lessons learned!)
Bruno Capuano
AdaBoost.R2 Regression Using C#
James McCaffrey
MAI-Image-2.5 support in ElBruno.Text2Image and the t2i CLI
Bruno Capuano
Expanding on‑device AI in Microsoft Edge: New models and APIs for the web
Sohum Chatterjee
Agent Control Specification: Portable runtime governance for AI Agents
Lisa Brown Jaloza

Web / HTML / CSS / Javascript

Announcing Angular v22
Angular
New to the web platform in May
Rachel Andrew
Astro Markdown Component Utility for Any Framework
Zell Liew
In-N-Out Animations: Dialogs (Part 1/3)
Chris Coyier
::search-text
Sunkanmi Fafowora
Fix Common TypeScript Issues
Elizaveta Myšáková
Another Stab at the Perfect CSS Pie Chart... Sans JavaScript!
Antoine Villepreux
@function
Declan Chidlow
offset-path
Geoff Graham
Obscuring Text with @counter-style & Word Rotator with @counter-style
Preethi Sam

Visual Studio / Complementos / Herramientas

Cómo crear un status line personalizado para GitHub Copilot CLI
Gisela Torres
Announcing Intelligent Terminal 0.1
Anas Mazouni
GitHub Copilot Credit Based Usage Is Live
Mitchel Sellers
What's Coming Next in Visual Studio: Our Microsoft Build 2026 Announcements
Mads Kristensen
Keeping the Computer Awake
Joel Ivory Johnson
GitHub Copilot app: The agent-native desktop experience
Mario Rodriguez
How Microsoft is migrating repositories to GitHub
Grant Trimble
Azure DevOps and GitHub: Journeying into the AI Era
Tim Chermin
Visual Studio 2026, 6 Months Later
Dave Brock
Build 2026: Furthering Windows as the trusted platform for development
Pavan Davuluri, Executive Vice President, Windows + Devices

.NET MAUI

Why Nested ListView Breaks Down Faster Than You Expect in .NET MAUI
Anandh Ganesan
5 Heart Animations Using .NET MAUI
Leomaris Reyes

Otros

100.000 gracias, developers ❤️
Gisela Torres
¡¡Enhorabuena!!
Microsoft’s Majorana 2 is here
Catherine Bolgar
Introducing a powerful new chapter for Windows PCs, accelerated by NVIDIA RTX Spark
Pavan Davuluri
Elixir v1.20 released: now a gradually typed language
José Valim
The placeholder name for the Windows 8 experience was "modern"
Raymond Chen
Coding Isn’t Fun Anymore — And Maybe That’s Okay
Miguel Teherán

Publicado en Variable not found.

Enlaces interesantes 650

2026-06-01T08:00:00.000+02:00

Mientras programamos, todos hemos dicho alguna vez "voy a tomar este atajo", "ya lo solucionaré en el futuro", "lo dejo hardcodeado por ahora"... y el código se queda así para siempre. Viene bien reflexionar sobre lo que estas decisiones implican, como las reflexiones de Martin Stühmer sobre lo crueles que somos a veces con nuestro yo del futuro, en un par de posts con títulos muy ilustrativos: My biggest enemy writes my code y I’m done making empty promises.

Interesante también el artículo de Fran Iglesias explicando cómo usar métricas objetivas —no solo intuiciones o “elegancia”— para decidir cuándo y cómo refactorizar código con el fin de reducir costes de mantenimiento y mejorar la calidad.

Agentes, agentes IA everywhere... Pero, ¿cómo funcionan por detrás los agentes IA? En este post de Waldek Mastykarz nos explica el flujo de trabajo un agente para que podamos comprenderlo de forma sencilla.

También, Chris Pietschmann nos lleva de nuevo a las bases para revisar los ámbitos de vida de servicios en .NET (Singleton, Scoped y Transient) y entender cuándo usar cada uno de ellos.

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

Por si te lo perdiste...

Obtener información sobre el origen de la invocación de un método con los atributos "caller info" de .NET
José M. Aguilar
Tipos referencia anulables en C# 8
José M. Aguilar

.NET

No llames a BuildServiceProvider()
Fernando Escolar
Automatically getting API difference diagrams in your .NET PRs
Morten Nielsen
C#: Should This Service Be Singleton, Scoped, or Transient?
Chris Pietschmann
The Support Length for .NET LTS and STS versions – Thomas Claudius Huber
Thomas Claudius Huber
In C#, When Should You Use Exceptions, Result Objects, or Validation Errors?
Chris Pietschmann
Python for .NET devs: data types, classes, objects, records and interfaces
Davide Bellone
C# Nullable Types Explained (2026)
NDepend Team

ASP.NET Core / ASP.NET / Blazor

Designing high-throughput APIs for 1M requests/minute .NET
Ali Hamza Ansari
Running ASP.NET Core Applications as a Subfolder Application
Rick Strahl
AI-Powered Content Summarization and File Organization in Blazor File Manager
Keerthana Rajendran

Conceptos / Patrones / Buenas prácticas

Refactoring dirigido por métricas
Fran Iglesias
My Biggest Enemy Writes My Code & I'm Done Making Empty Promises
Martin Stühmer
How to Scale Long-Running API Requests
Milan Jovanović

Data

EF Core without migrations - it's only a matter of time
David Grace
Using ExecutionLog views in SQL Server Reporting Services to monitor performance
Bart Wullems
Pagination in Entity Framework Core: Why Skip/Take Falls Apart on Hot Tables
Chris Woodruff
EF Core 10–Smarter parameterized collections
Bart Wullems

Machine learning / IA

Introducing Claude Opus 4.8
Anthropic
How LLMs Work, Part 1: How LLMs Process Text
Shubham Raizada
How AI coding agents actually use your technology
Waldek Mastykarz
Anatomy of an Open-Source AI Coding Agent Built in .NET: CodeAlta
NDepend Team

Web / HTML / CSS / Javascript

Cross-Document View Transitions: Scaling Across Hundreds of Elements
Durgesh Rajubhai Pawar
Revealing Text With CSS letter-spacing
Preethi
Managing Anchor Associations With Data Attributes and Advanced attr()
Daniel Schwarz
Measuring Performance in FrontEnd using FPS — Latish Sehgal
Latish Sehgal
Algorithmic Theming Engines: Building Self-Correcting Color Systems With contrast-color()
Durgesh Pawar
<search>: HTML generic search element
MDN
What’s !important
Daniel Schwarz
The Fundamentals and Dev Experience of CSS @function
Jane Ori
How to add icons to external links with CSS
Chris Ferdinandi

Visual Studio / Complementos / Herramientas

Doing More with GitHub Copilot as a .NET Developer
Wendy Breiding
Visual Studio May Update – Plan, Review, Refine
Mark Downie

.NET MAUI

.NET MAUI changes its engine: what it means for your mobile app
Sebastián Cabrera
Give Your .NET MAUI Android Apps a Material 3 Makeover
Gerald Versluis
Share Functionality in Your .NET MAUI Apps
Leomaris Reyes

Otros

Un informático en el lado del mal: Un rato con mi amigo José Manuel Alarcón de CampusMVP
Chema Alonso
Technical Writing in the AI Age
Geoff Graham

Publicado en Variable not found.

Filtros de solución en Visual Studio y .NET (.slnf)

2026-05-26T08:01:00.000+02:00

Probablemente alguna vez habréis trabajado en Visual Studio con una solución .NET enorme, con decenas o centenares de proyectos. Es algo habitual en sistemas que tienen ya muchos años de vida, con una arquitectura muy compleja o que han ido creciendo con el tiempo sin un control adecuado.

En estos casos, el entorno de desarrollo tarda una eternidad en cargar la solución y quedar listo para su uso, el rendimiento de Visual Studio se resiente enormemente, con lo que cada acción que realicemos (compilar, ejecutar, depurar, etc.) se vuelve lenta y frustrante, y encima, al navegar por el código, todo se complicará bastante por la cantidad de proyectos y archivos que tendremos que manejar.

Y lo peor de todo es que es para nada. En la mayoría de los casos no es necesario tener todos los proyectos de la solución cargados para poder realizar nuestras tareas, porque lo habitual es que solo trabajemos con un subconjunto de ellos, normalmente bastante pequeño.

Afortunadamente, .NET permite crear filtros de solución (archivos .slnf), algo así como mini-soluciones que incluyen solo los proyectos que nos interesan en cada ocasión, mejorando el rendimiento de los entornos de desarrollo y facilitando la navegación por el código.

En este artículo vamos a ver qué son los filtros de solución, cómo crearlos y cómo usarlos.

¿Qué son los filtros de solución?

Los filtros de solución fueron introducidos hace ya unos años, con Visual Studio 2019 y .NET Core 3.1. Se trata de una forma de crear vistas personalizadas de una solución donde solo se incluyen los proyectos con los que queremos trabajar en cada momento.

En la práctica, son simples archivos de JSON con extensión .slnf que contienen una referencia a una solución normal (archivo .sln o .slnx) y la lista de proyectos que queremos incluir en el filtro. Una vez creados, podemos abrir estos archivos directamente desde Visual Studio o nuestro editor favorito, y solo cargarán los proyectos que hayamos incluido en el filtro.

Como ejemplo, a continuación se muestra el contenido de un filtro de solución, llamado OneToFour.slnf, que incluye solo los proyectos 1, 2, 3 y 4 de una solución con 300 proyectos llamada VeryBigSolution.slnx (vale, quizás es un escenario algo exagerado, pero sirve para ilustrar la idea):

{
  "solution": {
    "path": "VeryBigSolution.slnx",
    "projects": [
      "Project01/Project01.csproj",
      "Project02/Project02.csproj",
      "Project03/Project03.csproj",
      "Project04/Project04.csproj"
    ]
  }
}

Imaginaos el cambio que supone manejar solo 4 proyectos en lugar de los 300 que tiene la solución original. La carga de la solución en Visual Studio será mucho más rápida, así como el rendimiento general del entorno de desarrollo y las acciones habituales que realizamos en él, como compilar, ejecutar, depurar, navegar por el código, etc.

Los archivos .slnf son soportados también a nivel de framework desde .NET Core 3.1, lo que quiere decir que podemos lanzar comandos de CLI como dotnet build, dotnet test, o incluso msbuild apuntando a un archivo de filtro de solución, y se ejecutarán solo con los proyectos que estén incluidos en dicho filtro.

D:\Projects\VeryBigSolution>dotnet build OneToFour.slnf
Restore complete (0,6s)
  Project03 net10.0 succeeded (0,1s) → Project03\bin\Debug\net10.0\Project03.dll
  Project02 net10.0 succeeded (0,1s) → Project02\bin\Debug\net10.0\Project02.dll
  Project04 net10.0 succeeded (0,2s) → Project04\bin\Debug\net10.0\Project04.dll
  Project01 net10.0 succeeded (0,2s) → Project01\bin\Debug\net10.0\Project01.dll

Build succeeded in 1,1s

En realidad, es parecido a lo que conseguiríamos creando soluciones normales (.sln/.slnx) con distintos subconjuntos de proyectos. Sin embargo, si lo hiciéramos de esta forma, tendríamos que encargarnos de gestionar varias soluciones, con sus configuraciones, perfiles y otras cosas; en cambio, con los filtros de solución, solo tenemos que mantener una solución normal y varios archivos de filtro que la referencien, por lo que todo será más sencillo y fácil de mantener.

Por ultimo, es conveniente aclarar que por cada solución podemos tener tantos archivos .slnf como queramos, cada uno con un subconjunto diferente de proyectos. De esta forma, podríamos tener un filtro para cada área funcional del sistema, para cada equipo de desarrollo, para cada tarea concreta que tengamos que realizar, etc.

¿Cómo crear un filtro de solución?

Al tratarse de archivos .json, bastaría con crearlos manualmente con un editor de texto cualquiera, siempre que sigamos la estructura que hemos visto antes.

Sin embargo, Visual Studio también nos ofrece una forma muy sencilla de crearlos a través del entorno gráfico. Para ello, lo único que tenemos que hacer es abrir la solución normal (archivo .sln o .slnx), usar el menú contextual del Explorador de Soluciones para descargar los proyectos que no nos interesen, y finalmente ir a Archivo > Guardar como solución filtrada... y elegir un nombre para el nuevo filtro de solución.

A partir de aquí, ya la cosa pasa a ser completamente artesana. Si queremos añadir nuevos proyectos al filtro o eliminar algunos existentes, tendremos que retocar el archivo .slnf manualmente, o bien volver a generarlo desde Visual Studio siguiendo el procedimiento descrito antes.

¡Espero que os resulte útil!

Publicado en Variable not found.

Enlaces interesantes 649

2026-05-25T08:00:00.000+02:00

Esta semana se ha lanzado Gemini 3.5 Flash, la nueva versión de los modelos de lenguaje de Google, con mejoras significativas en rendimiento y capacidades. José Manuel Alarcón analiza qué cambios trae esta actualización para los desarrolladores.

Hay casos de uso que funcionan bien y otros que fallan, pero, ¿qué ocurre con los que funcionan a medias? En este artículo, Milan Jovanović analiza cómo diseñar para el fallo parcial en .NET, explorando estrategias para manejar situaciones donde una operación no se completa en su totalidad.

Martin Stühmer nos recuerda que el código que escribimos hoy puede convertirse en un problema para otros, o incluso nosotros mismos, en el futuro, destacando la importancia de escribir código limpio y mantenible.

El posicionamiento en CSS ha sido un desafío para los desarrolladores durante mucho tiempo, especialmente al intentar mostrar tooltips relativos a elementos del DOM. Manikanda Akash Munisamy explora cómo los anchors en CSS podrían poner fin a los cálculos manuales para alinear estos elementos.

Y por último, me ha parecido interesante compartir este artículo de Barry Pollard y Noam Rosenthal sobre las actualizaciones parciales declarativas en Chrome, una nueva característica que permite a los desarrolladores actualizar solo partes específicas de una página web sin necesidad de recargar toda la página, mejorando así la experiencia del usuario.

El resto de enlaces, a continuación.

Por si te lo perdiste...

Comparación natural de cadenas en .NET 10
José M. Aguilar
Null coalescing assigment "??=", el nuevo operador de asignación en C# 8
José M. Aguilar

.NET

NuGet Package Pruning: Cleaner Dependencies and Actionable Vulnerability Reports
Nikolche Kolev
Zstandard compression in .NET 11
Steven Giesel
.NET finally gets union types🎉
Andrew Lock
How to build .NET obfuscator
Andrii Kurdiumov
Improving C# Memory Safety
Jaren Duan
Announcing Agent Governance Toolkit MCP Extensions for .NET
Jack Batzner
Six Ways ILogger Silently Fails in Production
Martin Stühmer
Reflection Performance in .NET 10: Benchmarks, Caching, and Delegates
Nick Cosentino

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

Introducing Syncfusion Toolkit for Blazor: Free Open-Source Blazor Components
Saravanan G.
Blazor - How to set a base component for all Razor components
Gérald Barré
How to upload files in an ASP.NET Core Web API
Ali Hamza Ansari
How to Migrate from ASP.NET Framework to ASP.NET Core
Gopinath Karunanithi
Your dev loop is full of tribal knowledge
David Fowler

Azure / Cloud

How to run evals for the model router
Sanjeev Jagtap

Conceptos / Patrones / Buenas prácticas

When Your Use Case Half-Succeeds: Designing for Partial Failure in .NET
Milan Jovanović
The Code You Write Today Is Someone's Problem Tomorrow
Martin Stühmer

Data

What Is a JSON Database and Why Are They Useful?
Matthew Groves
Demystifying PIVOT and UNPIVOT in T-SQL
Edward Pollack
An EF Core alternative for .NET apps with complex object graphs — full LINQ, no migrations, no DbContext
Rinat Kozin

Machine learning / IA

Gemini 3.5 Flash: qué cambia de verdad para desarrolladores
José Manuel Alarcón
NPU vs GPU: qué son, en qué se diferencian y cuál necesitas según lo que programes
José Manuel Alarcón
Gemini 3.5: frontier intelligence with action
Koray Kavukcuoglu & Jeff Dean & Oriol Vinyals & Noam Shazeer
Introducing Gemini Omni
Koray Kavukcuoglu
Agentic-Agile: Why Agent Development Needs Agile (Not Just Prompts)
Neil Van Heukelem
Introduction to LM Studio
Paul Michaels

Web / HTML / CSS / Javascript

CSS Anchor Positioning: The End of Manual Tooltip Calculations?
Manikanda Akash Munisamy
Cross-Document View Transitions: The Gotchas Nobody Mentions
Durgesh Rajubhai Pawar
TypeScript utility types you're probably underusing
Muhammed Ali
Moving away from Tailwind, and learning to structure my CSS
Julia Evans
TypeScript v6 is here: A full migration guide
Amazing Enyichi Agu
From latency to instant: Modernizing GitHub Issues navigation performance
Peter Ritchie
Better Browser Caching with No-Vary-Search
Harry Roberts
Advanced Tree Counting: Mathematical Layouts With sibling-index() And sibling-count()
Durgesh Pawar
What's missing in CSS layout
Patrick Brosset
Declarative partial updates
Barry Pollard & Noam Rosenthal
Choosing CSS Selectors for Production: Specificity, Modern Pseudo-Classes, and Maintainable Styles
Arunachalam Kandasamy Raja
The State of CSS Centering in 2026
Temani Afif

Visual Studio / Complementos / Herramientas

Plan Before You Build: Introducing the Plan agent in Visual Studio
Jonatas Siqueira
Improving Windows quality: Making Taskbar and Start more personal
Diego Baca

.NET MAUI

Build a Real-Time Weather Dashboard with .NET MAUI Tab View
Sneha Kumar
Installing and Basics of Telerik UI for .NET MAUI AI Coding Assistant
Héctor Pérez

Otros

Un informático en el lado del mal: Invaders Must Die!: "Cheating" Space Invaders con Inteligencia Artificial para ganar en mi Spectrum
Igor Lukic
Stack Overflow: When We Stop Asking
Sunkanmi Fafowora
Four Levels Of Customer Understanding
Vitaly Friedman

Publicado en Variable not found.

Enlaces interesantes 648

2026-05-18T08:01:00.000+02:00

Esta semana se ha lanzado la preview 4 de .NET 11, con novedades en el runtime, librerías, SDK, C#, ASP.NET Core, .NET MAUI y Entity Framework Core. Especialmente interesantes la compilación de librerías con el nuevo runtime asíncrono y las incorporaciones a la API Process.

Se ha anunciado que la aplicación de escritorio GitHub Copilot, la visión de Microsoft de lo que será el desarrollo agéntico, está ya disponible como technical preview. Si eres suscriptor de GitHub Copilot Pro o Pro+, puedes comenzar a probarla.

Milan Jovanović ha publicado un artículo muy interesante sobre el versionado de APIs, un tema que siempre genera debate y que él aborda desde una perspectiva muy práctica.

David Ortinau anuncia que el runtime de .NET MAUI abandona Mono y se moverá a CoreCLR en la próxima versión 11, lo que supone un gran paso adelante para esta plataforma, con mejoras en rendimiento, compatibilidad y experiencia de desarrollo.

Los futuros ordenadores cuánticos podrán romper sin demasiado esfuerzo los sistemas de cifrado actuales, lo que hace que la criptografía post-cuántica sea un tema cada vez más importante. Khalid Abuhakmeh ha publicado una guía práctica para implementarla en .NET 10, con ejemplos de algoritmos y librerías disponibles.

Por último, David Fowler ha publicado un artículo muy interesante sobre cómo la IA nos ha hecho más rápidos, pero también creó nuevos cuellos de botella que obligan a cambiar procesos y hábitos.

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

Por si te lo perdiste...

JavaScriptizando C#: chequeo de nulos usando conversores implícitos
José M. Aguilar
Etiquetado de consultas en Entity Framework Core
José M. Aguilar

.NET

.NET 11 Preview 4 is now available!
.NET Team
Process API Improvements in .NET 11
Adam Sitnik
BackgroundService exceptions now propagate in .NET 11
Steven Giesel
LINQ Filtering in C#: Where, Any, All, Contains, and OfType & LINQ Aggregation in C#: Count, Sum, Min, Max, Average, and Aggregate
Nick Cosentino
The field Keyword in C# 14: Write Less, Validate More
Khalid Abuhakmeh
Inspecting 3D objects (incl. gltf) with a 28-line C# script • Ben Bowen's Blog
Ben Bowen
Stop Pretending TimeProvider Doesn't Exist
Martin Stühmer
Post-Quantum Cryptography in .NET 10: A Practical Guide
Khalid Abuhakmeh
Creating a Simple MCP Server in .NET
Paul Michaels
10 .NET Open Source Libraries Every Developer Should Know in 2026
Vikrant Bagal

ASP.NET Core / ASP.NET / Blazor

Refactoring an ASP.NET Core API with clean architecture
David Grace
Implementing the Sidecar Pattern in Microservices-Based ASP.NET Core Applications
Joydip Kanjilal
Propagating OpenTelemetry context in .NET
Gérald Barré
Running background tasks in Blazor with Web Workers
Andrew Lock
Getting the Client IP Address in ASP.NET Core
Rick Strahl
Fixing a Blazor App with VS Code's New Agent Browser Sharing
David Ramel
Streaming Server Events with SSE and Blazor
Héctor Pérez

Azure / Cloud

Using AWS Locally with MiniStack and .NET
Ricardo Peres
Introducing Azure Container Apps Express!
Simon J.
Exponential backoff and circuit breaker for Service Bus-triggered Azure Functions
Swapnil Nagar

Conceptos / Patrones / Buenas prácticas

What Is Code?
Unmesh Joshi
C#: Inheritance vs Composition — When to Use Each and Why AI Can't Decide for You
Chris Pietschmann
Decision Trees: The unreasonable power of nested decision rules
Jared Wilber & Lucía Santamaría
API Versioning Should Be Your Last Resort
Milan Jovanović
Debugging Event-Driven Systems: 5 Problems Teams Create
Peter Ritchie

Data

EF Core: La explosión cartesiana — Hiciste todo bien y aun así el query es un desastre
Isaac Ojeda
The complete guide to mastering Dapper micro-ORM in .NET
Ali Hamza Ansari

Machine learning / IA

Agent Skills vs Custom Instructions en código IA: cuándo usar cada una
José Manuel Alarcón
AI Made Us Faster. That Was the Problem
David Fowler
Composition Stack for AI-Assisted .NET Development
Matt Mattei

Web / HTML / CSS / Javascript

Why Keyboard Users Can't Scroll Your Overflow Containers
Godstime Aburu
Computing and Displaying Discounted Prices in CSS
Preethi
Soon We Can Finally Banish JavaScript to the ShadowRealm
Mat Marquis
Callout UI with CSS Offset & Border
Preethi Sam
Repeating Square Dots Backgrounds in CSS
Chris Coyier
Install web apps with the new HTML install element
Patrick Bosset
What’s !important
Daniel Schwarz
How to Control Infinite CSS Animations (Part 2 of 2)
Temani Afif
How Claude Code works in large codebases: Best practices and where to start
Claude Team

Visual Studio / Complementos / Herramientas

.NET MAUI

.NET MAUI Moves to CoreCLR in .NET 11
David Ortinau
Build an AI-Powered Rich Text Editor in .NET MAUI with AI AssistView
Tamilarasan Gunasekaran
How to Verify Network Connectivity in .NET MAUI
Leomaris Reyes

Otros

Un cuadro de Monet y el nuevo ludismo
José Manuel Alarcón
Why do Windows client editions on 32-bit x86 systems artificially limit RAM to 4 GB?
Raymond Chen

Publicado en Variable not found.

¡Variable not found cumple 20 años! ¿Y ahora, qué?

2026-05-12T08:01:00.076+02:00

En 2006 estábamos en pleno apogeo de los blogs personales de contenido técnico. La comunidad de desarrolladores estaba creciendo a pasos agigantados, y los blogs eran una de las formas más populares de compartir conocimientos, experiencias y descubrimientos. Yo era un gran consumidor de estos contenidos y seguía fielmente a autores que, aún hoy, son referentes para mí en muchos aspectos.

Y aunque no sabía muy bien a dónde iba, el 8 de mayo decidí subirme a ese tren con la ilusión de aportar mi pequeño granito de arena a la comunidad y devolverle al menos una pequeña parte de lo que tanto me había dado a lo largo de los años.

Han pasado veinte años desde que escribí el primer post en Variable Not Found.

En este tiempo he publicado más de 1.600 entradas en las que he compartido mis conocimientos, experiencias y descubrimientos sobre desarrollo web, centrado sobre todo, aunque no exclusivamente, en el ecosistema de Microsoft. Los más de seis millones de visualizaciones que han tenido mis posts a lo largo de los años me han dado la oportunidad de alcanzar una audiencia global y conectar con personas de todo el mundo que comparten mi pasión por la tecnología, y llegar profesionalmente a lugares que nunca imaginé.

Muchas gracias a todos los que me habéis acompañado en este viaje, habéis leído mis posts, dejado comentarios, compartido mis contenidos y, en general, apoyado mi trabajo de alguna manera. Sin vosotros, nada de esto habría sido posible.

Pero como de costumbre, me gusta aprovechar estas fechas para mirar con frialdad y reflexionar sobre cómo vamos evolucionando y a dónde nos dirigimos. Porque, al igual que el año pasado, la cosa sigue pintando muy mal: el número de visitas sigue cayendo en picado, y la mayoría de los lectores que quedan por aquí son robots obteniendo el contenido publicado 😢

¿Vale la pena seguir adelante? Pues no lo tengo nada claro...

¿Es el fin de los blogs técnicos?

Realmente, si mirara hacia fuera y viera que el resto de blogs técnicos siguen existiendo y manteniendo su audiencia, podría pensar que el problema es mío: quizás mis contenidos ya no son interesantes para la comunidad, quizás no estoy haciendo un buen trabajo promocionándolos, o quién sabe.

Pero la realidad es que el descalabro de los blogs técnicos es generalizado. Solo hay que ver que muchos de los sitios que antes eran referentes en la comunidad han cerrado o han dejado de publicar con una regularidad razonable. Cada vez es más difícil encontrar contenido de calidad y actualizado con frecuencia.

Esto podría deberse a varios factores, como el auge de las redes sociales y canales alternativos (vídeos, podcasts, streaming...), la saturación de contenido en internet o la falta de tiempo y motivación para mantener un blog. Pero, sobre todo, creo que la dramática caída en el número de visitantes está consiguiendo que el esfuerzo de mantener un blog no merezca la pena. Al fin y al cabo, esto tiene sentido si hay alguien al otro lado, ¿no?

El factor que más está contribuyendo al vertiginoso descenso de las visitas a mi blog es la dramática caída en el uso de buscadores, algo de lo que dependía el tráfico de la mayoría de sitios de contenido técnico especializado. En mi caso, más del 80% del tráfico de Variable Not Found procedía de búsquedas orgánicas, así que es lógico que este batacazo salpique directamente a las métricas. A día de hoy, solo un 16% de los visitantes llega a través de buscadores.

Pero analizando las estadísticas de visitantes del blog, hay más datos que encienden las alarmas. En el último año, las páginas vistas han caído un 21%, aunque curiosamente el número de usuarios distintos ha subido un 58%:

Periodo	Usuarios distintos	Páginas vistas
2022-2023	90.000 (-16%)	150.000 (-17%)
2023-2024	62.000 (-31%)	121.000 (-19%)
2024-2025	29.000 (-53%)	80.000 (-34%)
2025-2026	46.000 (+58%)	64.000 (-21%)

Es decir, hay más visitantes, pero menos comprometidos con el sitio y sus contenidos. ¿Extraño, verdad?

Se puede explicar si echamos un vistazo al origen de los visitantes. Sospechosamente, más del 70% de los visitantes proceden de países como China o Singapur, algo raro teniendo en cuenta que mis contenidos no son precisamente los más amigables para esa audiencia. El año pasado, este porcentaje era solo del 3%, lo que indica que algo ha cambiado radicalmente en el último año.

Pero, además, sumémosle que el tráfico directo (es decir, que no viene de búsquedas, ni redes sociales ni enlaces externos) también sobrepasa el 70% del total, mientras que el año pasado era del 18%. Es decir, que la mayoría de los visitantes han comenzado a llegar a mi sitio sin pasar por ningún intermediario, lo que es muy raro teniendo en cuenta que no tengo una marca personal especialmente fuerte, ni una comunidad muy activa, ni los hábitos de consumo actuales incluyen visitar directamente los sitios web.

La conclusión es clara: gran parte del tráfico de Variable Not Found procede de bots, crawlers, scrapers, y otros bichillos de la fauna digital, probablemente alimentando modelos de IA con esta información. Modelos que más adelante podrán responder a sus usuarios usando esta información, pero que no aportan ningún valor a mi sitio ni a mi trabajo.

Porque lo que es indudable, y además imparable, es que los desarrolladores utilizamos casi exclusivamente la IA para resolver nuestras dudas. La era de buscar en Google y leer un post para resolver un problema concreto se ha acabado. Además, esto también se aprecia viendo el declive de otras comunidades de preguntas y respuestas como StackOverflow, CodeProject o Foros del Web, que han visto caer su tráfico de forma dramática en los últimos años.

No sé si otros blogs técnicos estarán observando esta misma tendencia en sus estadísticas, pero me temo que será así, puntos porcentuales arriba o abajo. Y en este caso, el futuro de los blogs técnicos no pinta nada bien.

Y hay otro detalle que también me preocupa: siempre he dicho que una de las principales utilidades de mi blog era la de servir como un cuaderno de notas donde apuntar lo que iba aprendiendo, y, de paso, que otros pudieran aprovecharlo. Yo era mi principal usuario, y visitaba mi blog con frecuencia para consultar mis propias anotaciones. Pero cuando veo que la mayoría de las veces incluso yo mismo no acudo a mi blog a consultar las dudas porque es más cómodo preguntárselo a mi modelo favorito, creo que algo no va bien.

No es demasiado motivador, ¿verdad?

¿Tiene sentido seguir adelante con Variable Not Found?

Pues no lo tengo nada claro, la verdad. Ya en el análisis del año pasado comentaba que el futuro no pintaba nada bien, y que temía que el blog quedara como pienso para alimentar las IAs, y parece que no me equivocaba demasiado.

Sigo disfrutando mucho escribiendo, principalmente porque me obliga a estudiar y aprender en profundidad sobre los temas que me interesan y porque pienso que a alguien le ayudará, pero si realmente no hay nadie al otro lado, ¿tiene sentido seguir invirtiendo tiempo y esfuerzo en ello? ¿No podría simplemente tomar notas para mi consumo personal y dedicar el tiempo que requiere gestionar el blog (que no es poco) a aprender otras cosas que me interesan?

En cualquier caso, dejarlo no sería una decisión sencilla. Variable Not Found forma parte de mi vida desde hace veinte años, y uno no puede desprenderse de algo así de un día para otro. Eso sí, cuando tenga que hacerlo, pasaré página orgulloso de haber llegado hasta aquí y con la satisfacción de haber intentado devolver a la comunidad una mínima parte de lo que ella me ha dado.

En fin, seamos positivos: de momento seguiré escribiendo como siempre, aunque, sinceramente, no sé por cuánto tiempo más. Que digo yo que alguien tendrá que dar de comer a las IAs, ¿no? 😁

Nuevamente, muchas gracias a todos por estar ahí. Vayamos a donde vayamos, siempre os agradeceré el apoyo que me habéis brindado a lo largo de estos veinte años.

¡Seguimos viéndonos por aquí!

Publicado en: www.variablenotfound.com.

Enlaces interesantes 647

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

Tras un mini parón por vacaciones, vuelvo a la carga con los enlaces interesantes, esta vez recopilados durante las dos últimas semanas, por lo es especialmente abundante. Cerca de 90 referencias a los que creo que vale la pena echar el vistazo para estar al día de lo que se cuece en .NET, ASP.NET Core, IA, Javascript, CSS y muchos otros temas relacionados con el desarrollo de software.

Por destacar algunos, encontramos a Isaac Ojeda hablando de cómo evitar el temido problema N+1 en Entity Framework Core, todo un clásico que merece ser recordado de vez en cuando-

Y otro clásico: cuando queremos crear un nuevo tipo en C#, ¿debería ser una clase, un record, una struct o una interfaz? Chris Pietschmann nos da su opinión al respecto, y una guía práctica para elegir la mejor opción en cada caso.

Martin Stühmer nos advierte sobre los costes ocultos de los Source Generators en .NET, una tecnología muy potente pero que puede afectar al rendimiento de la compilación si no se usa con cuidado.

Mario Rodriguez nos cuenta uno de los cambios que más pueden impactar en equipos y empresas este año: GitHub Copilot pasa a un modelo de facturación por uso. Si trabajas con esta IA a diario, este enlace es casi de lectura obligatoria.

Khalid Abuhakmeh pone el foco en un problema tan común como traicionero en producción: los límites de tamaño de cookies en ASP.NET Core, con causas y soluciones prácticas para evitar sustos en aspectos como autenticación y sesiones.

Oren Eini contrasta cómo se aprendía a programar en los 90 con la forma de hacerlo en la actualidad, y cómo la IA está transformando —y a veces debilitando— la comprensión profunda que necesitan los desarrolladores de hoy.

Esto y mucho más, a continuación.

Por si te lo perdiste...

Dispara la eficiencia de tus búsquedas en memoria con .NET usando SearchValues
José M. Aguilar
Índices y rangos en C# 8 (2 de 2)
José M. Aguilar

.NET

Microsoft WinApp CLI: la herramienta que unifica el desarrollo para Windows
José Manuel Alarcón
Cómo manejar fallos transitorios en .NET con Polly y ResiliencePipelineBuilder
Isaac Ojeda
Announcing the WinApp VS Code Extension — Run, Debug, and Package Windows Apps in VS Code -
Chiara Mooney
The best way to create email templates in .NET
David Grace
ConfigurationIgnoreAttribute in .NET 11
Steven Giesel
C# Regex: Complete Guide to Regular Expressions in .NET
Nick Cosentino
Docker Support for Isolator
Ricardo Peres
High-Performance Distributed Caching with .NET and Postgres on Azure
Matthew Schwartz
Welcome to SkiaSharp 4.0 Preview 1
David Ortinau
VSTest is Removing its Newtonsoft.Json Dependency
McKenna Barlow
Your Privacy Docs Are Fiction: Let's Fix That with .NET CLI Tools
Martin Stühmer
Harden Your .NET JSON Deserialization with System.Text.Json and JsonSerializerOptions.Strict
Khalid Abuhakmeh
Introducing ReflectionIT.DisposeGenerator — A Modern Source Generator for the Dispose Pattern
Fons Sonnemans
C# / .NET Performance: Why Is It Slow 'Here' and What Should You Optimize First?
Chris Pietschmann
Multi-layer Caching with the Decorator Pattern
Ian Griffiths
Pattern matching in C#: Advanced scenarios you didn't know
Ali Hamza Ansari
Source Generators: The Build Performance Killer Nobody Warned You About
Martin Stühmer
C# Records
Ricardo Peres
LINQ in C#: Complete Guide to Language Integrated Query (.NET 6-9)
Nick Cosentino
C#: Should This Be a Class, Record, Struct, or Interface?
Chris Pietschmann

ASP.NET Core / ASP.NET / Blazor

ASP.NET: How to Structure a Growing Application So It Stays Maintainable
Chris Pietschmann
Combining API versioning with OpenAPI in .NET 10 applications
Sander ten Brinke Author
ASP.NET Core Cookie Size Limits in Production: Causes and Fixes
Khalid Abuhakmeh
Blazing.Mvvm - Production MVVM for Every Blazor Hosting Model
Graeme Grant
How to migrate from controllers to Minimal APIs
David Grace
The Cleanest Way to Introduce a New Cross-Cutting Concern
Chris Pietschmann
Disable HTTP caching by default in ASP.NET Core APIs
Gérald Barré
SimpleChat: A Provider-Agnostic AI Chat Starter for Blazor
Michael Washington
Copilot Studio gets faster with .NET 10 on WebAssembly
Daniel Roth

Azure / Cloud

SQL MCP Server as an App Service
Mathew Kishe
Introducing the Azure Resource Manager MCP Server!
Steven Bucher

Conceptos / Patrones / Buenas prácticas

Ports & Adapters: cómo aislar tu núcleo de todo lo que puede cambiar
Isaac Ojeda
Just Use Postgres as a Queue?
Derek Comartin
Security Tests That Prove Themselves
Martin Stühmer
Bridge Design Pattern in C#: Complete Guide with Examples
Nick Cosentino
CQRS Without MediatR: Hand-Rolled Command and Query Handlers in .NET | Adrian Bailador
Adrian Bailador

Data

EF Core: N+1 — Una query en dev, mil queries en producción
Isaac Ojeda
How to Fix Slow EF Core Queries: Practical Performance Tuning
Arulraj Aboorvasamy
Azure Cosmos DB Conf 2026 Recap: Lessons from Production
Mark Brown
What are managed identities in SQL Server 2025? A complete guide
Greg Low
More Realistic Tests with In-Memory Databases ASP.NET Core
Assis Zang

Machine learning / IA

Eliminación de datos personales con IA: el modelo Open Source de OpenAI que se ejecuta en local
José Manuel Alarcón
La factura de la IA: por qué el talento pesa más que los tokens
David Carrero
GPT-5.5 Instant: smarter, clearer, and more personalized
OpenAI
GitHub Copilot is moving to usage-based billing
Mario Rodriguez
Multi-token-prediction in Gemma 4
Olivier Lacombe & Maarten Grootendorst
Governing MCP tool calls in .NET with the Agent Governance Toolkit
Jack Batzner
Microsoft Agent Framework - Building Blocks for AI Part 3
Jeremy Likness
Running GitHub Copilot CLI Offline with Local Models: A CPU-Only Reality Check & GPU Edition
Bruno Capuano
AI-Assisted Coding: A Practical Guide for Software Engineers & * AI Amplifies Everything: A Team Lead’s Guide to AI-Assisted Development
Durgesh Rajubhai Pawar
Quadratic Regression with Pseudo-Inverse Training Using C#
James McCaffrey
Durable Workflows in the Microsoft Agent Framework
Shyju Krishnankutty
.claudeignore Doesn't Exist. Here's What Does.
Martin Stühmer
Advancing voice intelligence with new models in the API
OpenAI

Web / HTML / CSS / Javascript

Let’s Use the Nonexistent ::nth-letter Selector Now
Lee Meyer
Build a Web-Based Production Planning Spreadsheet in React
Sumathi Uthayakumar
contrast() & contrast-color()
Gabriel Shoyombo

What’s !important#10: HTML-in-Canvas, Hex Maps, E-ink Optimization, and More
Daniel Schwarz
Fixed-Height Cards: More Fragile Than They Look
Kevine Nzapdi
CSS n of Selectors for Conditional Validation
Preethi Sam
Generative colors with CSS
Chris Ferdinandi
The Importance of Native Randomness in CSS
Alvaro Montoro
Multi-stroke text effect in CSS
Yuan Chuan
Making Zigzag CSS Layouts With a Grid + Transform Trick
Durgesh Rajubhai Pawar
Why I don't chain everything in JavaScript anymore
Matt Smith
Animating Focus with View Transitions
Chris Coyier
A Scrollytelling Gift for Mum on Mother’s Day 2026
Lee Meyer
Using CSS corner-shape For Folded Corners
Daniel Schwarz
How to Control Infinite CSS Animations (Part 1 of 2)
Temani Afif

Visual Studio / Complementos / Herramientas

Control de calidad en Agentic DevOps: automatiza linting y formateo con hooks
Gisela Torres
VS Code Tunnels sin instalar VS Code: accede a tu máquina remota desde el navegador
Gisela Torres
ReSharper Made VS Code a Real Option for My .NET Work
Chris Woodruff
New features in Git 2.54: easier rebasing, hooks, and statistics
Andrew Lock
Visual Studio April Update – Cloud Agent Integration
Mark Downie
Visual Studio 2026 Gives IntelliSense Priority in Longstanding Copilot Completion Clash
David Ramel
TypeScript 7 Beta Now Enabled by Default in Visual Studio 2026 18.6 Insiders 3
Daniel Flöijer
The new Run dialog: faster, cleaner, and more capable
Clint Rutkas
SDK-Style Support for Extension Projects
Andrea Viel

.NET MAUI

Integrating Native Device Features in .NET MAUI with Built‑In APIs
Shalini Suresh
Integrating Haptic Feedback in .NET MAUI
Leomaris Reyes

Otros

¿Por qué Google financia a su mayor rival? El juego de ajedrez detrás de lo de Anthropic
José Manuel Alarcón
Learning to code, 1990s vs 2026
Oren Eini

Publicado en Variable not found.

Enlaces interesantes 646

2026-04-27T08:01:00.065+02:00

Entre los contenidos interesantes de esta semana, se ha anunciado la beta del esperado TypeScript 7.0 implementado en Go, prometiendo mejoras de rendimiento en compilación de hasta 10 veces respecto a las versiones anteriores. Y según comentan, que la "beta" no engañe: esta versión es ya bastante estable y en muchos escenarios podríamos empezar a usarla ya y disfrutar de sus mejoras, porque además podemos instalarla "side by side" con las versiones actuales.

Por otro lado, he de decir que los constructores primarios de C# no son mi opción por defecto cuando implemento una clase. Pero bueno, como hay que estar abierto a los cambios, me ha parecido interesante el post de Milan Jovanović donde explica por qué los usa al aplicar Inyección de Dependencias.

¿La IA es una moda pasajera, o lo cambia todo? Pienses lo que pienses, lo que es seguro es la tenemos encima, y tenemos que saber cómo lidiar con esta nueva situación. José Manuel Alarcón reflexiona sobre cómo la inteligencia artificial está transformando el trabajo real, lejos de los discursos apocalípticos o utópicos, y qué deberíamos hacer al respecto.

Por cierto, si usas un plan individual de GitHub Copilot, esto te interesa. Se vienen cambios para proteger la calidad del servicio ante el aumento de la demanda actual: nuevos registros en pausa, límites de uso más estrictos, modelos retirados...

Igor Roztropiński reflexiona sobre la complejidad del desarrollo frontend moderno, y se pregunta si es esencial o realmente innecesaria, proponiendo otros enfoques para reducirlo.

Gerson Azabache nos recuerda que los microservicios no son un objetivo sino una herramienta, y no encajan en todo tipo de proyectos.

Y por último, ¿el modelo Claude se llama así por puro chovinismo francés? Seguro que muchos pensábamos que sí. Pero CampusMVP nos cuenta qué hay detrás de este nombre, todo un homenaje al padre de la teoría de la información y uno de los pioneros de la informática moderna.

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

Por si te lo perdiste...

Tech on the Toilet: aprovechando "esos ratillos" para mejorar la calidad de nuestro software
José M. Aguilar
Índices y rangos en C# 8 (1 de 2)
José M. Aguilar

.NET

FluentValidation en .NET 10 sin ensuciar tus entidades (Clean Architecture + MediatR)
Romny Duarte
Writing Node.js addons with .NET Native AOT
Drew Noakes
.NET 10.0.7 Out-of-Band Security Update
Rahul Bhandari
Removing byte[] allocations in .NET Framework using ReadOnlySpan<T>
Andrew Lock
Who Ran That Migration?
Martin Stühmer
Why I Switched to Primary Constructors for DI in C#
Milan Jovanović
Evaluating CRON and RRule expressions in .NET
Gérald Barré
What's new for .NET in Ubuntu 26.04
Richard Lander
Revisiting C# Scripting with the Westwind.Scripting Templating Library, Part 1 & Putting the Westwind.Scripting Templating Library to work, Part 2
Rick Strahl

ASP.NET Core / ASP.NET / Blazor

AI-Powered File Search in Blazor File Manager: Semantic and Tag-Based
Keerthana Rajendran
The simplest way to secure a Minimal API (With Swagger)
David Grace
Blazor Basics: Getting Started with Blazor Development in VS Code
Claudio Bernasconi

Conceptos / Patrones / Buenas prácticas

El día que entendí que los microservicios no eran la solución para todo
Gerson Azabache Martínez
The 20 Software Engineering Laws
Dr Milan Milanović
Security Cosplay: Your Password-Only Admin Panel Isn't Fooling Anyone & Certified, Filed, Forgotten: The Compliance Trainwreck
Martin Stühmer

Data

12 practices for optimizing PostgreSQL queries for large datasets
Ali Hamza Ansari

Machine learning / IA

Por qué la IA de Anthropic se llama Claude (y por qué sin "Claude" no existiría la tecnología actual)
CampusMVP
Jailbreaking Nano Banana Just for Fun & Laughs
Chema Alonso
Introducing ChatGPT Images 2.0
openAI
Introducing GPT-5.5
OpenAI
Introducing Claude Design by Anthropic Labs \ Anthropic
Anthropic
Changes to GitHub Copilot Individual plans
Joe Binder
Securing MCP: A Control Plane for Agent Tool Execution
Jack Batzner

Web / HTML / CSS / Javascript

Announcing TypeScript 7.0 Beta
Gary Hepting
Modern Frontend Complexity: essential or accidental?
Igor Roztropiński
Markdown + Astro = ❤️
Zell Liew
The Web Is Fun Again: First Experiments with HTML in Canvas
Amit Sheen
Why I don't chain everything in JavaScript anymore
Matt Smith
Recreating Apple’s Vision Pro Animation in CSS
John Rhea
Constructable Stylesheets and adoptedStyleSheets: One Parse, Every Shadow Root
Rob Levin
Angular Grid at Scale: How Kendo UI Handles Millions of Rows
Dany Paredes
LangChain.js for Beginners: A Free Course to Build Agentic AI Apps with JavaScript
Yohan Lasorsa
Why I spent years trying to make CSS states predictable — tenphi.me
Andrey Yamanov
3 ways to store variables in React, and why you shouldn't sleep on useRef
Rachel Kaufman

Visual Studio / Complementos / Herramientas

Meet t2i — The ElBruno.Text2Image CLI
Bruno Capuano

Otros

IA y trabajo: quién gana (y quién sobra) en la nueva era laboral
José Manuel Alarcón
Sure, xor'ing a register with itself is the idiom for zeroing it out, but why not sub?
Raymond Chen

Publicado en Variable not found.

Enlaces interesantes 645

2026-04-20T07:45:00.040+02:00

Vamos una semana más con los enlaces a contenidos que me han llamado la atención durante los últimos días.

Entre ellos, vale la pena destacar que se ha anunciado la tercera preview de .NET 11, con novedades en C#, librerías, runtime, SDK, ASP.NET Core, Entity Framework y más. Las explica bastante bien Anton Martyniuk en su blog.

¿Los modelos LLM heredan comportamientos de sus "padres"? José Manuel Alarcón comparte un estudio reciente que sugiere que los modelos de lenguaje heredan sesgos cuando son entrenados con contenidos sintéticos. Muy interesante y da para reflexionar un rato sobre lo que viene.

También me ha parecido muy llamativo el proyecto personal de Konrad Kokosa, dotLLM, un motor de inferencia LLM escrito por completo en C#. En su blog explica cómo lo ha construido y los retos a los que se ha enfrentado.

Si trabajáis con Visual Studio y aún no habéis tenido ocasión de probar el agente de depuración de GitHub Copilot, en este post de Harshada Hole encontraréis un vídeo que muestra su uso (podéis ponerle el audio en español).

Y Martin Stühmer nos recuerda que almacenar secretos en appsettings.json es una mala idea, y muestra cómo podemos migrar a una solución más segura usando herramientas de Azure como Managed Identity y RBAC.

El resto de enlaces, a continuación.

Por si te lo perdiste...

Liberar automáticamente servicios creados de forma manual en ASP.NET Core
José M. Aguilar
Value Converters en Entity Framework Core
José M. Aguilar

.NET

Hacer logs en .NET hoy
Fernando Escolar
.NET 11 Preview 3 is now available!
Michael Taylor
New Features in .NET 11 Preview 3
Anton Martyniuk
Why I'm Building a Database Engine in C#
Loïc Baumann
Building a VS Code-Style Extension System in C#
Nick Cosentino
Introducing dotLLM - Building an LLM Inference Engine in C#
Konrad Kokosa
Agent Skills in .NET: Three Ways to Author, One Provider to Run Them
Sergey Menshykh
LLM Chat in .NET with IChatClient: The Complete Guide
NDepend Team
Validate .NET configuration on startup
David Grace
Suppressing Roslyn Analyzer Warnings Programmatically using DiagnosticSuppressor
Gérald Barré
C# String Comparison: Equals, OrdinalIgnoreCase, StringComparer, and Culture Pitfalls
Nick Cosentino
LINQ Max and nullable value types
Ian Griffiths
How to Implement Command Pattern in C#: Step-by-Step Guide
Nick Cosentino

ASP.NET Core / ASP.NET / Blazor

Build an AI Content Creation App in Blazor with AI AssistView
Arulraj Aboorvasamy
Purpose Limitation in API Design: Leaking Data You Shouldn't
Martin Stühmer

Azure / Cloud

"We Store Secrets in appsettings.json": A Horror Story in Five Acts
Martin Stühmer

Conceptos / Patrones / Buenas prácticas

Too much Discussion of the XOR swap trick
Chris Jefferson
Why “Clean Code” is Killing Your Velocity
Peter Ritchie
Clean Code to Clean Architecture: Refactoring Fat Controllers into Vertical Slices in ASP.NET Core
Sudhir Mangla
JSON5 – JSON for Humans
JSON5

Data

EF Core query translation: Why does some LINQ never become SQL?
Ali Hamza Ansari
Take your PostgreSQL-backed apps to the next level
Ismael Mejía
EF Core Migrations Best Practices
Peter Ritchie

Machine learning / IA

Introducing Claude Opus 4.7
Anthropic
Running AI agents with customized templates using docker sandbox
Andrew Lock

Web / HTML / CSS / Javascript

Seguridad en GitHub Pages con CSP
Gisela Torres
7 View Transitions Recipes to Try
Sunkanmi Fafowora
AI-Generated UI Is Inaccessible by Default
Durgesh Rajubhai Pawar
The Radio State Machine
Amit Sheen
font-family Doesn’t Fall Back the Way You Think – CSS Wizardry
Harry Roberts
Building a UI Without Breakpoints
Amit Sheen
A Well-Designed JavaScript Module System is Your First Architecture Decision
Amejimaobari Victor
What’s !important
Daniel Schwarz
The 10 Best Angular UI Libraries
Dany Paredes

Visual Studio / Complementos / Herramientas

Modo "fleet" en GitHub Copilot CLI: guía práctica para lanzar agentes en paralelo
José Manuel Alarcón
openscreen: Create stunning demos for free. Open-source, no subscriptions, no watermarks, and free for commercial use
Siddharth Vaddem
Stop Hunting Bugs: Meet the New Visual Studio Debugger Agent Workflow
Abhas Bhattacharya
Azure MCP tools now ship built into Visual Studio 2022 — no extension required
Yun Jung Choi
The Road to Visual Studio 2027
NDepend Team

.NET MAUI

MAUI Sherpa — Your Guide to .NET MAUI Development
Jonathan Dick
.NET MAUI ListView vs CollectionView: How Syncfusion ListView Performs Better
Anandh Ganesan
.NET MAUI State Management: From ViewModels to App Stores
Sri Radhesh Nag Subash Sankar
Building an Instagram-Style Like Animation in .NET MAUI
Leomaris Reyes

Otros

Why was there a red telephone at every receptionist desk?
Raymond Chen

Publicado en Variable not found.

Mejora el rendimiento de string.Format() usando CompositeFormat

2026-04-14T08:02:00.002+02:00

En .NET, todos hemos usado string.Format() cientos de veces. Se trata de una de esas herramientas que llevamos desde siempre en nuestro cinturón y usamos sin pensar demasiado en las implicaciones de rendimiento que puede tener su uso intensivo en escenarios críticos.

Sin embargo, cuando lo utilizamos en aplicaciones de alto rendimiento, en bucles con muchas iteraciones o en sistemas con limitaciones de recursos, es importante pararse un poco a pensar sobre cómo optimizar su uso.

En este artículo exploraremos cómo mejorar el rendimiento de string.Format() utilizando la clase CompositeFormat en .NET, que nos permite evitar el coste de analizar la cadena de formato cada vez que se llama al método.

El problema con `string.Format()`

Observemos un ejemplo típico de uso de string.Format():

for(var i = 0; i < 100_000; i++)
{
    var str = string.Format("Loop {0} started at {1}", i, DateTime.Now);
    Console.WriteLine(str);
}

Como podemos ver, en cada iteración del bucle se llama a string.Format() para obtener el mensaje que justo después es mostrado en la consola. El problema aquí es que cada llamada a string.Format() es independiente de las anteriores, lo que implica que, en cada vuelta, la cadena de formato "Loop {0} started at {1}" debe ser parseada para detectar los marcadores de posición, y luego reemplazarlos con los valores correspondientes.

De forma intuitiva, podemos ver claro que se trata de dos tareas diferentes: primero se analiza la cadena de formato y luego se realiza el reemplazo de valores. La segunda de ellas es inevitable, pero, ¿podríamos evitar la primera reutilizando el resultado del parseado de la cadena de formato entre las distintas llamadas?

Introducing `CompositeFormat`

La clase CompositeFormat, introducida en .NET 8, nos permite hacer precisamente eso. En lugar de llamar a string.Format() directamente, podemos crear una instancia de CompositeFormat con la cadena de formato parseada, y luego reutilizar esa instancia para formatear múltiples mensajes.

Aquí tenéis un ejemplo de cómo hacerlo:

var format = CompositeFormat.Parse("Loop {0} started at {1}");
for (int i = 0; i < 100_000; i++)
{
    var str = string.Format(null, format, i, DateTime.Now);
}

Como podéis ver, la cadena de formato se analiza una sola vez al crear la instancia de CompositeFormat, y luego se reutiliza en cada iteración del bucle. Esto reduce significativamente el coste de procesamiento, especialmente cuando el número de iteraciones es alto. Incluso podría mejorarse ligeramente si el objeto CompositeFormat se crea una única vez, como variable estática, y se reutiliza en todas las llamadas.

Si utilizamos BenchmarkDotNet para medir el rendimiento de estos enfoques, obtenemos los siguientes resultados:

BenchmarkDotNet v0.15.8, Windows 11 (10.0.26200.7462/25H2/2025Update/HudsonValley2)
Intel Core i9-9900K CPU 3.60GHz (Coffee Lake), 1 CPU, 16 logical and 8 physical cores
.NET SDK 10.0.101
  [Host]     : .NET 10.0.1 (10.0.1, 10.0.125.57005), X64 RyuJIT x86-64-v3
  DefaultJob : .NET 10.0.1 (10.0.1, 10.0.125.57005), X64 RyuJIT x86-64-v3

| Method                    | Mean     | Error    | StdDev   | Gen0      | Allocated |
|-------------------------- |---------:|---------:|---------:|----------:|----------:|
| UsingStandardStringFormat | 20.24 ms | 0.103 ms | 0.091 ms | 1812.5000 |   14.5 MB |
| UsingCompositeFormat | 17.97 ms | 0.096 ms | 0.089 ms | 1218.7500 |   9.92 MB |

El uso de la CPU se ha reducido en un 11,2%, y la cantidad de memoria asignada se redujo en un 31,6%, unos números nada despreciables.

Es importante tener en cuenta que el beneficio podría variar dependiendo de la complejidad de la cadena de formato. Por ejemplo, consideremos una cadena de formato más rebuscada como la siguiente, donde mostramos los mismos dos parámetros varias veces, pero con diferentes formatos:

ID:{0:D5} | Hex:0x{0:X8} | Padded:[{0,8}] | Num:{0:N0} | 
Time:{1:yyyy-MM-dd HH:mm:ss.fff} | Short:{1:dd/MM/yy} | ISO:{1:O}

Al ejecutar las mismas pruebas con esta cadena de formato más compleja, obtenemos los siguientes resultados:

| Method                    | Mean     | Error    | StdDev   | Gen0      | Allocated |
|-------------------------- |---------:|---------:|---------:|----------:|----------:|
| UsingStandardStringFormat | 59.31 ms | 0.292 ms | 0.259 ms | 4666.6667 |  38.06 MB |
| UsingCompositeFormat      | 47.32 ms | 0.300 ms | 0.281 ms | 3727.2727 |  30.44 MB |

En este caso, observamos una reducción del 20% en el uso de CPU, que demuestra que el proceso de parseado de la cadena es más costoso cuando no se reutiliza. El uso de la memoria usando CompositeFormat también mejora un 20% respecto a string.Format(), aunque en menor medida que antes debido a que el tamaño de las cadenas resultantes es mayor en ambos casos, y esto hace que la diferencia porcentualmente sea menor.

Punto extra: ¿por qué las cadenas interpoladas son mejores que ambas opciones?

Aunque CompositeFormat pueda parecer la panacea para mejorar el rendimiento de string.Format(), en realidad, las cadenas interpoladas ($"...") son una opción aún mejor en términos de rendimiento y legibilidad.

De hecho, en general, deberíamos utilizar cadenas interpoladas ($"...") en lugar de string.Format() o CompositeFormat siempre que sea posible. Las cadenas interpoladas son más legibles y se resuelven en tiempo de compilación, por lo que el compilador puede optimizarlas mejor y generar un código más eficiente. Podemos verlo en el siguiente benchmark comparativo:

| Method                  | Mean     | Error    | StdDev   | Gen0      | Allocated |
|------------------------ |---------:|---------:|---------:|----------:|----------:|
| StandardStringFormat    | 60.85 ms | 0.412 ms | 0.385 ms | 4666.6667 |  38.06 MB |
| UsingCompositeFormat    | 47.47 ms | 0.382 ms | 0.357 ms | 3727.2727 |  30.44 MB |
| UsingInterpolatedString | 37.34 ms | 0.236 ms | 0.197 ms | 3785.7143 |  30.44 MB |

Según los resultados, las cadenas interpoladas son un 38,7% más rápidas que string.Format() y un 21,3% más rápidas que CompositeFormat. Además, el uso de memoria es similar al de CompositeFormat, lo que las convierte en la opción preferida cuando la cadena de formato es conocida de antemano.

Para el resto de los casos, siempre y cuando el formateo de la cadena se encuentre en bucles o hot paths, CompositeFormat será la opción más eficiente. Pero ojo, ¡no hay que volverse locos con las micro-optimizaciones!

Publicado en: www.variablenotfound.com.

Enlaces interesantes 644

2026-04-13T08:01:00.002+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.

Por si te lo perdiste...

Cómo detectar y reaccionar a cambios en settings de ASP.NET Core, en tiempo real
José M. Aguilar
Ámbito local implícito en sentencias using de C#
José M. Aguilar

.NET

Tu App Necesita Workers Silenciosos: El Patrón que Usa Amazon para No Hacerte Esperar & * Background Jobs en .NET con IHostedService: Procesa Tareas en Segundo Plano
Gerson Azabache Martínez
Using LLMs and MCP in .NET
Ricardo Peres
Configuring contextual options with Microsoft.Extensions.Options.Contextual
Andrew Lock
How .NET handles exceptions internally (and why they're expensive)
Ali Hamza Ansari
URL Pattern Matching in .NET
Gérald Barré
How to build .NET obfuscator
Andrii Kurdiumov
Explore union types in C# 15
Bill Wagner
Convert Anything to Markdown in .NET — Meet ElBruno.MarkItDotNet
Bruno Capuano
Source code generated string enums with exhaustion support
Steven Giesel
What’s New in .NET 11 Preview 1 & 2: Runtime Async, Zstandard, Blazor TempData, and Vector Search
Arulraj Aboorvasamy
Libraries I Stopped Using in .NET (And I Don’t Regret It)
Miguel Teherán
ASP.NET Core: Why I Couldn’t Upgrade FluentValidation Past 11.4 in My Calzolari.Grpc.AspNetCore.Validation Package (and How I Finally Fixed It)
Anthony Giretti
Testing C# Source Generators: A Practical Guide
Nick Cosentino

ASP.NET Core / ASP.NET / Blazor

How to Load and Save Images in Blazor Image Editor with SQL Server
Satheeskumar S.
Instantiating Objects and Accessing Properties in Blazor
Héctor Pérez
ASP.NET Core 2.3 end of support announcement
Daniel Roth
Blazor Basics: Building Responsive Blazor Apps with CSS Media Queries
Claudio Bernasconi
Using Blazor Sections For Complex Situations
Mitchel Sellers
Mastering ASP.NET Core Rate Limiting: From Middleware to Distributed Redis Strategies
Sudhir Mangla

Azure / Cloud

Continued Investment in Azure App Service
Byron Tardif
Why Your Azure Portal Clicks Will Fail the Next Audit
Martin Stühmer
A simpler way to deploy your code to Azure App Service for Linux
Tulika Chaudharie
Agentic IIS Migration to Managed Instance on Azure App Service
Gaurav Seth

Conceptos / Patrones / Buenas prácticas

Tidying up your code
Fernando Escolar
DevOps para principiantes: ¿Qué significan Día 0, 1 y 2 y por qué el Día 2 puede durar cinco años?
José Manuel Alarcón
Code Organization and Maintainability: Factory Method Pattern Best Practices in C# & * Observer Pattern Best Practices in C#
Nick Cosentino
"Just Delete the User": Famous Last Words Before the GDPR Audit
Martin Stühmer
Floating point from scratch: Hard Mode
Julia Desmazes

Data

Un informático en el lado del mal: Un "Hardening Tip" de BBDD - de mi Lost & Found
Chema Alonso
Why your Entity Framework Core app needs query filters
David Grace
Mapping database views in EF Core without breaking migrations
Ali Hamza Ansari
EF Core transactions: Stop your data getting out of sync
David Grace
How to Delete and Update Millions of Rows in EF Core Without Loading a Single Entity
Chris Woodruff

Machine learning / IA

¿La IA genera deuda técnica? Causas, riesgos y cómo evitarlos
José Manuel Alarcón
La trampa del 70/30: El espejismo del rendimiento cognitivo en la era de la IA
Mario Cortés
Personas y agentes no colaboran. Compiten por el mismo cuello de botella
Alberto Díaz Martín
FrontierMath: Inteligencia Artificial resolviendo problemas de matemáticas aún no resueltos
Chema Alonso
AI Agents vs Skills (& Commands) in Claude Code, Codex, Copilot CLI & Gemini CLI: Stop Mixing Them Up
Juan Luis Guerrero
RAG vs Fine-Tuning: How to Choose the Right GPT Approach
Manikanda Akash Munisamy
Programming languages for AI
Mark Seemann
Context Engineering: Improving AI Code Output in Your IDE
Kaviya Priya Rajakumar
Migrating from Semantic Kernel to Microsoft Agent Framework in C#
Nick Cosentino
Claude Code Windows Migration Guide: Move Your Setup
Dirk Strauss
Best LLM APIs in 2026: Comparing OpenAI, Claude, Gemini, Azure, Bedrock, Mistral & DeepSeek
Arunachalam Kandasamy Raja
Introducing SQL MCP Server
Jerry Nixon

Web / HTML / CSS / Javascript

Form Automation Tips for Happier User and Clients
Iqra Naaem
The Drill-Down Menu with Details and @scope
Preethi Sam
What Is CSS Containment and How Can I Use It?
Harry Roberts
Email obfuscation: What works in 2026?
Spencer Mortensen
jQuery 4 - Reinventing Events
Ian Elliot
Making Complex CSS Shapes Using shape()
Temani Afif
What To Know in JavaScript (2026 Edition)
Chris Coyier
New CSS Multi-Column Layout Features in Chrome
Abhishek Pratap Singh
Let’s Get Puzzled!
Amit Sheen
You can't cancel a JavaScript promise (except sometimes you can)
Aaron Harper
How to Implement Cut, Copy, and Paste Support in React Spreadsheet
Parthasarathy Ranjan
Alternatives to the !important Keyword
Saleh Mubashar
Name-Only Containers: The Scoping We Needed
Chris Coyier
The 6 Big Ideas of Typescript • sitr.us
Jesse Hallett
Selecting a Date Range in CSS
Preethi
SVG Filters Guide: Getting Started with the Basics
Ana Tudor
How I Lost MadCSS
Chris Coyier

Visual Studio / Complementos / Herramientas

Cómo funciona launch.json en VS Code: configuraciones, compounds y arranques secuenciales
Gisela Torres
OpenCode | El agente de codificación IA de código abierto
OpenCode Team
JetBrains Air: The Future of Multi-Agent Coding, or Just More AI Noise?
Saeed Zarinfam
Visual Studio March Update - Build Your Own Custom Agents
Mark Downie
Bookmark Studio: evolving bookmarks in Visual Studio
Mads Kristensen
Your Migration's Source of Truth: The Modernization Assessment
Jeffrey Fritz
Running AI agents safely in a microVM using docker sandbox
Andrew Lock
How to Mock APIs Locally During Development
Quinton Wall

.NET MAUI

Tired of Multiple Viewers? Build a Universal Document Viewer in .NET MAUI
Deepak G.
Why .NET MAUI Popups Lag and How to Fix Performance Issues
Kompelli Sravan Kumar Kompelli Lakshman

Otros

Redefining the Software Engineering Profession for AI
Mark Russinovich & Scott Hanselman

Publicado en Variable not found.

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.