C# .NET String object is really by reference?

Question

Hi,

I have being studying (newbie) .NET and I got some doubts.

Reading from a book examples I learnt that String are object then Reference Type.

So, I did this test and the result was different what I expected:

I'm really curious, is this an exception because "string" are special types?

class Program
{
    static void Main(string[] args)
    {
        SByte a = 0;
        Byte b = 0;
        Int16 c = 0;
        Int32 d = 0;
        Int64 e = 0;
        string s = "";
        Exception ex = new Exception();

        object[] types = { a, b, c, d, e, s, ex };

        // C#
        foreach (object o in types)
        {
            string type;
            if (o.GetType().IsValueType)
                type = "Value type";
            else
                type = "Reference Type";
            Console.WriteLine("{0}: {1}", o.GetType(), type);
        }

        // Test if change
        string str = "I'll never will change!";

        Program.changeMe(str);

        Console.WriteLine(str);
    }

    public static string changeMe(string param)
    {
        param = "I have changed you!!!";

        return ""; // no return for test
    }
}

Output:

System.SByte: Value type
System.Byte: Value type
System.Int16: Value type
System.Int32: Value type
System.Int64: Value type
System.String: Reference Type
System.Exception: Reference Type
I'll never will change!

Answer 1

The MSDN page can help explain why it is a reference type.

Because String is a collection of chars and inherits from various Collection base classes, it is a class, and therefore a reference type.

Answer 2

strings are indeed a special case. They are a reference type but behave like value types. This was done for "simplicity's sakes" by the .Net development team.

Great quote: It is a reference type It's a common misconception that string is a value type. That's because its immutability (see next point) makes it act sort of like a value type. It actually acts like a normal reference type. See my articles on parameter passing and memory for more details of the differences between value types and reference types.

From: http://www.yoda.arachsys.com/csharp/strings.html

Answer 3

Strings are references.

changeMe doesn't change the string, it just reassigns a local reference (pointer) within that function.

Now, if you passed the string as a ref arg, you can have more fun:

public static string changeMe(ref string param) {
    param = "I have changed you!!!";
    return ""; // no return for test
}

Answer 4

This has nothing to do with string being a value type or a reference type. The parameter of your changeMe method isn't marked ref, so if the method changes it, the caller will not see the changes.

Try that instead :

public static string changeMe(ref string param)
{
    param = "I have changed you!!!";

    return ""; // no return for test
}

Answer 5

You passed by value and made a copy of the reference. Pass it by reference it will change. Well, really a new string will be created and your reference will be to a new spot.

Answer 6

String is indeed a reference type. However, when your Main method calls changeMe(str), .NET passes a copy of the reference to str to changeMe in the param argument. changeMe then modifies this copy to refer to "I have changed you!!!", but the original str reference still points to "I will never change".

Being a reference type means that if you changed the state of the passed string, the caller would see those changes. (You can't do this to a string because strings are immutable, but you can do it to other reference types e.g. Control.) But reassigning a parameter doesn't change the value the caller passed in that parameter, even if that value is a reference.

Answer 7

The reason that Program.changeMe(str) does not cause str to be set to "I have changed you!!!" is that although string is a reference type, references are passed by value.

So param is a copy of the reference, it gets changed inside the scope of Program.changeMe(param) and then thrown away at the end of the method.

The reference str is only copied, not changed to reference "I have changed you!!!"

Answer 8

Yes, this seems strange. What's happening is that you're passing a reference to your string in the parameter, but you're passing it by value, i.e. you're creating a copy of the reference in the parameter. So when you reassign it within the scope of you're function, you're only changing the changeMe() method's local copy of your string reference.

Lots more info about this here: http://www.yoda.arachsys.com/csharp/parameters.html

Answer 9

If you are planning on changing the value of an argument to a method you should really use the "ref" or "out" keywords. Otherwise you risk making confusing methods that may or may not do what you intend. As other have pointed out you are changing the value of the string reference and not the instance of the object. To see how this works with other classes I have written a quick example

static void Main(string[] args)
{
    var str = "String";
    var obj = new MyObject() { Value = "Object" };

    Console.WriteLine(str); //String
    Console.WriteLine(obj); //Object

    ChangeMe(str);
    ChangeMe(obj);

    Console.WriteLine(str); //String
    Console.WriteLine(obj); //Object

    ChangeMeInner(obj);
    // this is where it can get confusing!!!
    Console.WriteLine(obj); //Inner 

    ChangeMe(ref str);
    ChangeMe(ref obj); 

    Console.WriteLine(str); // Changed
    Console.WriteLine(obj); // Changed

    Console.Read();
}
class MyObject
{
    public string Value { get; set; }
    public override string ToString()
    {
        return Value;
    }
}
static void ChangeMe(MyObject input)
{
    input = new MyObject() { Value = "Changed" };
}
static void ChangeMeInner(MyObject input)
{
    input.Value = "Inner";
}
static void ChangeMe(string input)
{
    input = "Changed";
}
static void ChangeMe(ref MyObject input)
{
    input = new MyObject() { Value = "Changed" };
}
static void ChangeMe(ref string input)
{
    input = "Changed";
}

Answer 10

For all other reference types, passing it using byval semantics (without ref or out ), means you cannot change which object on the heap the callers copy points to, it does not mean you can't change the contents of the object on the heap that the variable points to. Because strings are immutable, they are truly an exception, they behave like a value type in this respect, even though they are a reference type, but this is done by exceptional additional coding in the CLR.