Interpolación constante en C# 10 y .NET 6 en 10 minutos o menos

Introducción

En este vídeo, Tim explica cómo las cadenas interpoladas -las que utilizan la conocida sintaxis del signo del dólar ($)- pueden utilizarse ahora en expresiones constantes, algo que antes no era posible. Este pequeño cambio hace que la construcción de cadenas constantes sea más fácil, limpia y fácil de mantener.

Explorando las constantes en .NET 6

Tim abre una aplicación de consola .NET 6 y elimina el código repetitivo para centrarse exclusivamente en las definiciones de constantes.

Comienza con la declaración de cadena constante más básica:

const string companyName = "Acme";

const string companyName = "Acme";

Se trata de una simple cadena literal asignada a una cadena const. Este tipo de constantes se evalúan en tiempo de compilación, lo que significa que sus valores son fijos y están integrados en el programa compilado.

Pero Tim pasa rápidamente a la cuestión central: ¿Qué pasa si queremos unir cadenas constantes o incrustar valores directamente dentro de otras cadenas mediante interpolación?

En C# 9 y versiones anteriores, esto no era posible:

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

Esta línea arrojaría un error de compilación, ya que la interpolación de cadenas no es compatible con expresiones constantes.

Cadenas interpoladas constantes en C# 10

Como demuestra Tim, en C# 10, el compilador admite ahora cadenas interpoladas constantes, siempre que todas las expresiones de interpolación sean constantes.

Así, el siguiente ejemplo funciona ahora perfectamente:

const string productName = $"{companyName} Anvils";

const string productName = $"{companyName} Anvils";

Se trata de una cadena interpolada constante, lo que significa que el compilador evalúa la cadena interpolada en tiempo de compilación en lugar de en tiempo de ejecución. Cuando se ejecuta el programa no se produce ninguna concatenación ni formateo adicional de cadenas: el compilador genera una única cadena constante literal como "Acme Anvils".

Tim explica que si cambiamos el valor de companyName de "Acme" a "ABC", el compilador genera automáticamente "ABC Anvils" para productName. Se trata de construcción de cadenas en tiempo de compilación, no de interpolación en tiempo de ejecución.

Esta mejora facilita enormemente la fusión de cadenas constantes sin recurrir a la concatenación + o a la repetición manual de valores.

Interpolación constante anidada

Tim va un paso más allá con otra definición constante:

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

Este es un ejemplo de interpolación anidada, en el que una cadena interpolada constante (productName) se utiliza dentro de otra.

El compilador trata todo esto como expresiones constantes, generando una única representación de cadena inmutable en tiempo de compilación.

Cuando Tim ejecuta el programa, el resultado es el siguiente:

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Esto confirma que la interpolación constante funciona sin problemas, incluso a través de múltiples constantes.

Por qué son importantes las constantes

En este punto, Tim hace una pausa para explicar por qué las constantes -y ahora las cadenas interpoladas constantes- son beneficiosas.

Señala que las constantes son extremadamente eficientes en memoria porque sus valores se almacenan directamente en el código compilado, no como instancias separadas en memoria.

En cambio, cuando antes los desarrolladores necesitaban algo similar, solían utilizar campos de sólo lectura:

readonly string companyName = "Acme";

readonly string companyName = "Acme";

Pero Tim señala que los campos de solo lectura no son lo mismo que los const: se evalúan en tiempo de ejecución, lo que consume más memoria e impide la optimización en tiempo de compilación.

Con las cadenas interpoladas constantes, ahora podemos escribir cadenas formateadas expresivas y reutilizables que siguen siendo constantes en tiempo de compilación, lo que mejora tanto la claridad como el rendimiento.

Ejemplo práctico - Uso de constantes en atributos

A continuación, Tim presenta un escenario real en el que esta nueva función brilla con luz propia: los atributos.

Define un método local simple dentro de Main():

void SayHi() { }

void SayHi() { }

A continuación, intenta aplicar el atributo [Obsolete] con un mensaje de cadena que hace referencia a una variable:

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

Esto falla porque los atributos sólo pueden aceptar expresiones constantes como parámetros. El compilador genera un error porque myCompany es una variable, no una constante.

Tim explica que el mensaje del atributo debe ser constante en tiempo de compilación, es decir, no puede depender de valores en tiempo de ejecución ni de variables de instancia.

Sin embargo, gracias a las cadenas interpoladas constantes en C# 10, ahora podemos hacerlo con seguridad:

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

Aquí, el compilador reconoce que tanto companyName como productName son constantes, por lo que toda la cadena interpolada es una expresión constante.

El compilador genera la cadena formateada en tiempo de compilación, haciéndola válida dentro del atributo.

Este ejemplo demuestra perfectamente por qué la interpolación constante no es solo azúcar sintáctico, sino que permite nuevas situaciones, como el uso de cadenas formateadas en tiempo de compilación directamente en atributos o metadatos.

Entre bastidores - Cómo se las arregla el compilador

Tim no entra en detalles internos del compilador en el vídeo, pero el concepto está estrechamente relacionado con el funcionamiento de los gestores de cadenas interpoladas en C# 10.

En general, cuando el compilador encuentra una cadena interpolada, crea código similar a una operación de formateo de cadenas, generando llamadas como AppendLiteral() y AppendFormatted() entre bastidores.

Pero cuando se trata de cadenas interpoladas constantes, el compilador evalúa todo en tiempo de compilación: no se emite ningún manejador de cadenas interpoladas ni ninguna llamada a métodos en el código IL generado.

Esto significa que el valor resultante se comporta exactamente igual que cualquier literal de cadena, pero se puede componer utilizando expresiones incrustadas de otras constantes.

Se trata de un elegante equilibrio entre expresividad y eficiencia: el compilador gestiona la construcción de cadenas de forma estática, lo que garantiza un coste cero en tiempo de ejecución.

Cuándo usar cadenas interpoladas constantes

Tim reconoce que no todo el mundo utilizará esta función a diario. Es posible que los desarrolladores que rara vez definen constantes o escriben atributos no se beneficien inmediatamente.

Sin embargo, para quienes crean muchas definiciones en tiempo de compilación, mensajes constantes o metadatos de atributos, esta función simplifica el código y evita el desorden de la concatenación de cadenas.

También es más seguro: como las constantes son inmutables y las comprueba el compilador, se eliminan los errores derivados de cadenas concatenadas dinámicamente o variables mal gestionadas.

Esto hace que su código sea más robusto, legible y fácil de mantener.

Conclusión

Al final de su vídeo, Tim invita a los desarrolladores a reflexionar sobre si utilizarán cadenas interpoladas constantes en sus proyectos. Algunos las consideran esenciales para obtener cadenas formateadas más limpias en tiempo de compilación, mientras que otros las ven como una comodidad menor.

En cualquier caso, la demostración de Tim muestra exactamente cómo implementar y dónde aplicar esta función con eficacia.

En resumen:

• Las cadenas interpoladas constantes permiten expresiones de interpolación dentro de constantes.

• Se evalúan en tiempo de compilación, produciendo literales de cadena eficientes.

• Sustituyen la concatenación repetitiva de cadenas por una sintaxis más limpia.

• Son especialmente útiles en atributos, configuración basada en constantes y mensajes de metadatos.

Al combinar la legibilidad con la seguridad en tiempo de compilación, la interpolación constante de C# 10 es un paso más hacia la programación expresiva y eficiente en C#, como demuestra claramente el ejemplo de Tim Corey.