Two different "strings" are the same object instance?

Question

The code is pretty self explanatory. I expected when I made a1 and b1 that I was creating two different string instances that contain the same text. So I figure a1 == b1 would be true but object.ReferenceEquals(a1,b1) would be false, but it isn't. Why?

//make two seemingly different string instances
string a1 = "test";
string b1 = "test";         
Console.WriteLine(object.ReferenceEquals(a1, b1)); // prints True. why?

//explicitly "recreating" b2
string a2 = "test";
string b2 = "tes";
b2 += "t";    
Console.WriteLine(object.ReferenceEquals(a2, b2)); // prints False

//explicitly using new string constructor
string a3 = new string("test".ToCharArray());
string b3 = new string("test".ToCharArray());    
Console.WriteLine(object.ReferenceEquals(a3, b3)); // prints False

@pst You are right ! and interninig is not part of any answer — V4Vendetta, May 28 '12 at 05:07
possible duplicate of [Strange string literal comparison](http://stackoverflow.com/questions/8317054/strange-string-literal-comparison) — V4Vendetta, May 28 '12 at 05:07

score 20 · Accepted Answer · answered May 28 '12 at 04:48

20

Literal string objects are coalesced into single instances by the compiler. This is actually required by the specification:

Each string literal does not necessarily result in a new string instance. When two or more string literals that are equivalent according to the string equality operator (Section 7.9.7) appear in the same assembly, these string literals refer to the same string instance.

answered May 28 '12 at 04:48

Greg Hewgill

951,095
183
1,149
1,285

1

see V4Vendetta's link above. Is this happening by the compiler or the CLR? – jb. May 28 '12 at 05:12

Talha · Answer 2 · 2012-05-28T05:14:08.320

The compiler is optimized to that the if string literals are equal with "==" operator than it does not need to create a new instance and both refer to the same instance... So, that's why your first part of question answered True.

Although string is a reference type, the equality operators (== and !=) are defined to compare the values of string objects, not references. This makes testing for string equality more intuitive. For example:

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine((object)a == (object)b);

This displays "True" and then "False" because the content of the strings are equivalent, but a and b do not refer to the same string instance.

The + operator concatenates strings:

string a = "good " + "morning";

This creates a string object that contains "good morning".

Strings are immutable--the contents of a string object cannot be changed after the object is created, although the syntax makes it appear as if you can do this. For example, when you write this code, the compiler actually creates a new string object to hold the new sequence of characters, and that new object is assigned to b. The string "h" is then eligible for garbage collection.

string b = "h";
b += "ello";

for more reference check this on msdn and this

this is not really related to my question. – jb. May 28 '12 at 05:00 — jb., May 28 '12 at 05:00

score 2 · Answer 3 · answered May 28 '12 at 04:45

2

Compiler optimization. Simple as that.

answered May 28 '12 at 04:45

Enigmativity

113,464
11
89
172

Two different "strings" are the same object instance?

3 Answers3

Linked

Related