C# String Format Examples

Mastering C# string format methods and remembering the various format specifiers can be tricky. Although the official String.Format documentation provides comprehensive details, it can be challenging to navigate quickly. In this article, we’ll simplify string formatting in C# by breaking down key concepts, common methods, and important format specifiers. From using string.Format and StringBuilder to leveraging the FormattableString type, we’ll cover everything you need to know to make your code cleaner and more efficient.

What Is a Format String in C#?

A C# string format is a string that includes placeholders, defined using curly braces {}, which are replaced with specified values at runtime using methods like string.Format, Console.WriteLine, or string interpolation ($). The most common way to format strings is by using string.Format(), which inserts the value of a variable, object, or expression into another string by replacing the format items with their string representation.

For example:

var msg = string.Format("There are {0} balls", 3);

Another way we can format a string is to use the StringBuilder.AppendFormat() method:

decimal num = 34.53567325m; 
var builder = new StringBuilder(); 
builder.AppendFormat("Format Decimal: {0:n2}", num);

And the third way to format a string is by using:

Console.WriteLine("There are {0} balls", 3);

In .NET 4.6, a new type called FormattableString was introduced. It includes the format string that would typically be passed to string.Format (e.g. "Hello, {0}"); and the arguments needed for formatting. Importantly, this information is captured before the string is formatted, allowing you to adjust the formatting as needed, most commonly to use the invariant culture with the Invariant static method. For example:

FormattableString y = $"FormattableString: It is now {DateTime.UtcNow}";
Console.WriteLine(FormattableString.Invariant(y)); 
// Result: FormattableString: It is now 03/18/2021 10:40:45

Essentially, it provides greater control over string formatting, particularly for scenarios that require consistent formatting across different cultures.

Format Specifiers

Here is a quick reference to all the conversion specifiers supported.

Number Formats

Custom Formats

Date and Time Formats

String Format Index

A string argument index is specified as a number in {} and is positional.

string.Format("There are {0} balls and {1} rackets", 3, 5); // result: There are 3 balls and 5 rackets

Formatting Numeric Data

With {0:D}, we can format numbers in decimal format.

string.Format("Number: {0:N}", 157); // result: 157,00

We can also write like this:

string.Format("{0:D}  {1,6:D}", 634, 868); // result: 634     868

The {0:D} format item specifies the first item from the list of supplied objects that will be taken and formatted in decimal format. The {1,6:D} format item takes the second item, formats it also as a decimal, and the string length will be 6 characters. Because the number has only three characters, it is right-aligned and padded with empty strings.

We can format a number in other notations, too, such as scientific, currency, percent, and hexadecimal:

string.Format("Scientific: {0:E}", 157); // result: 1.570000E+002 
string.Format("Currency: {0:C}", 157); // result for US locale: $157.00 
string.Format("Percent: {0:P}", 157); // result: 15,700.00% 
string.Format("Hexadecimal: {0:X}", 157); // result: 9D

In addition, we can have format alignments, which represent a minimum number of characters to be written to the output. E.g., {0,10} with right-align and for left-align, we need to specify a negative length, like {0,-10}:

string.Format("{0,10}", 1); 
// result:          1

String Cultures

String Format also has the following signature: public string Format(IFormatProvider, string, object)

Which means it accepts IFormatProvider. It provides cultural info into the method and is normally implemented by a CultureInfo class (e.g., CultureInfo.CurrentCulture, CultureInfo.InvariantCulture, etc.). The interface is a gateway for a function to get a set of culture-specific data from a culture. The three commonly available culture objects that an IFormatProvider can be queried for are:

• DateTimeFormatInfo
• NumberFormatInfo
• CultureInfo

For example:

DateTime dateValue = new DateTime(2021, 4, 16, 10, 40, 0); 

var enUSCulture = new CultureInfo("en-US"); 
var itITCulture = new CultureInfo("it-IT");
 
Console.WriteLine("{0}: {1}", enUSCulture.Name, dateValue.ToString(enUSCulture)); 
// Result: en-US: 4/16/2021 10:40:00 PM 

Console.WriteLine("{0}: {1}", itITCulture.Name, dateValue.ToString(itITCulture)); 
// Result: it-IT: 16/04/2021 10.40.00

String Interpolation — $

In C# 6 or later versions, String Interpolation is recommended. String interpolation is more flexible and more readable and can achieve the same results without composite formatting. The $ special character identifies a string literal as an interpolated string. An interpolated string is a string literal that might contain interpolation expressions.

For example:

string name = "Mike"; 
var date = DateTime.Now; 

// Composite formatting: 
Console.WriteLine("Hello, {0}! Today is {1}, it's {2:HH:mm} now.", name, date.DayOfWeek, date); 

// String interpolation: Console.WriteLine($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now."); 

// Result: Both calls produce the same output that is similar to: 
// Hello, Mike! Today is Tuesday, it's 10:40 now.

We can also use optional formatting component ({<interpolationExpression>[,<alignment>][:<formatString>]}), alignment and formatString, which are part of Composite Format String. A composite format string and object list are used as arguments of methods that support the composite formatting feature. An optional alignment component is a number indicating the preferred formatted field width, while the optional formatString component is a format string that is appropriate for the type of object being formatted (custom or standard numeric format).

Console.WriteLine($"|{"Left",-7}|{"Right",7}|"); 
// Result: |Left   |  Right| 

const int FieldWidthRightAligned = 20; 

Console.WriteLine($"{Math.PI, FieldWidthRightAligned} - default formatting of the pi number"); 
// Result:      3.14159265358979 - default formatting of the pi number 

Console.WriteLine($"{Math.PI, FieldWidthRightAligned:F3} - display only three decimal digits of the pi number"); 
// Result:                 3.142 - display only three decimal digits of the pi number

Conclusion

Formatting strings in C# is a skill that can significantly enhance the clarity and efficiency of your code. Whether using string.Format, StringBuilder.AppendFormat, or the more modern string interpolation introduced in C# 6, each method provides powerful tools for crafting well-structured and readable output. 

Additionally, understanding format specifiers, custom numeric and date/time formats, and culture-specific formatting allows developers to handle diverse data scenarios with precision. By mastering these techniques, you can make sure your applications maintain consistent and professional outputs across different contexts and use cases.