Interpolación de strings y String.Format en C#: especificadores de formato, alineación y cultura

La interpolación de strings construye un string a partir de texto literal y expresiones. Pon el prefijo $ al literal, escribe cualquier expresión de C# entre llaves, y su valor se convierte a texto y se inserta:

using System;

class Program
{
    static void Main()
    {
        string customer = "Maya";
        int items = 3;
        decimal price = 4.5m;

        Console.WriteLine($"Hello, {customer}!");
        Console.WriteLine($"{items} items at {price} = {items * price}");
        Console.WriteLine($"Name has {customer.Length} letters, upper: {customer.ToUpper()}");
        Console.WriteLine($"Free shipping: {(items * price > 10 ? "yes" : "no")}");
    }
}

Salida:

Hello, Maya!
3 items at 4.5 = 13.5
Name has 4 letters, upper: MAYA
Free shipping: yes

La interpolación llegó en C# 6. El compilador la convierte en una llamada a string.Format o string.Concat (o, desde C# 10, en código de handlers más eficiente), así que no es más lenta que construir el string a mano.

La expresión condicional de la última línea necesita paréntesis. Dentro de un hueco de interpolación, los dos puntos inician un especificador de formato, así que {x > 10 ? "yes" : "no"} sin paréntesis es un error de compilación.

Especificadores de formato

Después de la expresión, unos dos puntos y un string de formato controlan cómo se escribe el valor. Los mismos strings de formato funcionan con ToString("...") y con string.Format.

using System;

class Program
{
    static void Main()
    {
        decimal total = 1234567.891m;
        int orderId = 42;
        double ratio = 0.8127;

        Console.WriteLine($"{total:F2}");     // fixed-point, 2 decimals
        Console.WriteLine($"{total:N2}");     // with thousands separators
        Console.WriteLine($"{total:N0}");     // no decimals, rounded
        Console.WriteLine($"{orderId:D5}");   // integer padded to 5 digits
        Console.WriteLine($"{255:X}");        // hexadecimal
        Console.WriteLine($"{255:x4}");       // lowercase hex, 4 digits
        Console.WriteLine($"{total:E2}");     // scientific
        Console.WriteLine($"{ratio:F3}");
        Console.WriteLine($"{ratio:0.0%}");   // custom: percent with 1 decimal
        Console.WriteLine($"{total:#,##0.00}"); // custom pattern
        Console.WriteLine($"{7.5:000.0}");    // leading zeros
        Console.WriteLine($"{3.10m:0.##}");   // drop trailing zeros
    }
}

Salida:

1234567.89
1,234,567.89
1,234,568
00042
FF
00ff
1.23E+006
0.813
81.3%
1,234,567.89
007.5
3.1

Los códigos estándar, cada uno seguido opcionalmente de un número de precisión:

Los patrones propios construyen un formato a partir de marcadores: 0 es un dígito que siempre se muestra, # es un dígito que solo se muestra si es significativo, . es el punto decimal, , dentro del número activa los separadores de grupo y % multiplica por 100. "0.##" muestra hasta dos decimales y quita los ceros finales; "#,##0.00" es el formato contable clásico.

Todo el formato numérico redondea el valor mostrado; la variable en sí no cambia. Cuando un valor está justo a medio camino (2,25 mostrado con un decimal), distintos runtimes y tipos pueden redondear el empate de forma distinta, así que si la regla importa, redondea antes de forma explícita con Math.Round(value, 1, MidpointRounding.AwayFromZero) y después da formato.

Fechas en la interpolación

Los valores DateTime aceptan strings de formato de fecha de la misma forma:

using System;

class Program
{
    static void Main()
    {
        var shipped = new DateTime(2026, 9, 24, 16, 5, 0);

        Console.WriteLine($"{shipped:yyyy-MM-dd}");
        Console.WriteLine($"{shipped:dd/MM/yyyy HH:mm}");
        Console.WriteLine($"{shipped:ddd, MMM d}");
        Console.WriteLine($"Shipped at {shipped:HH:mm} on {shipped:dddd}");

        TimeSpan eta = TimeSpan.FromMinutes(130);
        Console.WriteLine($"ETA {eta:hh\\:mm}");
        Console.WriteLine($"{eta.TotalHours:F1} hours");
    }
}

Salida:

2026-09-24
24/09/2026 16:05
Thu, Sep 24
Shipped at 16:05 on Thursday
ETA 02:10
2.2 hours

Un formato propio de TimeSpan exige escapar los caracteres literales con una barra invertida, que en un literal de string normal se escribe \\:. La lista completa de códigos de fecha (yyyy, MM, HH, tt...) y los errores que se cometen con ellos (mm son minutos, MM son meses) están en formato de DateTime.

Alineación y relleno

Una coma después de la expresión fija un ancho mínimo de campo. Un número positivo alinea a la derecha y uno negativo a la izquierda. Combinado con un formato, alinea tablas en texto plano:

using System;

class Program
{
    static void Main()
    {
        var names = new[] { "Espresso", "Latte", "Hot chocolate" };
        var prices = new[] { 2.4m, 3.6m, 4.25m };
        var sold = new[] { 118, 64, 9 };

        Console.WriteLine($"{"Item",-14}|{"Price",7}|{"Sold",5}");
        Console.WriteLine(new string('-', 28));
        for (int i = 0; i < names.Length; i++)
        {
            Console.WriteLine($"{names[i],-14}|{prices[i],7:F2}|{sold[i],5}");
        }
    }
}

Salida:

Item          |  Price| Sold
----------------------------
Espresso      |   2.40|  118
Latte         |   3.60|   64
Hot chocolate |   4.25|    9

La sintaxis es {expression,alignment:format}: primero la alineación, después el formato. Un valor más largo que el ancho no se recorta; empuja el resto de la línea. PadLeft y PadRight hacen el mismo relleno fuera de la interpolación.

Escapar las llaves

Para imprimir una llave literal, duplícala: {{ y }}. Esto aparece cuando la salida es JSON, CSS o código:

using System;

class Program
{
    static void Main()
    {
        int id = 42;
        string name = "Ana";

        Console.WriteLine($"{{ \"id\": {id}, \"name\": \"{name}\" }}");
        Console.WriteLine($"Set literal: {{1, 2, 3}}");
        Console.WriteLine($"{{{id}}}");   // a value wrapped in braces
    }
}

Salida:

{ "id": 42, "name": "Ana" }
Set literal: {1, 2, 3}
{42}

Construir JSON a mano así vale para una línea de log rápida; para JSON de verdad usa un serializador, que maneja correctamente las comillas y los caracteres especiales dentro de name.

string.Format y el formato compuesto

Antes de C# 6, el formato se hacía con string.Format, que recibe marcadores numerados y una lista de argumentos. La misma sintaxis de formato compuesto la aceptan Console.WriteLine, StringBuilder.AppendFormat y TextWriter.Write:

using System;

class Program
{
    static void Main()
    {
        string item = "Notebook";
        decimal price = 3.5m;
        int qty = 4;

        string line = string.Format("{0} x{1}: {2:F2}", item, qty, price * qty);
        Console.WriteLine(line);

        Console.WriteLine("{0,-10}|{1,6:F2}", item, price);   // alignment and format
        Console.WriteLine("{0} {0} {1}", "echo", "!");        // an index can repeat

        string template = "Dear {0}, your order #{1:D6} has shipped.";
        Console.WriteLine(string.Format(template, "Leo", 731));
    }
}

Salida:

Notebook x4: 14.00
Notebook  |  3.50
echo echo !
Dear Leo, your order #000731 has shipped.

En el código, prefiere la interpolación: los valores están donde aparecen, así que un marcador no puede apuntar al argumento equivocado. string.Format sigue siendo la herramienta correcta cuando la plantilla es un dato, como un mensaje traducido cargado de un archivo de recursos. Un índice de marcador sin argumento correspondiente ({2} con dos argumentos) lanza una FormatException en tiempo de ejecución.

Cultura: controlar los separadores y la moneda

La interpolación, ToString y string.Format usan por defecto la cultura actual del hilo. En una máquina configurada en alemán, {1234.5:N2} produce 1.234,50; en Estados Unidos produce 1,234.50. El formato de moneda C usa el símbolo de la cultura. Para elegir la cultura de forma explícita, captura el string interpolado como un FormattableString y dale formato con un proveedor:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        decimal amount = 1234.5m;
        var us = new CultureInfo("en-US");
        var de = new CultureInfo("de-DE");

        FormattableString line = $"Total: {amount:N2}";
        Console.WriteLine(line.ToString(us));
        Console.WriteLine(line.ToString(de));

        Console.WriteLine(amount.ToString("C", us));
        Console.WriteLine(string.Format(de, "{0:N2}", amount));

        // For files, logs and URLs: always the invariant culture
        string csv = FormattableString.Invariant($"{amount},{0.75}");
        Console.WriteLine(csv);
    }
}

Salida:

Total: 1,234.50
Total: 1.234,50
$1,234.50
1.234,50
1234.5,0.75

Usa la cultura del usuario para el texto que leen las personas, y CultureInfo.InvariantCulture para todo lo que lee otro programa. Un CSV escrito con la cultura actual en una máquina en alemán tiene comas dentro de los números y no se puede leer en otro sitio. En .NET 6 y posteriores, string.Create(CultureInfo.InvariantCulture, $"...") hace lo mismo que FormattableString.Invariant sin el objeto intermedio.

Strings interpolados literales y sin procesar

$ se combina con @ para un string interpolado literal (verbatim): las barras invertidas son literales y el string puede ocupar varias líneas. C# 8 y posteriores aceptan los dos órdenes ($@ o @$); C# 6 y 7 exigen $@:

using System;

class Program
{
    static void Main()
    {
        string user = "ana";
        int year = 2026;
        Console.WriteLine($@"C:\Users\{user}\Reports\{year}\summary.txt");
        Console.WriteLine($@"Report for {user}
Year: {year}");
    }
}

Salida:

C:\Users\ana\Reports\2026\summary.txt
Report for ana
Year: 2026

C# 11 añadió los strings interpolados sin procesar. Con un $, las llaves marcan expresiones como siempre. Con $$, una llave simple es literal y las expresiones necesitan dos llaves, lo que hace legibles las plantillas de JSON y de código:

// C# 11 and later
int id = 42;
string name = "Ana";
string json = $$"""
    {
      "id": {{id}},
      "name": "{{name}}"
    }
    """;

C# 11 también permite saltos de línea dentro de un hueco de interpolación, así que una expresión larga o una expresión switch pueden repartirse en varias líneas.

Errores comunes

• Olvidar el $. "Total: {total}" imprime las llaves literalmente. El compilador no avisa.
• Un ternario sin paréntesis dentro de las llaves: los dos puntos se leen como separador de formato.
• Dar formato a la salida legible por máquinas con la cultura actual. Las comas decimales rompen CSV, JSON y SQL. Usa la cultura invariante.
• Usar ToString() sin formato para el dinero. 2.5m se imprime como 2.5, no 2.50. Usa F2, N2 o C.
• Construir strings grandes con interpolación dentro de un bucle. Cada iteración crea un string nuevo; usa StringBuilder o string.Join.