En general, el uso de expresiones largas debería estar prohibido por ley. Hay pocas cosas que ataquen tanto a la legibilidad de un código como una expresión larga y compleja a la que tengamos que dedicar un buen rato cada vez que intentemos comprenderla. Y no digamos si nos toca modificarla 😱

Aunque esto es aplicable a cualquier tipo de expresión, en este post me voy a centrar en los predicados, que al fin y al cabo representan las condiciones que determinan el comportamiento de una aplicación.

Veamos un ejemplo de if con un predicado que implementa una condición de negocio necesaria para que un usuario user pueda realizar una tarea concreta en la cuenta account:

if (account is not null && account.IsActive && account.HasSubscription 
    && account.SubscriptionStartDate <= DateTime.Today && account.SubscriptionEndDate 
    >= DateTime.Now.AddDays(1) && (account.SubscriptionLevel == "Standard" || 
    account.SubscriptionLevel == "Premium") && user.IsActive && (user.HasRole("admin") 
    || (user.HasRole("owner"))) && user.AccountId == account.Id)
{
    account.ChangePaymentMethod("paypal");
}

Es un poco difícil de leer, ¿verdad? 😅 Bueno, está algo forzado para ilustrar bien el ejemplo, pero seguro que en nuestras bases de código podríamos reconocer fragmentos conceptualmente similares.

Básicamente, la condición anterior verifica si el estado de la cuenta account es válido para realizar la tarea, comprobando que sea correcta, esté activa, y tenga en vigor una suscripción de nivel "Standard" o "Premium", así como que el usuario user tenga permisos para hacerlo, comprobando que esté activo, tenga un rol de "admin" u "owner", y pertenezca a la cuenta account.

Obviamente, no podemos evitar que la lógica de negocio sea compleja, eso no depende de nosotros. Pero sí podemos hacer que la forma de expresarla mediante código sea más sencilla y legible, así que, ¡manos a la obra!

Aquí está la recopilación semanal número 593 de enlaces interesantes, donde podéis encontrar un montón de referencias a artículos sobre C#, .NET, ASP.NET, Azure, desarrollo web, inteligencia artificial, Visual Studio y otros temas 🙂

Destacable el post "Tendencias en programación JavaScript para 2025", de José Manuel Alarcón, donde desvela hacia dónde se dirige el desarrollo JavaScript este año recién estrenado, en términos de herramientas, frameworks, metaframeworks, programación en backend y los nuevos paradigmas impulsados por la irrupción de la inteligencia artificial. Si usáis este lenguaje y su ecosistema, no os lo perdáis.

Los que diseñáis sistemas distribuidos con ASP.NET Core, os puede venir bien echar un vistazo a la introducción de Ricardo Peres a la implementación de trazas distribuidas en ASP.NET Core.

El artículo de Mark Heath sobre el uso de tools de forma segura con LLMs, Using Tools (Safely) with LLMs, me ha sido útil para descubrir que las bibliotecas cliente de Azure OpenAI también tienen la capacidad de ejecutar herramientas, algo que pensaba que había que hacer manualmente o con frameworks más potentes como Semantic Kernel.

Y muy bueno el recopilatorio del equipo de Visual Studio sobre novedades destacables que se introdujeron en el producto durante 2024. Si usáis a diario esta herramienta, echadle un ojo porque hay cosas muy interesantes.

Espero que os sean de utilidad 🙂

Por si te lo perdiste...

• Comprimir el resultado de acciones específicas en ASP.NET Core MVC
  José M. Aguilar
• Non-nullable property must contain a non-null value when exiting constructor: 7 formas de evitar el warning CS8618 en C#
  José M. Aguilar

.NET Core / .NET

• The memory leak in ConcurrentQueue
  Oren Eini
• Measuring the impact of locks and waits on latency in your .NET apps
  Christophe Nasarre
• Stop the Leaks: Properly Disposing Objects in .NET
  David McCarter
• C# foreach: Definition and Best Practices
  Stackify Team
• Reading compilation options and the C# version in source generators
  Andrew Lock
• Local inter-process communication over named pipes with ASP.NET Core or StreamJsonRpc in .NET
  Anthony Simmon
• Comparing Records, Structs, and Classes in C#: When to Use What?
  Ali Hamza Ansari
• Enhance Your .NET HttpClient with HSTS Support
  Gérald Barré
• Introducing MSBuild.Sdk.SqlProj 3.0 - create, build, validate, analyze, pack and deploy SQL database projects with .NET 9
  Erik Ejlskov Jensen
• Mastering C# - Pattern Matching
  Jesse Liberty
• The Transition of .NET FluentAssertions to Paid Software
  Tomasz Sobczak
• C# Enum: Definition and Best Practices
  Stackify Team
• Working with JsonSerializerContext in System.Text.Json and Refit
  Tomasz Cielecki

Tras el parón navideño, volvemos a la carga con la primera recopilación de 2025 🙂

Bueno, la frase anterior no es del todo cierta. Por una parte, aunque haya dejado de publicar durante un par de semanas, no he dejado de recopilar enlaces, así que esta edición es especialmente extensa: más de 90 enlaces. Y por otra parte, en realidad sería la segunda recopilación, si contamos la revisión de los contenidos más vistos del blog durante el pasado año que publiqué ayer 😊

Pero bueno, al tema...

Es difícil destacar algo en concreto ante tanto contenido, pero quizás me quedo con el post "The Myth of Perfect Code: Why It’s Hurting You More Than Helping", donde Terrance Craddock reflexiona sobre lo que deberíamos considerar "código perfecto".

También me voy a quedar con algo que, por diferente, me ha llamado la atención: "Unique Solving Method for Rubik's Cube", un método para resolver el cubo de Rubik presentado de forma muy visual. Si sois de los que en los 80 pasasteis horas intentando resolverlo, seguro que como mínimo os resultará curioso 🙂

Por si te lo perdiste...

• Este código C# no compila. ¿Cómo lo hacemos funcionar sin tocarlo?
  José M. Aguilar
• Crear desplegables desde enums en ASP.NET Core MVC
  José M. Aguilar

.NET Core / .NET

• Critical: .NET Install links are changing
  Richard Lander
• Scheduling Background Jobs With Quartz in .NET (advanced concepts)
  Milan Jovanović
• Fast build and high security in .NET with Package Source Mapping
  Tomasz Sobczak
• Back to Basics: Using the Parallel Library to Massively Boost Loop Performance
  Rick Strahl
• Logging in .NET: Best Practices and Why You Should Love It
  Marius Schröder
• 10 Reasons to Upgrade to .NET 9
  Anton Martyniuk
• Vogen: turn your primitives (ints, decimals etc.) into value objects that represent domain concepts
  Steve Dunn
• StackOverflowException vs. OutOfMemoryException
  Sergey Teplyakov
• Static Lambda in C# 12 : Performance Improvement
  Devesh Omar
• C# Null-Conditional (?.) & Null-Coalescing (??) Operators Explained
  Ivan Kahl
• Automatically format your dotnet code using dotnet format
  Josef Ottosson
• Think Beyond Synchronous: The Ultimate Guide to Tasks in C#
  Chris Woodruff
• Moq Unit Testing in .NET Core with xUnit
  Jaimin Shethiya
• Implementing an interceptor with a source generator
  Andrew Lock
• Writing a String Numeric Comparer with .NET 9
  Khalid Abuhakmeh
• .NET 9 upgrade - notnull constraint
  Bart Wullems
• Exploring CollectionsMarshal for Dictionary
  Gérald Barré
• C# 12.0: collection expressions
  Ian Griffiths
• Writing a .NET profiler in C#
  Kevin Gosse
• Modern C# Part 3 – Switch Expressions
  Jesse Liberty

Pues sí, se acabaron las fiestas y aquí estamos de nuevo, volviendo a la rutina. Con el 2025 recién estrenado, ante todo, me gustaría aprovechar la ocasión para desearos que sea un gran año en todos los sentidos🙂

Y para empezar con buen pie, vamos a seguir la tradición de aprovechar este primer post para hacer un breve recopilatorio de los artículos más leídos el año anterior, con idea de que podáis descubrir contenidos que quizás os habíais perdido, reencontraros con algo que os interesó en su momento, o simplemente ver qué contenidos están llamando más la atención al resto de lectores del blog.

Top 10 posts 2024 en Variable Not Found

En décimo lugar, inaugurando el top ten de 2024 tenemos una llamada de atención: el artículo "¡No uses ContainsKey() en un diccionario .NET para ver si existe un elemento antes de obtenerlo!" muestra el impacto en el rendimiento de la doble búsqueda (una para ver si existe el elemento y otra para obtenerlo) y cómo podemos solucionarlo fácilmente con las herramientas que proporciona el propio framework.

Seguidamente, en el noveno puesto de la lista, respondemos a una pregunta bastante habitual cuando empezamos con ASP.NET Core: ¿por qué mi aplicación no arranca? En el artículo "No se puede conectar al servidor web 'https', el servidor web ya no funciona y otras pistas de que no has lanzado correctamente tu aplicación ASP.NET Core", además de la respuesta, veremos otros síntomas que nos pueden ayudar a identificar el problema. Spoiler: has olvidado incluir el app.Run() al final del código de inicialización 😉

Aquí van los enlaces recopilados durante la semana pasada, en lo que será ya la última entrega del año. Volveremos a las tareas de recolección la primera semana de enero, semana arriba o semana abajo  (¡soy malo para esto de las estimaciones!😉).

Esta edición incluye enlaces a casi 50 contenidos que me han llamado la atención, aunque me gustaría resaltar especialmente algunos de ellos.

En primer lugar un gran repaso de CampusMVP a los CWE Top 25 de 2024 o, en otras palabras, a los principales agujeros de seguridad que dejamos por detrás los desarrolladores al crear nuestras aplicaciones. Algunos de ellos seguro que los conoces ya, como inyección SQL o XSS, pero hay muchas más perversidades que debemos conocer y evitar. 

Muy interesante, como siempre, los resultados publicados por JetBrains sobre el estado del ecosistema de desarrolladores del año que está a punto de terminar, obtenidos de una encuesta a más de 23.000 developers de todo el mundo. Aquí encontraréis información valiosa sobre los proyectos en los que más trabajamos, qué lenguajes son los más utilizados en distintas áreas, qué herramientas son las preferidas, o si seguimos pensando que la IA nos va a quitar el trabajo a todos los desarrolladores antes de acabar totalmente con la humanidad, o si en cambio es una gran aliada 😉

Por último, también me parece destacable los anuncios que Microsoft ha dejado caer hace unos días: la disponibilidad de un nuevo plan gratuito de GitHub Copilot para los usuarios de Visual Studio y Visual Studio Code. Bueno, obviamente tiene sus limitaciones, pero es un buen punto de partida para los que aún no habéis podido probarlo o no tenéis acceso a licencias superiores.

Por último, aprovecho también para desearos a todos unas muy felices fiestas. Disfrutad de la mejor compañía posible y pasadlo bien, pero eso sí, sin excesos, que luego vienen los arrepentimientos... 😉

Por si te lo perdiste...

• Serialización polimórfica con System.Text.Json
  José M. Aguilar
• Cómo saber si un nivel de traza está activo en aplicaciones ASP.NET Core/MVC
  José M. Aguilar

.NET Core / .NET

• .NET Framework Migration to .NET 9
  Derek Comartin
• Some news about .NET 10: BackgroundServices and new String Comparer
  Steven Giesel
• Deep C# - The Perils of the C# Parallel For
  Mike James
• How and why to write mutation tests in C#
  Daniel Ward
• Special properties in .NET projects
  Alexandre H. T. R.
• Deserializing JSON to a string or a value
  Phil Haack
• Functional Programming With C# - Make Dictionaries Functional!
  Simon Painter
• C# 13 and .NET 9: Personal Highlights
  Dmytro Misik

A principios de siglo, con un C# aún bastante primitivo, las propiedades que almacenaban datos en una clase teníamos que definirlas siempre usando un backing field, es decir, un campo privado que almacenaba el valor, y accediendo a él mediante métodos getter y setter. Es decir, algo así:

public class Customer
{
    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
    ...
}

Esto cambió en 2007 con la llegada de las propiedades automáticas, una maravilla para nuestros cansados dedos, que desde entonces usamos en la mayoría de ocasiones. Gracias a ellas, podemos definir una propiedad sin tener que implementar sus métodos accesores ni su campo privado correspondiente, porque el compilador se encargaba de crearlos por nosotros. De esta forma, código anterior quedaba así:

public class Customer
{
    public string Name { get; set; }
    ...
}

En realidad, se trataba sólo de un azucarillo sintáctico. Por detrás, el compilador está generando el campo privado y transformando nuestro código para utilizarlo; de hecho, el código generado de la clase anterior es algo así (algo simplificado para que se pueda leer mejor):

public class Customer
{
    private string <Name>k__BackingField;

    public string Name
    {
        get { return <Name>k__BackingField; }
        set { <Name>k__BackingField = value; }
    }
}

Aunque obviamente usar propiedades automáticas es mucho más cómodo que la opción anterior, tiene un inconveniente: no tenemos forma de acceder al campo generado por el compilador, algo que puede resultar interesante si nos interesa realizar algún tipo de validación o lógica adicional en el getter o setter más allá de simplemente devolver o asignar el valor.

Por ejemplo, imaginemos que queremos que el nombre de nuestro cliente siempre esté en mayúsculas. Con una propiedad automática, simplemente no podemos hacerlo, y tendremos que recurrir a las verbosas propiedades tradicionales con backing fields.

Y aquí es donde entran en escena las propiedades semiautomáticas...