We all know that the way .net handles a string is not optimal and uses up lot of memory, thought there are reason to do like this. But if we have more string objects or comparison inside our assembly then in this case surely it is going to be a performance hit. But here what really happens is framework itself take cares at least some part of it using the concept of Sting Interning.
So what is String interning in Microsoft .net. How does it helps the C# code Execution..
It seems that there is an internal hashtable maintained with the actual string value and it’s reference to managed heap. And two methods help us to handle this hash table
This is the “Intern” and “IsInterned” methods which is part of string manipulation class.
By default when an assembly is loaded all common used strings in the assembly (including manifest and metadata) are interned and stored to this hash table . And whenever this is needed , “IsInterned” finds out whether it is already interned and if not the first method interns it, thereby ensuring that string objects are not duplicated due to it’s immutability while doing a comparison to get the exact string we need. (“IsInterned” sends the hashed value to fetch from the internal hashtable )
To simply for your better understanding let us see the below example
string str1 = test;
string str2 = test;
In the above example statement line number 3 returns false, while the next stament returns true thought we are using the exactly same statement. Once a string is interned, the internal hash table stores reference of that string. and whenever that string is needed again "IsInterned" method takes the string as argument and fetch the actual reference for that string from the above said internal hashTable
This procedure seems to be widely used to parse the metadata and manifest of the assembly, otherwise obviously there should be a performance hit when we use reflection.
But the other pointed noted here is that frequent hashing and lookup could also cause a performance hit when it is not really required so there is a way to control this too by applying the “CompilerRelaxationattribute” with “NostringInterning”. But this is again changeable by the compiler if decides that the more better way to go will be with string interning.
Was this post helpful to you ? !!.. Then please like this in any of the social media below !.
Let it be useful for others too..