Why Strings Are Immutable In Dot Net?


Next Read : An Extensive Examination Of ArrayList in C#

Most of the developers know that strings in .Net are immutable. But a very few knows the reason behind this behavior.  I will try to explain the same in this article.

Before diving into the reason, let me first explain what do we mean by immutable?

What do we mean by Immutable strings? 

The dictionary meaning of immutable is “unchanging over time or unable to be changed”. This means once a value is assigned to String object, it can never be changed. Yes, you read it correctly. Consider the following code:

myString

Output of this code will be.

abcdef
abcdefghijkl

Though it seems as if we just changed the value of myString from “abc” to “abcdef” and then to “abcdefghijkl”, but we really didn’t! Lets try to understand it. In first step, a new string object is allocated on the heap with value of “abc” and myString points to this memory location. At step no 2 (myString += “def”;), a new string object is allocated on heap with value of “abcdef” and myString now points to this new memory location. But the string “abc” still exists on heap. So we actually sit with two string objects on the heap, even though we’re only referencing one of them. Continuing same way, at the end of this code we will have four string objects, with only one object referenced and other three unused. The following memory allocation diagram of above code will make things more clear.

Memory Allocation of immutable strings
Memory Allocation of immutable strings

Now we will move on to the context of why.

Why strings are immutable in dot net?

Designers of .Net decided to implement immutable text strings. They have multiple reasons for this architecture. If programmers have multiple string variables with same value, it will avoid allocating memory for same string value multiple times. It will allocate memory to string once and all the variables will point to the same memory block.  Consider the following block of code.

same string

Memory allocation for this code will look like this:

Memory Allocation of Same String
Memory Allocation of Same String

If strings were mutable, changing the value of str1 would have changed the value of str2 and str3 also, which is unwanted.

Second, immutable strings eliminates race conditions in multi threaded applications. Any text amendment causes creation of a new variable so there is no need to set up the lock to avoid conflicts while multiple threads simultaneously access text. In some cases, those race conditions could be used to mount security attacks.  For example, you could satisfy a FileIOPermission demand with a string pointing to an publicly accessible section of the file system, and then use another thread to quickly change the string to point to a sensitive file before the underlying CreateFile occurs.

Another reason for string immutability is the well adapted use of strings as keys in hashtables. The objects on which the hash values are computed must be immutable to make sure that the hash values will be constant in time.

Another cool thing about string immutability is that even though System.String is a class, string objects get compared with equivalence, as a value type. This is possible because we can consider that the identity of an immutable object is its state. Consider following piece of code:

String Comparison

Even thought str1 and str2 reference 2 different objects ,the above code returns true.

StringBuilder : An alternative to avoid creation of unused strings

As we saw in figure “Memory Allocation of immutable strings”, there are unused strings allocated in memory. Its because of the way string behaves. If a code makes thousands of operations on string , heap will have thousands of unused string objects leading to unwanted memory wastage. Fortunately we can avoid this by using StringBuilder class. In my next article I will discuss about this class.

I hope you must have enjoyed the article. Please leave your comments and feedback in comments section at bottom. If you have any doubt or query, please feel free to ask in comments. Thanks for reading.

Click to read it on LinkedIn

Next Read : An Extensive Examination Of ArrayList in C#

Advertisements

9 thoughts on “Why Strings Are Immutable In Dot Net?

What do you think about this article?

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s