Dica C#: Interpolated String Handlers

Hoje, vamos simplificar o uso de Interpolated String Handlers, uma funcionalidade do C# 12 que permite controlar como strings interpoladas são construídas, de forma otimizada e condicional. Veja o exemplo no código abaixo.

using System;
using System.Runtime.CompilerServices;

public class Program
{
    public static void Main()
    {
        var nomeProduto = "Caneta";

        // Tentativa de logar uma mensagem curta
        LogMessage($"Produto: {nomeProduto}");

        // Tentativa de logar uma mensagem que resultará em mais de 10 caracteres
        LogMessage($"O nome do produto é {nomeProduto}");

        Console.ReadKey();
    }

    public static void LogMessage(MaxLengthLogHandler handler)
    {
        if (handler.IsEnabled)
        {
            Console.WriteLine(handler.GetContent());
        }
    }
}

[InterpolatedStringHandler]
public ref struct MaxLengthLogHandler
{
    private readonly bool _isEnabled;
    private string _message;

    public bool IsEnabled => _isEnabled;

    public MaxLengthLogHandler(int literalLength, int formattedCount)
    {
        // Permite logar apenas se a mensagem resultante tiver 10 caracteres ou menos
        _isEnabled = literalLength <= 10;
        _message = string.Empty;
    }

    // Você poderia manipular os literais aqui
    // Literal é o texto: "Produto: " ou "O nome do produto é "
    public void AppendLiteral(string literal) => _message += literal;

    // Você poderia manipular os valores formatados aqui
    // Valor formatado é o valor da variável: nomeProduto
    public void AppendFormatted<T>(T valor) => _message += valor?.ToString();

    public string GetContent() => _message.Length <= 15 ? _message : string.Empty;
}

Explicação:
Os Interpolated String Handlers permitem que você decida se uma string interpolada deve ser construída ou não, dependendo de condições específicas.
Neste exemplo, a mensagem de log só será construída e exibida se a string resultante tiver 15 caracteres ou menos, considerando o conteúdo interpolado (que é validado no handler). Isso ajuda a evitar a criação de strings muito longas e desnecessárias, economizando recursos e melhorando a performance.

Importante:
Um manipulador de strings interpoladas é um tipo que deve ter as seguintes características:
• O atributo System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute aplicado ao tipo.
• Um construtor que tenha dois parâmetros int, literalLength e formattedCount. (Mais parâmetros são permitidos).
• Um método público AppendLiteral com a assinatura: public void AppendLiteral(string s). Nesse método, você pode manipular o conteúdo literal.
• Um método genérico público AppendFormatted com a assinatura: public void AppendFormatted(T t). Nesse método, você pode manipular o conteúdo enviado de forma interpolada (exemplo, os que são enviados através de váriaveis dentro das chaves {}).

Código fonte: GitHub

Espero que essa dica ajude você a entender como usar Interpolated String Handlers para construir strings de forma eficiente! Até a próxima.