Interpolação de constantes em C# 10 e .NET 6 em 10 minutos ou menos

Tim Corey

6m 14s

A cada nova versão, o C# continua a evoluir em poder e elegância, oferecendo aos desenvolvedores maneiras mais limpas e eficientes de escrever código. Uma dessas adições introduzidas no C# 10 são as strings interpoladas constantes — um recurso que permite aos desenvolvedores usar a interpolação de strings dentro de constantes.

Antes dessa funcionalidade, se você tentasse criar uma string constante usando interpolação (por exemplo, $"{companyName} Produtos"), o compilador geraria um erro. Você só podia atribuir literais de string simples a valores constantes, o que frequentemente levava a um código repetitivo ou desajeitado ao construir mensagens constantes ou strings de atributos.

Agora, com C# 10 e .NET 6 em diante, você pode combinar constantes usando strings interpoladas diretamente em tempo de compilação. Essa melhoria não só torna seu código mais limpo, como também o mantém eficiente, já que todos os valores são avaliados antes da execução do programa.

Para entender melhor como isso funciona, Tim Corey, em seu vídeo " Interpolação Constante em C# 10 e .NET 6 em 10 Minutos ou Menos ", explica o conceito passo a passo. Em seu estilo conciso e prático de sempre, Tim explica o que esse novo recurso faz, como ele difere da concatenação de strings tradicional e onde ele pode ser especialmente útil — particularmente em atributos.

Vamos então analisar a explicação de Tim para ver exatamente como funcionam as strings interpoladas constantes em C# e por que elas são um recurso útil para desenvolvedores.

Introdução

Neste vídeo, Tim explica como strings interpoladas — aquelas que usam a sintaxe familiar do cifrão ($) — agora podem ser usadas em expressões constantes, algo que não era possível antes. Essa pequena alteração torna a construção de cordas constantes mais fácil, limpa e de menor manutenção.

Explorando constantes no .NET 6

Tim abre um aplicativo de console .NET 6 e remove o código repetitivo para se concentrar exclusivamente nas definições de constantes.

Ele começa com a declaração de string constante mais básica:

const string companyName = "Acme";

const string companyName = "Acme";

Const companyName As String = "Acme"

Const companyName As String = "Acme"

Esta é uma string literal simples atribuída a uma string constante. Constantes como essa são avaliadas em tempo de compilação, o que significa que seus valores são fixos e incorporados ao programa compilado.

Mas Tim rapidamente aborda a questão central: e se quisermos mesclar strings constantes ou incorporar valores diretamente dentro de outras strings usando interpolação?

Em C# 9 e versões anteriores, você não podia fazer isso:

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

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

Const productName As String = $"{companyName} Anvils" ' Not allowed before VB 16.0

Const productName As String = $"{companyName} Anvils" ' Not allowed before VB 16.0

Essa linha geraria um erro de compilação, já que a interpolação de strings não era suportada para expressões constantes.

Strings Interpoladas Constantes no C# 10

Como Tim demonstra, no C# 10, o compilador agora suporta strings interpoladas constantes — desde que todas as expressões de interpolação internas sejam constantes.

Assim, o exemplo a seguir agora funciona perfeitamente:

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

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

Const productName As String = $"{companyName} Anvils"

Const productName As String = $"{companyName} Anvils"

Esta é uma string interpolada constante, o que significa que o compilador avalia a string interpolada em tempo de compilação, em vez de em tempo de execução. Nenhuma concatenação ou formatação de string adicional ocorre quando o programa é executado — o compilador gera uma única string literal constante como "Acme Anvils".

Tim explica que, se alterarmos o valor de companyName de "Acme" para "ABC", o compilador gera automaticamente "ABC Anvils" para productName. Trata-se de construção de strings em tempo de compilação, não de interpolação em tempo de execução.

Essa melhoria torna muito mais fácil mesclar strings constantes sem recorrer à concatenação com o operador + ou à repetição manual de valores.

Interpolação de constantes aninhadas

Tim vai um passo além com outra definição de 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.";

Const productDescription As String = $"{productName} are the best way to crush unsuspecting roadrunners."

Const productDescription As String = $"{productName} are the best way to crush unsuspecting roadrunners."

Este é um exemplo de interpolação aninhada, onde uma string interpolada constante (productName) é usada dentro de outra.

O compilador trata todas essas expressões como constantes, gerando uma única representação em string imutável em tempo de compilação.

Quando Tim executa o programa, a saída é a seguinte:

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

Isso confirma que a interpolação constante funciona perfeitamente, mesmo com várias constantes.

Por que as constantes são importantes

Nesse ponto, Tim faz uma pausa para explicar por que as constantes — e agora as strings interpoladas constantes — são benéficas.

Ele destaca que as constantes são extremamente eficientes em termos de memória, pois seus valores são armazenados diretamente no código compilado, e não como instâncias separadas na memória.

Em contrapartida, quando os desenvolvedores precisavam de algo semelhante anteriormente, eles frequentemente utilizavam campos somente leitura:

readonly string companyName = "Acme";

readonly string companyName = "Acme";

ReadOnly companyName As String = "Acme"

ReadOnly companyName As String = "Acme"

Mas Tim observa que os campos somente leitura não são iguais aos campos constantes — eles são avaliados em tempo de execução, o que consome mais memória e impede a otimização em tempo de compilação.

Com strings interpoladas constantes, agora podemos escrever strings formatadas expressivas e reutilizáveis ​​que permanecem constantes em tempo de compilação, melhorando tanto a clareza quanto o desempenho.

Exemplo prático — Usando constantes em atributos

Tim então apresenta um cenário do mundo real onde esse novo recurso se destaca — os atributos.

Ele define um método local simples dentro de Main():

void SayHi() { }

void SayHi() { }

Sub SayHi()
End Sub

Sub SayHi()
End Sub

Em seguida, ele tenta aplicar o atributo [Obsolete] com uma mensagem de texto que faz referência a uma variável:

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}")]

Dim myCompany As String = "Tim's Company"
<Obsolete($"This is no longer used for {myCompany}")>

Dim myCompany As String = "Tim's Company"
<Obsolete($"This is no longer used for {myCompany}")>

Isso falha porque os atributos só podem aceitar expressões constantes como parâmetros. O compilador gera um erro porque myCompany é uma variável, não uma constante.

Tim explica que a mensagem do atributo precisa ser uma constante em tempo de compilação — ela não pode depender de valores em tempo de execução ou variáveis ​​de instância.

No entanto, graças às strings interpoladas constantes no C# 10, agora podemos fazer isso com segurança:

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}")]

Const productName As String = $"{companyName} Anvils"
<Obsolete($"This is no longer used for {productName}")>

Const productName As String = $"{companyName} Anvils"
<Obsolete($"This is no longer used for {productName}")>

Neste caso, o compilador reconhece que tanto companyName quanto productName são constantes, portanto, toda a string interpolada é uma expressão constante.

O compilador gera a string formatada em tempo de compilação, tornando-a válida dentro do atributo.

Este exemplo destaca perfeitamente por que a interpolação constante não é apenas um recurso sintático — ela possibilita novos cenários, como o uso de strings formatadas em tempo de compilação diretamente em atributos ou metadados.

Nos bastidores — como o compilador lida com isso

No vídeo, Tim não entra em detalhes internos de baixo nível do compilador, mas o conceito está intimamente ligado ao funcionamento dos manipuladores de strings interpoladas no C# 10.

Em geral, quando o compilador encontra uma string interpolada, ele cria um código semelhante a uma operação de formatação de string, gerando chamadas como AppendLiteral() e AppendFormatted() nos bastidores.

Mas, ao lidar com strings interpoladas constantes, o compilador avalia tudo em tempo de compilação — nenhum manipulador de string interpolada ou chamada de método é emitido no código IL gerado.

Isso significa que o valor resultante se comporta exatamente como qualquer literal de string, mas você ainda pode compô-lo usando expressões incorporadas de outras constantes.

É um equilíbrio elegante entre expressividade e eficiência — o compilador lida com a construção da string estaticamente, garantindo custo zero em tempo de execução.

Quando usar strings interpoladas constantes

Tim reconhece que nem todos usarão esse recurso diariamente. Os desenvolvedores que raramente definem constantes ou escrevem atributos podem não se beneficiar imediatamente.

No entanto, para quem cria muitas definições em tempo de compilação, mensagens constantes ou metadados de atributos, esse recurso simplifica o código e evita a complexidade da concatenação de strings.

Também é mais seguro, pois as constantes são imutáveis ​​e verificadas pelo compilador, eliminando erros provenientes de strings concatenadas dinamicamente ou variáveis ​​mal gerenciadas.

Isso torna seu código mais robusto, legível e fácil de manter.

Conclusão

Ao concluir seu vídeo , Tim convida os desenvolvedores a refletirem sobre se usarão strings interpoladas constantes em seus projetos. Algumas pessoas podem considerá-las essenciais para obter strings formatadas de maneira mais limpa em tempo de compilação, enquanto outras podem vê-las como uma pequena conveniência.

De qualquer forma, a demonstração de Tim mostra exatamente como implementar e onde aplicar esse recurso de forma eficaz.

Resumindo:

• Cadeias interpoladas constantes permitem expressões de interpolação dentro de constantes.

• Elas são avaliadas em tempo de compilação, produzindo literais de string eficientes.

• Elas substituem a concatenação repetitiva de strings por uma sintaxe mais limpa.

• São particularmente úteis em atributos, configurações baseadas em constantes e mensagens de metadados.

Ao combinar legibilidade com segurança em tempo de compilação, a interpolação de constantes do C# 10 é mais um passo em direção a uma programação C# expressiva e eficiente — como o exemplo de Tim Corey demonstra claramente.