Type of values in .Net - Is string a separate type?

Question

We have Object and ValueType.... And String....

String is derived from object, but it is immutable. Is it considered a type of it's own as it doesn't behave like other objects? Is it the only object that has this immutable behaviour? Is it the runtime, compiler or library that defines this? And are there other cases like this in .Net?

Edit: Yes, I too create classes that isn't allowed to change after constructed; immutable objects. But isn't string more special than this?

Answer 1

String is a reference type (see here), but its behaviour is a bit special. As you say, it is immutable, and assignment copies the string content rather than the object's reference.

Regarding your question, of course string is a "separate" type. I am not sure what you mean by "separate", but each class and struct in .NET is a type of its own.

Answer 2

string is a reference type. There are plenty of other immutable types though, and you can create your own: just don't provide any members which change the state! Here's an example:

public class Int32Wrapper
{
    private readonly int value;
    public int Value { get { return value; } }

    public Int32Wrapper(int value)
    {
        this.value = value;
    }
}

Of course, string also overloads == and !=, overrides Equals and GetHashCode etc... all of which can be done in your own types too.

string does have some genuinely special properties though:

• It's the only reference type for which there's a literal format in IL (and in supporting languages)
• There are IL instructions which specifically use strings
• Other than arrays, string is the only type where the size of the object which varies by instance. (Other types vary depending on the CLR you're using, but for any one CLR, all instances of other types will have the same size - strings and arrays vary by content.)
• If you call new String(new char[0]) repeatedly, you'll get the same reference every time
• It interacts with the interop marshaller in magical ways :)

Answer 3

The author of the class determines whether instances of the class are immutable.

Here's another immutable class: (a reference type, not a value type)

public class Person
{
    private readonly string name;
    private readonly int age;

    public Person(string name, int age)
    {
        this.name = name;
        this.age = age.
    }

    public string Name
    {
        get { return name; }
    }

    public int Age
    {
        get { return age; }
    }
}