Advertisement

---

Top

< Prev

Next >

Similar to Java, one of the main goals of C# programming language is to minimize the redundancy and memory waste/overuse caused by storing String literals with duplicate values on the heap and this is why the common language runtime(CLR) reserves a special table on the Heap memory called intern pool, which stores only a single reference to each unique String literal declared in a program.

Note : Before we know more about String intern pool, we should know that a String object can be created in two ways:
• By directly assigning a String literal.
• By dynamically creating a String object:
  • By using the new keyword when calling the constructor of String class, or
  • By converting a StringBuilder object to String object.
  • By programmatically creating a String object i.e. by concatenating two string objects by + operator or by some other way.

Important points to remember

• String objects created by directly assigning a String literal are stored in the String intern pool table.
• Dynamically created String objects are stored in the normal memory part on the heap.
.

How String intern pool saves memory?

Now let's understand how String intern pool saves memory by a short code :-

//String objects created by directly assigning the String literals
String s1 = "Hello";             // Statement 1 
String s2 = "Hello";             // Statement 2 

//Creating a char array
char[] arr = {'H', 'e', 'l', 'l', 'o'};

//Dynamically creating a String object from a char[] array.
String str1 = new String(arr);	// Statement 3

After executing the above piece of code, String intern pool part on heap(a special area on the heap) and the other normal part of heap are represented by Figure 1.

• After executing statement 1, String object with value Hello is stored in String intern pool part on the heap because this object is constructed by directly assigning a String literal i.e. non-dynamic creation.


• Statement 2 asks for the creation of another String object with the same value Hello by direct assigning a String literal. Before allocating this object on String intern pool part of heap memory, CLR checks if there is already a String object with the value Hello present in "String intern pool" on the heap and it finds a String object with a same value Hello being referred by a reference variable s1 already.


• In order to save the memory from storing a String object with a duplicate value, the CLR assigns the reference of the existing String object with value Hello to reference variable s2 as well, thus saving heap memory. Now reference variables s1, s2 point to same String object with value Hello(Figure 1).


• But, after executing statement 3, the String object with a value Hello is created in a normal non-pool part of Heap memory because this object is dynamically created by using the new keyword.

Note: The duplicate reference of String literal Hello stored in the reference variable, s2, will be collected by garbage collector in its next run.

Advertisement

String intern pool example

Here in the upcoming program, we have created four String objects and we are using the ReferenceEquals() static method of the Object class, which checks for equality of references i.e. if two references point to a similar String object, to show how the String intern pool saves memory does not store duplicate String objects which are created non-dynamically i.e. by directly assigning the String literals.

//C# String Intern Pool Example

using System;
using System.Text;

class A
{
public static void Main()
{
	//Creating a String object in intern pool by directly assigning a String literal value
	String s1 = "Hello";  

	//Creating a String object in intern pool by directly assigning a duplicate String literal value
	String s2 = "Hello";  
	
	//Creating a String object in intern pool by directly assigning a String literal value
	String s6 = "HelloHello";

	
	//Creating a char array
	char[] arr = {'H', 'e', 'l', 'l', 'o'};


	//Dynamically creating a String object from a char[] array.
	String s3 = new String(arr);


	//Dynamically creating a String object by calling converting a StringBuilder to String object.
	String s4 = new StringBuilder("Hello").ToString();


	//Dynamically creating a String object by programmatically adding two String objects
	String s5 = s1 + s1;


	//Calling the static method ReferenceEquals(), to check for the equality of references.
	Console.WriteLine("Do s1 and s2 point to a same String object ? "+ (ReferenceEquals(s1, s2)));
	Console.WriteLine("Do s1 and s3 point to a same String object ? "+ (ReferenceEquals(s1, s3)));
	Console.WriteLine("Do s3 and s4 point to a same String object ? "+ (ReferenceEquals(s3, s4)));
	Console.WriteLine("Do s6 and s5 point to a same String object ? "+ (ReferenceEquals(s6, s5)));
}
}

Output is :

Do s1 and s2 point to a same String object ? True
Do s1 and s3 point to a same String object ? False
Do s3 and s4 point to a same String object ? False
Do s6 and s5 point to a same String object ? False

Program Analysis

• To avoid storing duplicate String objects on String intern pool heap memory, reference variables s1 and s2 refer to the same String object having the same value Hello on String intern pool table, whereas, the reference variable s3 and s4 point to different String objects created in a normal memory on Heap, as these objects were dynamically created, even though their value is the same i.e. Hello.



• In the first call to ReferenceEquals() method, it returns true on checking check if references s1 and s2 point to a similar object, which proves that both references, s1 and s2 are pointing to the same object on String intern pool and thus saving memory.



• In the second call to ReferenceEquals() method, it returns false when reference s1 was compared with s3, because, s1 points to a String object in String intern pool memory on the Heap while s3 points to a String object in normal Heap.



• In the third call to ReferenceEquals() method, it returns false when the reference s3 was compared with s4. Although both reference variable s3 and s4 point to the String objects with the same value Hello but as these objects were dynamically creating, hence, these objects are stored in normal heap memory where the String objects with duplicate values can be stored.



• Finally, in the fourth call to ReferenceEquals() method, it returns false when the reference s6 was compared with s5, because the reference variable s6 s1 points to a String object in String intern pool memory on the Heap while s6 points to a String object in normal Heap.

Please share this article -

< Prev

Next >

< C# String

C# Immutable String >

Advertisement