Format String In C#

Download Sample Source Code

Displaying and Formatting Strings C# is a common task. Whether you are building a simple console application or a complex web application, how you present your data to users matters.

This is where Format String In C# comes into play, especially C# $ String Format ( C# String Interpolation ), a modern feature. Format string in c# provides a powerful and flexible way to control the manipulation and appearance of data when converting it to a string representation.

C# formatting strings feature can help us craft beautiful and neatly formatted output strings. The power of string formatting is multifaceted. From generating aesthetically pleasing console outputs to crafting perfectly formatted report data and beyond, a sound understanding of C# format string is an essential skill in the modern C# developer's toolkit.

Format string in C# can also be a handy tool when writing and debugging code. For all developers, from beginners to experts, understanding C# Format String, including the C# $ String Format and C# Tostring Formatting, will increase your efficiency and clarity when dealing with strings.

Today, we will look into ins and outs of C# String Formatting, learn how to use them effectively and understand why they are essential for clean and professional code.


  1. Format string in C# is a tool for controlling the manipulation and appearance of data when converting it to a string representation.
  2. C# String Interpolation, denoted by the $ symbol, provides a short way to format strings by directly including variable placeholders in the string itself. It simplifies the process of creating formatted strings.
  3. C# Format String, used with the String.Format method, allows for formatting and replacing placeholders within a string with specified parameters. It uses zero-based indexing and provides control over alignment, spacing, and format of inserted values.
  4. C# provides various format specifiers (such as C, D, E, F, N, P) that define how values are displayed within formatted strings. These specifiers are used to format numbers, currencies, percentages, dates, and custom patterns.
  5. When working with formatting strings, it's important to avoid common mistakes such as using incorrect indices for placeholders and mismatching data types with format specifiers.

You can download the source code attached, practice it, and use it in your application!

Format String In C#

String Formatting In C# is typically used in conjunction with the “String.Format”, “ToString”, and C# Format String $ ( C# String Interpolation ) methods. These are widely used methods, and we will definitely learn here today!

In essence, a Format String In C# is a string with embedded format items, which are placeholders for other values. These placeholders, identified by curly braces "{}", can be filled with specific values during runtime using the string.Format() method.

C# $ String Format

C# 6.0 introduced an alternative way of formatting strings known as C# String Interpolation. The idea is to include the variable placeholders directly inside the string text. You just need to precede the string with a $ symbol. This is the so-called C# $ string format.

string name = "John Doe";
string message = $"Hello, {name}!";
Console.WriteLine(message); // Output: Hello, John Doe!

Another example is with two variables, using C# $ string format.

string name = "John";
int age = 25;
string result = $"Hello, {name}. You are {age} years old.";

Console.WriteLine(result); // Output: Hello, John. You are 25 years old.

Interpolated strings start with a $ sign before the double quotes. The variables are directly embedded into the string in curly braces "{}".

The advantage of this approach is readability. The C# formatted string is easier to understand because the variable is placed exactly where it will appear in the result.

C# Format String $

So in previous code examples, we saw a simple implementation of c# string interpolation. Let’s discuss how to format c# string using the C# Format String $ operator.

string name = "Alice";
int age = 25;
double salary = 5000.50;

string formattedString = $"Name: {name}, Age: {age}, Salary: {salary:C}";


// Output : Name: Alice, Age: 25, Salary: $5,000.50

In the example above:

  1. The $ symbol before the string indicates that it's an interpolated string.
  2. Within the string, you can include variables or expressions enclosed in curly braces {}.
  3. The variable's name, age, and salary are directly inserted into the string using interpolation.
  4. “:C” is a format specifier used for currency formatting in C#.

We can use various format specifiers to control how the values are displayed within the string, we can say it is “String Formatter C#”. You will see how to use format specifiers later in this article, like “N” for Number format, “D” for Decimal format, “F” for Fixed-point format, and many others!

We can also include expressions within the curly braces to perform calculations or call methods like this:

int x = 5;
int y = 10;

string expressionString = $"Sum: {x + y}, Product: {x * y}";

// Output : Sum: 15, Product: 50

As you can see, C# Format String $ simplifies the process of creating formatted strings by directly including variables or expressions, and format specifiers within curly braces {} inside a string.

String.Format C#

C# String.Format method is a versatile function used to format and replace placeholders within a string with specified parameters. The method has a flexible syntax which can help you achieve a C# Formatted String.

String.Format In C# formats and substitutes objects into a string. Here's a brief example, how to use the C# String.Format method:

string name = "John";
int age = 25;
string result = string.Format("Hello, {0}. You are {1} years old.", name, age);

// Output: Hello, John. You are 25 years old.

The functionality is the same as C# $ String Format example we saw earlier, but the syntax is different.

Note that C# uses zero-based indexing, meaning the initial element in an array or list is at index 0, 1 for the second element, and so on. Therefore, the first argument after the format string is referred to as "{0}", the second as "{1}", and so on.

The placeholders are denoted by curly braces "{}". Each placeholder contains a number that corresponds to the index of the object in the parameters. In the example above, "{0}" corresponds to "name", and "{1}" corresponds to "age".

The basic syntax of a placeholder (or format item) is as follows:


Let’s first an example, then you will see what each parameter is for:

string name = "John";
double balance = 1234.5678;
string formattedString = string.Format("Name: {0,-10} | Balance: {1,10:C}", name, balance);

// Output : Name: John       | Balance: $1,234.57

Don’t worry, if you feel this example is a little difficult to understand, keep reading and you will find easy-to-understand explanations later.

Parameter Description
index Represents the zero-based index of the argument to be inserted. In the above example, we have a 0 index for the name and 1 for Balance.
alignment It is optional parameter that determines the minimum width of the field. It specifies the number of spaces to reserve for the field, allowing for right or left alignment. In the above code, we and -10 and 10. We will see details and another code example in the “Control Alignment - String.Format C#” section.
formatString An optional parameter (like “:C”) that defines the format of the inserted value, such as the number of decimal places, currency symbols, date, and time formats, etc. We saw similar use in the C# Format String - $ section.

Control - Formatting Strings C#

Formatting Strings C# tools allow you to control how the output of a string looks. Understanding the format specifiers and how they work with different data types is crucial as it is especially helpful when dealing with numbers, dates, and times. The "String.Format" method allows for a range of formatting options.

double number = 12345.6789;
string numberString = String.Format("{0:N}", number); 

// Output : "12,345.68"

In the example above, "{0:N}" is used to format a double value as a Number.

C# provides various format specifiers including

Format Specifiers Description
C Currency format
String.Format("{0:C}", 12345.6789)
// Output: $12,345.68
D Decimal format
String.Format("{0:D}", 42)
// Output: 42
E Exponential notation (scientific) format
String.Format("{0:E}", 12345.6789)
// Output: 1.234568E+004
F Fixed-point format
String.Format("{0:F}", 12345.6789)
// Output: 12345.68
G General format (default format)
String.Format("{0:G}", 12345.6789)
// Output: 12345.6789
N Number format with thousands separator
String.Format("{0:N}", 12345.6789)
// Output: 12,345.68
P Percentage format
String.Format("{0:P}", 0.42)
// Output: 42.00%
R Round-trip format (for floating-point numbers)
String.Format("{0:R}", 12345.6789)
// Output: 12345.6789
X Hexadecimal format
String.Format("{0:X}", 42)
// Output: 2A
Custom Formats Such as phone numbers, with the appropriate pattern.
String.Format("{0:(###) ###-####}", 1234567890)
// Output: (123) 456-7890
% Percentage
String.Format("{0}%", 42)
// Output: 42%

Control Spacing and Alignment - C# String.Format

Okay, so you're curious about how to control spacing and alignment, right? Let's talk again about that neat method called “String.Format”. This thing is a real powerhouse! It lets you insert variables into strings, control spacing, and alignment, you name it.

Here's a super simple example. Let's imagine you've got an array of names and ages:

string[] names = { "Alice", "Bob", "Charlie" };
int[] ages = { 20, 25, 30 };

for (int i = 0; i < names.Length; i++)
    string formatted = String.Format("{0,-10} is {1,3} years old.", names[i], ages[i]);

// Output:

   Alice      is  20 years old.
   Bob        is  25 years old.
   Charlie    is  30 years old.

Here, "-10" and "3" inside the placeholders are the game-changers.

  1. {0,-10} represents the name, which can contain a width of 10 characters and left alignment. The negative sign indicates left alignment.
  2. {1,3} represents the age, which can contain a width of 3 characters and right alignment. The positive sign indicates right alignment.

By using String.Format with control spacing, we ensure that the names and ages are displayed in a tabular format with consistent alignment and spacing.

C# Tostring Formatting

The ToString C# Format in C# can be used to convert a value to its string representation. It also allows custom formatting. The ToString C# Format method works similarly to C# String.Format when it comes to using format specifiers.

double price = 99.99;
string result = price.ToString("C");

// Output: $99.99

C# Format String $ Or C# String.Format

While "String.Format" is a potent tool but c# string interpolation, signified by the "$" in C# $ String Format, offers a more readable and concise approach. With interpolation, the placeholders are directly included in the string, eliminating the need to manage the positional references in the C# String.Format.

How Many Items In The C# Formatting Strings?

The format list in the C# String.Format method can contain as many items as needed. However, readability can be a concern with a long list of parameters. In such cases, C# String Interpolation (C# Format String $) can be a more practical approach.

Common Mistakes in C# Formatting Strings

While C# Formatting Strings is usually straightforward, there are common mistakes that developers often make.

One such mistake involves indexing. Remember, the index of placeholders starts from 0, not 1. So if you have two objects to format, the indices should be {0} and {1}, not {1} and {2}.

Another common mistake is mismatching the data type with the format specifier. It's crucial to understand which format specifiers work with which types of data.

End of Journey

C# Formatting Strings offers multiple ways to construct, manipulate, and present strings. Whether you choose to use the C# String.Format method or prefer the cleaner approach of C# String Interpolation (C# Format String $) or even C# String.Format method, your C# toolkit will have the optimal tool for the task at hand.

And there you have it! Now you're a whiz at C# Formatting Strings!

Go ahead and also read the detailed article on Date Time Format In C#.