Best Way to Repeat a Character in C#: Building Repeated Strings Efficiently

By the end of this page, you will understand how repeated string creation works in C#, why some approaches are more efficient than others, and which option is usually best for repeating a character such as \t. You will also learn when StringBuilder is useful, why repeated string += can become expensive, and which built-in APIs make this task simplest.

In C#, string objects are immutable. That means once a string is created, it cannot be changed. If you write code like this:

output += '\t';

a new string is created each time through the loop.

That matters because building a string one piece at a time with += can become inefficient. Each concatenation may copy the old contents into a new string, then add the new character.

For a small number of tabs, this usually does not matter much. But for larger counts, it can become much slower and use more memory.

Why StringBuilder exists

StringBuilder is designed for cases where you build a string gradually. Instead of creating a brand-new string for every append, it keeps a mutable internal buffer and grows it as needed.

That makes it a better choice than repeated += when:

• you are appending inside a loop
• you do not know the final string up front
• the result may be large

Why the LINQ version is not ideal here

LINQ is great for querying collections, but this problem is not really a collection-query problem. Using:

• Enumerable.Repeat
• then Aggregate

adds extra abstraction and overhead for something very simple. Also, still performs repeated string concatenation, so it does not avoid the core inefficiency.

Think of a string like text carved into stone.

• If you want to add one more character, you cannot change the stone.
• You must carve a new stone with all the old text plus the new character.

That is what happens with repeated string +=.

Now think of StringBuilder like writing on a whiteboard.

• You can keep adding characters without recreating everything each time.
• When you are done, you copy the final result into a string.

And think of new string('\t', count) like ordering a pre-made rope of exactly the right length.

• You already know the character
• You already know how many times it should repeat
• So the runtime can create the final result directly

That is why it is usually the cleanest option for this case.

If you want to repeat a single character in C#, the most direct syntax is:

string tabs = new string('\t', 3);
Console.WriteLine(tabs.Length); // 3

Recommended approach

private string Tabs(int numTabs)
{
    return new string('\t', numTabs);
}

Example:

Console.WriteLine(Tabs(3) == "\t\t\t"); // True

This is usually the best solution because it is:

• short
• readable
• efficient

Using StringBuilder

If you need to build text in multiple steps, use StringBuilder:

using System.Text;

private  ()
{
    StringBuilder sb =  StringBuilder(numTabs);
     ( i = ; i < numTabs; i++)
    {
        sb.Append();
    }
     sb.ToString();
}

Consider this example:

string result = new string('\t', 4);

What happens step by step

1. The character \t is chosen as the content to repeat.
2. The count 4 tells C# how many times to repeat it.
3. The runtime allocates a string of length 4.
4. Each position is filled with a tab character.
5. The final string is returned.

The result is equivalent to:

"\t\t\t\t"

Compare with +=

string output = "";
for (int i = 0; i < 4; i++)
{
    output += '\t';
}

Trace:

• Start: output = ""
• After loop 1: "\t"
• After loop 2: "\t\t"
• After loop 3:

Repeating characters or short strings appears in many real programs.

Indentation and formatting

Your tabs example is common when generating:

• formatted console output
• source code
• XML or JSON-like text
• nested debug output

string indent = new string('\t', depth);
Console.WriteLine(indent + "Node");

Padding output

You may repeat spaces or symbols to align text:

string line = new string('-', 20);
Console.WriteLine(line);

Generating separators

string border = new string('=', 40);

Useful for logs, reports, and command-line tools.

Creating test data

When testing string-processing code, developers often generate repeated input:

string sample = new string(, );

In real projects, developers usually choose the tool based on the shape of the problem.

Common pattern: direct character repetition

If the task is exactly “repeat one character N times”, developers typically use:

string indent = new string('\t', level);

This is common in:

• pretty-printers
• text exporters
• log formatters
• code generators

Common pattern: build a larger string with many parts

When repeated characters are only one part of a larger output, developers often use StringBuilder:

var sb = new StringBuilder();
sb.Append(new string('\t', level));
sb.AppendLine("Item");

Validation and guard clauses

In production code, developers often validate counts before constructing strings:

private string Tabs(int numTabs)
{
    if (numTabs < 0)
        throw  ArgumentOutOfRangeException((numTabs));

      (, numTabs);
}

1. Using += inside a loop for large strings

Broken or inefficient pattern:

string output = "";
for (int i = 0; i < 10000; i++)
{
    output += '\t';
}

Why it is a problem:

• each concatenation creates a new string
• performance gets worse as the string grows

Better:

string output = new string('\t', 10000);

or, for more complex output:

var sb = new StringBuilder();

2. Using LINQ for simple string repetition

var tabs = Enumerable.Repeat("\t", count);
string result = tabs.Aggregate((a, b) => a + b);

Why it is not ideal:

• more complex than necessary
• still performs repeated concatenation
• less readable for this specific task

Better:

Best option for repeating one character

string tabs = new string('\t', count);

Recommended method

private string Tabs(int numTabs)
{
    if (numTabs < 0)
        throw new ArgumentOutOfRangeException(nameof(numTabs));

    return new string('\t', numTabs);
}

When to use what

• Use new string(char, count) for one repeated character
• Use StringBuilder for many appends or complex text generation
• Avoid string += in loops for large strings
• Avoid LINQ for this simple repetition task

Key rule

string is immutable in C#.

That means:

output += ;

What is the fastest way to repeat a character in C#?

Usually new string(char, count) is the fastest and clearest way when you need one character repeated many times.

Is StringBuilder faster than string concatenation?

Yes, usually when you append repeatedly in a loop. StringBuilder avoids creating a new string on every append.

Is LINQ a good choice for repeating a string in C#?

Not usually for this problem. It is more verbose internally and less efficient than the direct new string solution.

Why is string += in a loop slow?

Because strings are immutable. Every concatenation creates a new string and copies existing content.

Should I use uint for counts that cannot be negative?

Usually no. Most .NET APIs use int, so using uint often makes code less convenient and requires casts.

What happens if the repeat count is 0?

new string('\t', 0) returns an empty string.

Can StringBuilder still be the right choice here?

Yes, if tabs are only one small part of a larger string you are constructing step by step.

• string immutability — explains why concatenation creates new strings instead of modifying existing ones.
• StringBuilder — the standard tool for efficiently constructing strings in multiple steps.
• string concatenation — useful for understanding + and += with text.
• char vs string — helps clarify when to use single quotes or double quotes.
• for loops — important because repetition is often implemented with loops.
• LINQ — relevant because it can express repetition, even though it is not ideal here.
• ArgumentOutOfRangeException — useful when validating numeric inputs such as counts.
• performance basics in C# — helps build intuition about allocation, copying, and efficient APIs.