Difference Between String and StringBuilder in C#.NET With Example

In C#, the System.String and System.Text.StringBuilder classes are two ways to work with strings. Although both allow you to manage and manipulate strings, there are important differences between them, especially in terms of performance and memory usage. In this tutorial, we’ll delve into the difference between string and StringBuilder in C#.Net.

Table of Contents

Overview

Below is a table outlining the key differences between String and StringBuilder in C#.Net.

Property	String	StringBuilder
Mutability	No	Yes
Performance	Slower for concatenation operations	Faster for concatenation operations
Memory Utilization	High when manipulating strings	Lower when manipulating strings
Thread Safety	Yes	No

Understanding String

Strings in C# are immutable. This means once a string is created, it cannot be changed. Any operation that appears to change the string instead creates a new string.

String Example

string city1 = "Los Angeles";
string city2 = "New York";

string cities = city1 + ", " + city2;
Console.WriteLine(cities);

In the code above, when concatenating city1 and city2, a new string is created. The original strings city1 and city2 are not changed, but a completely new string is formed and returned.

Understanding StringBuilder

In contrast to String, StringBuilder is mutable. It doesn’t create a new string in the memory every time you modify its value. This makes it a better choice when dealing with string manipulation operations, especially in loops or when you’re dealing with large amounts of data.

StringBuilder Example

StringBuilder sb = new StringBuilder();
sb.Append("Los Angeles");
sb.Append(", ");
sb.Append("New York");
Console.WriteLine(sb.ToString());

In this StringBuilder example, we’re achieving the same thing as in the String example, but without creating additional strings in memory. All the changes occur within the same StringBuilder object, which is more memory-efficient.

Performance Comparison

To illustrate the difference in performance between String and StringBuilder, let’s look at an example where we concatenate names of several US cities in a loop.

String Performance

string cities = "";
for(int i = 0; i < 10000; i++) {
    cities += "Los Angeles, ";
}

In this code, each iteration creates a new string in memory, which can be a significant performance hit when the loop runs a large number of times.

StringBuilder Performance

StringBuilder sb = new StringBuilder();
for(int i = 0; i < 10000; i++) {
    sb.Append("Los Angeles, ");
}

Here, the StringBuilder only creates a single object, and all changes are made to this object, making this code significantly faster and more memory-efficient when dealing with large string manipulations.

Conclusion

In summary, while both String and StringBuilder in C#.Net are used for string manipulations, StringBuilder is more efficient when it comes to memory and performance for large and complex string operations. However, String is thread-safe and suitable for simple string manipulations, particularly when the string isn’t going to be modified after creation. Always consider the specific requirements of your use case to determine which one to use.

I hope you got an idea of the difference between String and StringBuilder in C#.NET.