Boost Your C# App Performance: 7 Tips You Can’t Ignore

In today’s software development landscape, performance plays a pivotal role in delivering efficient and scalable applications. Writing optimized C# code ensures that your applications can handle increasing workloads while maintaining responsiveness.

This article explores practical tips and techniques to improve the performance of C# code, from comparing the statistics of each methods to decide which one is the best. By applying these strategies, developers can build applications that are not only robust but also lightning-fast.

Keywords to understand

In order to compare the performance, we would be comparing the following statistics.

• Mean: Average execution time.
• Error: Margin of error.
• StdDev: Standard deviation of the execution time.
• Median: Median execution time.
• Ratio: Comparison of execution times between methods.

String vs Char

When using IndexOf, StartsWith, EndsWith with single character always prefer character overload instead of string overload.

Performance Output

Explanation of the Results:

EndsWithStringValue (String version):

• This method takes around 8.7 nanoseconds to complete on average. It has a higher Mean, Error, and StdDev compared to EndsWithCharValue.
• This is because comparing two strings involves more overhead, like allocating memory and handling complex string comparisons.

EndsWithCharValue (Char version):

• This method takes around 0.01 nanoseconds on average. It’s much faster because comparing a character is a simpler, more direct operation compared to string comparisons.
• The Ratio of 0.001 shows it is significantly faster compared to the string method.

Result:

• Using EndsWith(char) is much more efficient in terms of both speed and consistency (low StdDev) compared to using EndsWith(string).
• If you’re optimizing for performance, using the char overload of methods like EndsWith is recommended over the string version when possible.

String Concatenation vs String Builder

Avoid concatenating strings in loops. Strings are immutable which means that once a string object is created it cannot be modified.

What happens when we concatenate strings in loops?

When we concatenate the string strings using ‘+’ operator in a loop, at each iteration a new string object is created resulting performance issues.

It can be a dreading result when dealing with large strings or a large number of iterations.

Performance Output

Result:

Using StringBuilder is generally more efficient for repeated concatenation operations due to reduced overhead in memory allocation and copying.

Skip and Take vs Take with Range syntax

In traditional Skip(n).Take(n) [where n is an integer specifying the count] the Skip() skips the first n elements of a sequence and then the Take() returns the first n elements of a sequence.

In C# 8, instead of Skip(n).Take(n) you can simply write Take() to return a specified range of elements from a sequence defined.

Performance Output

Result:

Definitely Take(n..x) performs better than Skip(n).Take(n) because it can be implemented in a single pass over the collection whereas Skip requires iterating over the elements that need to be skipped. Using Skip can be costly for large collections.

ToLower / ToUpper vs string.Equals

Case conversion is often required in C# to normalize the comparison of string inputs. We might want to ignore the case differences for example, “John Wick” and “JOHN WICK” should be considered equal — in such scenarios, the ToLower() or ToUpper() can be used.

There is something else, known as string.Equals. This is a direct call and performs a case-insensitive comparison by default.

Performance Output

Look at the difference! The ToLower() converts both the strings to lower case before comparison. The string.Equals() accepts two params as the main ones to compare the string.

Result:

Clearly string.Equals performs well compared to ToLower(). It is more efficient because it avoids creating new string instances for comparison.

Using ‘ToString()’ vs ‘nameof’ for Enum to String conversion

We’ve been into situations often where we have to convert an Enum value to string because Enum returns an integer value.

We can convert an Enum to a string two ways. First one is .ToString() and the other is nameof

Performance output

Result:

The nameof stands out much better in performance to convert an enum to a string. This is because this method is evaluated at a compile-time. It injects a string literal that never changes. This is much useful to avoid magic strings in your code.

One disadvantage to highlight is that using the nameof() with enums can lead to mismatched enum member names if the enum changes without recompiling referencing projects because as we have discussed above, nameof provides names at compile-time.

Exists() vs Any()

Array types and List<T> has Exists() method. This method checks whether an element that satisfies the condition exists in the list or array.

On the other hand, the Any() works with IEnumerable<T> including arrays, lists and other collection types. It checks whether any element in the IEnumerable<T> satisfies the condition.

Performance Output:

Result:

Use Exists() over Any() because Exists() doesn’t require the overhead of creating an enumerator that Any()` does.

Contains() vs Any()

C# provides Contains() for checking of a specific item in a collection.

Any() works with IEnumerable<T> including arrays, lists and other collection types. This is more general method that checks if any element in the collection satisfies a provided collection.

Performance output

Result:

Use Contains()` over Any()` because Contains() directly checks for the equality of each elements to the specified value.

Conclusion

So, as a wrap up, I just want to say optimizing your C# application’s performance isn’t just about writing code faster; it’s about writing it smarter. By implementing these tips, you’re well on your way to creating applications that not only run efficiently but also scale effectively.