3

string is an reference type (similar to object). Why the diff behavior in the following scenario - when creating an instance of string and object?

I understand the concept of immutability etc in string but that is to do with value assigned to string (which wont change). My question is more to do with why s2 is creating another complete instance whereas if i had done with object it doesnt do that?

enter image description here

Example of string

class Program
{
    static void Main(string[] args)
    {
        string s1 = "Hello";
        string s2 = s1;

        s1 = null;
        Console.WriteLine("s1 = " + s1);
        Console.WriteLine("s2 = " + s2);
        Console.ReadLine();
    }
}

Output: s2 still prints "Hello"

Example of object

class Program
{
    static void Main(string[] args)
    {
        Name s1 = new Name();
        s1.id = 5;
        Name s2 = s1;

        s1 = null;
        Console.WriteLine("s1 = " + s1.id);
        Console.WriteLine("s2 = " + s2.id);
        Console.ReadLine();
    }
}

public class Name
{
    public int id { get; set; }
}

Output: Both s1 and s2 are null;

Improve this question
2
  • 8
    In the second code snippet, s2 is not null but you can't see it because s1.id throws NullReferenceException. Remove Console.WriteLine("s1 = " + s1.id); and you will see 5 in the Console. Commented Feb 28, 2014 at 20:19
  • 3
    When you say something like s1 = null you are only setting that variable s1 to null, you are not changing anything that s1 used to refer to. And as @Selman22 said, if you remove the null ref exception, you'll see they both behave the same. Also, try actually running the code first. Commented Feb 28, 2014 at 20:23

3 Answers 3

Reset to default
7

In your second code snippet, s2 is not null but you can't see it because s1.id throws NullReferenceException and you didn't handle it.So your program never reaches the second line.Remove it and you will see 5 in the Console.After s1 = null;, s2 doesn't change.It is still pointing the s1's old Location in the memory.

Also if you don't want to remove the first line alternatively you can put it inside of try/catch block:

try
{
    Console.WriteLine("s1 = " + s1.id);
}
catch (Exception ex)
{
     Console.WriteLine(ex.Message);
}
 Console.WriteLine("s2 = " + s2.id);

And you can see 5 in the Console and the exception message.But this is completely unnecessary; it will definitely throw exception because s1 is null.So, as a result: there is no difference between string and other reference types except immutability

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

6

First of all, I'm sure you realize you are going to get a lot of NullReferenceException with that code you've got there. Secondly, the string class is a fun and special object which you can mentally think of as a primitive data type. Let me just say though, System.String is not a primitive type.... but you can think about it like it is for general purposes.

I have drawn some diagrams that may better display what is going on in each of the examples you gave.

When you

string s1 = "Hello";
string s2 = s1;

An object named s1 of type string is created which points to a memory space that holds the value "Hello". Then a new object of type string named s2 is created and the value of "Hello" from s1 is copied to another memory space and addressed by s2. This results in your memory looking as it does below.

enter image description here

Now, when you

s1 = null;

You have set the reference of s1 to point to the null pointer, which leaves that memory with the value of "Hello" to float around until the garbage collector comes around and removes it. At this point s1 is still pointing to the value that was copied earlier.

enter image description here

Now lets look at how this differs from a normal object.

When you 

Name s1 = new Name();
s1.id = 5;
Name s2 = s1;

A memory space called s1 is created which points to a newly allocated space in memory the large enough to hold the memory of a Name object.

Then you pointed to the memory space addressed in s1 and changed its Property called id to be 5.

Then you created a new memory space called s2 which copies the value of the address to the allocated memory mentioned above. So now s1 and s2 point to the same object in memory. This results in your memory looking as it does below.

enter image description here

Note: That at this point, if you were to change the value of id it would change for both s1 and s2, and if that was nullable type you were using for id, and you set it to be null, the change would be reflected in both s1 and s2.

Now if you were to 

s1 = null;

as you did in your post. s1 would change its address to point to the null pointer, and s2 would continue to be looking at the same space in memory. Which results in what you see below.

enter image description here

Edit: To provide further explanation on why strings seem to behave like primitives and not like objects. I don't know, however I will speculate. My guess is that it was designed this way because developers want to use string as if it were a primitive. I will say that it is so nice to not have to worry about stray references to my string, or having to clone it before I make changes to it. However Microsoft could not make string a primitive type because strings are huge. The max length of a string is the maximum value of an Int32. And every letter is a char which is a Int16, so that is somewhere around 2 gigs I believe (don't quote my math). This means that strings are too big to store on the stack which is only 1MB. Thus strings have to be objects and placed on the heap.

If you are unaware of the differences between the stack and the heap, I do recommend looking it up, it is good to know how memory is handled, while in C# all that dirty work is done for you, if you decide to move to something like C++ you'll find yourself managing that on your own (not super fun).

So in short I suppose it is because we want to use strings like primitives, but they are implemented as objects because of the limitations of the stack.

Improve this answer

4 Comments

Excellent Explanation with diagrams. Precisely what I was looking for. Just one question is even though strings are reference types - why do s1=s2 behave differently than o1=o2 ? Any particular reason why are they different
@Patrick You are certainly welcome, I have also edited my post to give my best answer to your question.
A good thing to look up is the term Immutable. Strings are Immutable Objects, so if you attempt to modify one it gives you a new copy of the modified object back instead and leaves the original alone. This is what makes strings behave "like a primitive" because all primitives are immutable. In .NET 4.5 you can get the System.Collections.Immutable namespace via NuGet, this lets you have objects like lists and dictionaries that behave that way too (modifying returns a new copy).
Indeed Immutable would be the thing to research, I didn't mention it because he stated in the OP he understood Immutables. However, that Immutable namespace looks pretty nice, thanks!
1

Your variables are reference variables because they are declared with the String type. Your code is doing this:

  1. Retrieve a reference to the string Hello
  2. Assign that reference to the string variable s1
  3. Create a new variable s2 and assign its reference to the reference in s1
  4. Assign s1's reference to null

Throughout this process, the string Hello is still in memory and s2 still references it. s1 and s2 are two different containers; they can each hold their own reference. Whether the reference is the same is immaterial.

I'll try a metaphor:

You (s2) and I (s1) are sitting in a room looking at a vase (Hello) on a table. This is akin to s1 and s2 pointing to the same string in memory, as they do after the second line in your Main method. Now, I get up and leave the room (s1 = null;) You're still looking at the vase, aren't you? We are two different people (variables) with the capacity to look at different things.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.