String Comparisions
Here's how String Interning for System::String instances and literal strings in your code relates to string comparisions on MC++.

If you've been trying to use the == operator to compare managed string instances and have been getting inconsisten results, then string literals are probably involved. This is not really tricky, but the fact that the problem is that you're seeing how string Interning works is not obvious.

Consider this simple code:

String* s1 = S"This is a String";
String* s2 = S"This is a String";

// s1==s2 && s1.Equals(s2)==true
Console::WriteLine(S"s1==s2 - {0}", __box(s1==s2)); 
Console::WriteLine(S"s1.Equals(s2) - {0}",  __box(s1->Equals(s2)));

The code above should print true for both cases. However, now add this:

String* s3 = "This is a String";
	
// s1!=s3 && s1.Equals(s3)==true
Console::WriteLine(S"s1==s3 - {0}", __box(s1==s3)); 
Console::WriteLine(S"s1.Equals(s3) - {0}",  __box(s1->Equals(s3)));

Now it prints false and true. So what's going on?

The problem is you're expecting your use of == to imply the use of the managed equality operator (also known as op_Equality()), just as similar-looking C# code would do. However, that's not the case. Since String is a reference type you're accessing through pointers, standard C++ syntax demands that a pointer comparision is done, so what you're really doing is comparing the two pointer values for equality.

So why does it work in the first case? The reason is that you're using the S prefix on your string literals. That tells the compiler you want this as a managed string, so the compiler will use the String Interning and String Pooling features of the .NET runtime (see Jeffrey Richter's "Progamming the .NET Framework" for more details on this), and that means that you're not actually creating two String instances with the same value, but rather retrieving pointers to the same String instance. That's why the pointer value comparision returns true!. BTW, this is all possible in great part thanks to the immutability of the String objects.

The second case does not do this, however, as you're not using the S prefix on the string literal. In that case, the compiler will generate code that will call one of String's constructors taking an unmanaged array of single-byte characters, which doesn't use interning, nor pooling, so the string is rather treated as a dynamically created string whose value is not known until runtime, if you see what I mean.

The lesson? Don't relly on the use of operator==; instead, use the Equals() method of the String class explicitly. That's the correct choice in this case, and in all cases where managed reference types are involved, since MC++ doesn't support overloaded managed operators on them.