String repeat method for C#

C# doesn’t have built-in function to repeat a string. There are different version for string.Repeat() available in internet and it’s up to reader to find out which version works better. Here is the list of most popular implementations I found across the web. I list my findings here with the results of simple performance test.

String repeat implementations

I found these six implementations to be most popular:

• ForLoop – string is repeated in regular for loop
• PadLeft – string is repeated using empty string, PadLef() method and Replace() method
• Replace – string is repeated using String constructor and Replace() method
• Concat – string is repeated using Concat() method on Enumerable.Repeat()
• StringBuilderInsert – sring is repeated using Insert() method on StringBuilder()
• StringBuilderAppend – string is repeated using AppendJoin() method on StingBuilder()

The last one is a little bit rare actually but I added it here as it gave also great results.

String repeat methods

Here is the source code of all six methods. I left out sanity checks and other bullet-proofing to keep methods clean of all additional functionalities.

static string RepeatForLoop(string s, int n)
{
    var result = s;
 
    for (var i = 0; i < n - 1; i++)
    {
        result += s;
    }
 
    return result;
}        
 
static string RepeatPadLeft(string s, int n)
{
    return "".PadLeft(n, 'X').Replace("X", s);
}
 
static string RepeatReplace(string s, int n)
{
    return new String('X', n).Replace("X", s);
}
 
static string RepeatConcat(string s, int n)
{
    return String.Concat(Enumerable.Repeat(s, n));
}
 
static string RepeatStringBuilderInsert(string s, int n)
{
    return new StringBuilder(s.Length * n)
                .Insert(0, s, n)
                .ToString();
}
 
static string RepeatStringBuilderAppend(string s, int n)
{
    return new StringBuilder(s.Length * n)
                .AppendJoin(s, new string[n+1])
                .ToString();
}

Performance of string repeat methods

I ran simple performance tests on all those methods. Here is what I exactly did:

• every method was run one million times,
• test string was simply “Test!”,
• test string was repeated by all methods 130 times,
• during tests all programs and services with more impact on machine performance were closed,
• test code was built on latest .NET Core in Release mode and run on console,
• I measured time that takes for each method to run one million times.

Here are my performance test results. Times are given in milliseconds (divide by thousand to get seconds).

We can clearly see that ForLoop is total overkill. It doesn’t have any optimizations and it results in big number of allocations and buffer copies. It is out of question to use this method in production. But be warned – ForLoop works fast and doesn’t show any signs of performance problems if it is not used intensively.

Other methods are approximately up to 6.5 times faster. In all my tests StringBuilderInsert and StringBuilderAppend gave the best results. StringBuilderAppend was on all test few hundred milliseconds better that StringBuilderInsert. As it was the winner I present it here as extension method you can add to some library.

public static class StringExtensions
{
    public static string Repeat(this string s, int n)
    {
        return new StringBuilder(s.Length * n)
                        .AppendJoin(s, new string[n+1])
                        .ToString();
    }
}

Wrapping up

There are many implementations available for string repeat method and not all of them are equal from performance perspective. We saw that most primitive version using for-loop has awful performance while more cumbersome method using StringBuilder and AppendJoin was the best. If there is more than one implementation available then it’s good idea to make some tests to see what is best peforming implementation and go with this.