Introduction: In this article i am going to explain
the
difference between String and StringBuilder class in ASP.NET with C# and When
to use String and when to use StringBuilder and why? It is one of
the important
interview questioned asked in interview.
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 += "webcodeexpert.com";
Output string will be Welcome to webcodeexpert.com
Let's do the same concatenation operation using
StringBuilder class
StringBuilder sb = new StringBuilder("");
sb.Append("Welcome");
sb.Append("to ");
sb.Append("webcodeexpert.com");
String str = sb.ToString();
Output string will be Welcome to webcodeexpert.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.