Performance deep dive

In this approach, we'll find out how to most efficiently reverse a string in C#.

The approaches page lists three idiomatic approaches to this exercise:

1. Using LINQ
2. Using Array.Reverse()
3. Using StringBuilder

For our performance investigation, we'll also include a fourth approach that uses Span<T>.

Benchmarks

To benchmark these approaches, we wrote a small benchmark application using BenchmarkDotNet library. The benchmark checks the various approaches against strings of length 0, 10, 100 and 100_000. Besides the regular CPU-time columns, the amount of memory used was also tracked.

These are the results:

The final rankings are:

1. Using Span<T>
2. Using Array.Reverse()
3. Using StringBuilder
4. Using LINQ

Span<T>

The top performing approach is the Span<T> approach. This is due to us allocating the char [] on the stack and not on the heap. Stack access is both faster than heap access and does not require garbage collection.

The main downside is that the stack has a relatively small amount of memory, so for very large strings you'll get a StackOverflowException.

Array.Reverse

The Array.Reverse() call has very similar performance characteristics to the Span<T> approach. This is not coincidental, as Array.Reverse() actually uses Span<T> internally:

case CorElementType.ELEMENT_TYPE_CHAR:
    UnsafeArrayAsSpan<short>(array, adjustedIndex, length).Reverse();
    return;

The main reason why it is slower than the Span<T> approach, is that the ToCharArray() call allocates a char[] on the heap, which is slower to access and needs to be garbage collected:

char[] chars = new char[Length];

LINQ

The LINQ-based approach is the slowest and allocates the most memory. In general, LINQ makes for highly readable code, but is usually not the most performance.

StringBuilder

The StringBuilder approach is slightly better, but still quite a bit slower than the two top-performing approaches. It also allocates the most memory of all the approaches.

One common way to optimize performance when using a StringBuilder is to set its internal buffer's capacity to a value that won't be exceeded:

var chars = new StringBuilder(capacity: input.Length);

Unfortunately, in this case this does not give us any performance benefit:

Conclusion

The top performing approaches are the Span<T> and Array.Reverse() approaches. The Span<T> approach has the downside of being more error-prone to write and from not working for all inputs, but it is the fastest approach. 🏆

The two slowest approaches, LINQ and StringBuilder, are also the ones that allocate (the most) memory.