Well, a classic Delphi-string is very smart.
It keeps a negative offset from char of string[0 -> -3].
That keeps info length of the actual string, and even back further, the
capacity of the string. Even -back there are the number of references to it.

As Microsoft has licenced pretty much every patent Borland ever filed, I
don't see why the runtime would skip this smart way to handle strings in the
runtime.

Strings may not be as 'immutable' as they may seem, but rather follow the
copy-on-write-scheme that ObjectPascal more or less intruduced.

But that does not matter. The C# specs clearly says that strings are
immutable. Code that way!
..  and let the JITter/Runtime take care of the rest. =)

Happy Coding
- Michael Starberg

Amen!

As for using classes/structs I think I have found a pretty good way on how
to attack the problem/difference.

- Michael Starberg

No it doesn't. String interning has nothing to do with this.

To prove that:
using System;

class Test
{    
   static void Main()
   {
       string s1 = new string(new char[]{'a','a','a'});
       string s2 = s1.Replace("b", "c");
       
       Console.WriteLine(object.ReferenceEquals(s1, s2));
       Console.WriteLine(string.IsInterned(s1)==null);
   }
}

This prints "True" twice, which shows that s1 *isn't* interned.

Actually it seems to work even if the strings aren't interned, suggesting it
is instead a "I didn't update anything, return the original reference"
optimisation; since it is an internal-call, it is hard to check...

Anyways, s1 and s2 come out as ref-equals, even though it isn't interned.

Marc

           string s0 = "foobar"; // expect this to be interned
           Console.WriteLine("s0: {0}", s0);
           Console.WriteLine("s0 interned: {0}", (string.IsInterned(s0) !=
null));
           string s1 = new string('a',5); // don't expect this to be
interned
           Console.WriteLine("s1: {0}", s1);
           Console.WriteLine("s1 interned: {0}", (string.IsInterned(s1) !=
null));
           string s2 = s1.Replace("b", "c");
           Console.WriteLine("s2: {0}", s1);
           Console.WriteLine("ref-equals: {0}", object.ReferenceEquals(s1,
s2));
           Console.WriteLine("s1 interned: {0}", (string.IsInterned(s1) !=
null));
           Console.WriteLine("s2 interned: {0}", (string.IsInterned(s2) !=
null));