Difference between String and StringBuilder class in Asp.Net C# ?

String
and StringBuilder class are used to handle the strings but there are subtle differences between these two.

Let's understand the difference between String and StringBuilder using suitable example:

1. Performance of StringBuilder is high as compared to String

Consider the following concatenation example:

String str= "";
str += "Welcome ";
str += "to ";
str += "kunalsaurav.com";

Output string will be Welcome to kunalsaurav.com

Let's do the same concatenation operation using StringBuilder class

StringBuilder sb = new StringBuilder("");
sb.Append("Welcome");
sb.Append("to ");
sb.Append("kunalsaurav332.com");
String str = sb.ToString();

Output string will be Welcome to kunalsaurav332.com

Have you noticed the result using String and StringBuilder is same; then what is the difference between these two? The difference is in their performance. Whenever we concatenate new string to the old string then String class always create new object of string type in memory where as when you use string builder class for that purpose, it updates string at one place in memory and does not create new space in memory.

So obviously StringBuilder consumes less memory thus perform faster operation. So it is always recommended to use StringBuilder class for operations that manipulate strings. StringBuilder will give better performance as compared to String when concatenating the strings like shown above in example.

2) From the above point it is clear that String consumes more memory as compared to StringBuilder

3) String Concatenation can be done using '+' operator or using the String.Concat method whereas in case of StringBuilder we use Append() method to concatenate.

4) String is Immutable (Non Modifiable) whereas StringBuilder is a Mutable Class

String is immutable i.e. the value stored in the String object cannot be changed. We cannot change it after creating it. Every time we use one of the methods in the System.String class that manipulate the string, we are actually creating a new string object in memory, which requires a new allocation of space for that new object. Internally a new String object is created each time whenever we do the changes.

For example, when we use the "String" object to concatenate two strings, the first string is concatenated to the other string by creating a new copy in the memory as a string object, and then the old string is deleted so we can say when we create a string we can never change it, rather it will create a new string to store the new value.

Hence it can cause performance issue in situations where we need to perform repeated modifications to the string because overhead associated with creating a new String object can be costly.

StringBuilder is mutable. By mutable we mean that we can perform the operations that manipulate the string without creating the new StringBuilder object each time.

For example, using the StringBuilder class can boost performance when concatenating many strings together in a loop. So StringBuilder is more efficient if large amounts of string manipulations have to be performed.

4) String class belongs to the namespace System while StringBuilder class belongs to the namespace System.Text.

5) When string concatenation takes place, additional memory will be allocated whereas in case of StringBuffer additional memory will be allocated only when the string buffer capacity exceeds.

When to use String or StringBuilder Class?
For simple String manipulations we can use String class. But for large string manipulations it is recommended to use StringBuilder class.