Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the memory allocation and resident pool of strings in C#". The content of the explanation in this article is simple and clear, and it is easy to learn and understand. let's study and learn "what is the memory allocation and resident pool of strings in C#"?

When I first started learning C #, I heard that CLR has a special memory management mechanism for String classes: sometimes, two objects of the String class are declared, but they point to the same instance. As follows:

String S1 = "Hello"; String S2 = "Hello"; / / the actual values of both S2 and S1 are "Hello" bool same = (object) S1 = = (object) S2; / / compare whether S1 and S2 refer to the same object instance / / so you can't write bool same = S1 = = S2. / / because the String class overloads the = = operator to compare the actual values contained in the String object

The same here will be assigned to true. This means that S1 and S2 really refer to the same String object. Of course, it should be noted that S1 and S2 are uniformly assigned to the same string "Hello", which is why this happens.

Now we have come to the preliminary conclusion that when there are multiple string variables that contain the same string actual value, CLR may not repeatedly allocate memory for them, but let them all point to the same string object instance. (I say "maybe" here because in some cases, multiple copies of the actual value of the same string do exist in memory at the same time. Please read on.)

We know that there are many special things about the string class, one of which is that it is "immutable". This shows that every time we operate on a String object (for example, using methods such as Trim,Replace), we do not actually modify the instance of the String object, but return a new instance of the String object as the result of the operation. Once an instance of the String object is generated, it will not be changed until death!

Based on features such as the String class, it makes sense for CLR to point variables that represent the actual values of the same string to the same String case. Because any modification made with any reference to the String instance does not actually affect the state of the instance, it does not affect the actual value of the string represented by all other references to the instance. By managing the memory allocation of the String class in this way, CLR can optimize memory usage and avoid redundant data in memory.

To implement this mechanism, CLR silently maintains a table called resident pool (Intern Pool). This table records references to all string instances declared using literals in the code. This means that strings declared literally will enter the resident pool, while strings declared in other ways will not, and will not automatically enjoy the benefits of CLR's mechanism to prevent string redundancy. This is the example I mentioned above that "in some cases, multiple copies of the actual value of the same string exist in memory at the same time." Look at this example:

StringBuilder sb = new StringBuilder (); sb.Append ("He"). Append ("llo"); string S1 = "Hello"; string S2 = sb.ToString (); bool same = (object) S1 = = (object) S2

At this time, same is not true, because although S2 represents the same string, S2 is not declared literally, and when CLR allocates memory for the return value of the sb.ToString () method, it does not go to the resident pool to check whether a string with the value of "Hello" already exists, so it naturally does not let S2 point to the object in the resident pool.

To enable programmers to force CLR to check the resident pool to avoid redundant string copies, the designer of the String class provides a class method called Intern. Here is an example of this method:

StringBuilder sb = new StringBuilder (); sb.Append ("He"). Append ("llo"); string S1 = "Hello"; string S2 = String.Intern (sb.ToString ()); bool same = (object) S1 = = (object) S2

All right, same is true again. The Intern method takes a string as a parameter, which checks in the resident pool for the existence of a string represented by the parameter. If it exists, a reference to the string in that resident pool is returned; otherwise, a new string representing the same value is added to the resident pool, and a reference to that string is returned. Note, however, that even if the Intern method finds a string of the same value in the resident pool, it won't save you a string memory allocation operation, because the string as a parameter has already been allocated once. The advantage of using the Intern method is that if the Intern method finds a string of the same value in the resident pool, although there are two copies of the string in memory (one is a parameter and the other is in the resident pool), over time, the copy referenced by the parameter will be garbage collected, so there is no redundancy for the string in memory.

When there is a method in your program that can create and return a long string according to different contexts, and it often returns the same string while the program is running, you may want to consider using the Intern method to improve memory utilization. It is also worth noting, however, that using the Intern method to keep a string alive in the resident pool also has a side effect: even if there are no other references to the string in the resident pool, the string is still not necessarily garbage collected. That is, even if the string in the resident pool is no longer useful, it may not be destroyed until the end of the CLR. You should also consider this special behavior when using the Intern method.

Thank you for your reading. the above is the content of "what is the memory allocation and resident pool of strings in C#". After the study of this article, I believe you have a deeper understanding of what is the memory allocation and resident pool of strings in C#, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.