Why String is Value type although it is a class not a struct?

Question

Take the following example:

string me = "Ibraheem";
string copy = me;
me = "Empty";
Console.WriteLine(me);
Console.WriteLine(copy);

The output is:

Empty
Ibraheem

Since it is class type (i.e. not a struct), String copy should also contain Empty because the = operator in C# assigns reference of objects rather than the object itself (as in C++)??

Poaceous

The = does not change the object, but rather changes the reference to point at a different object. Your code has two references: me and copy, and since you're only assigning a different object to me, copy still points at the old object. – Aleece

Answer 1

System.String is not a value type. It exhibits some behaviors that are similar to value types, but the behavior you have come across is not one of them. Consider the following code.

class Foo 
{ 
     public string SomeProperty { get; private set; }
     public Foo(string bar) { SomeProperty = bar } 
}

Foo someOtherFoo = new Foo("B");
Foo foo = someOtherFoo;
someOtherFoo = new Foo("C");

If you checked the output of foo.SomeProperty, do you expect it to be the same as someOtherFoo.SomeProperty? If so, you have a flawed understanding of the language.

In your example, you have assigned a string a value. That's it. It has nothing to do with value types, reference types, classes or structs. It's simple assignment, and it's true whether you're talking about strings, longs, or Foos. Your variables temporarily contained the same value (a reference to the string "Ibraheem"), but then you reassigned one of them. Those variables were not inextricably linked for all time, they just held something temporarily in common.

Cordell

Ah, but your example uses strings internally, so of course it’s the same as in OP’s code. ;-) – Drawtube

If he's confused by this example, we're all toast. – Cordell

@Anthony so that I have assined to me another value without using the new keyword?? – Poaceous

@Mr.DDD, assignment is not about new. It's simply about x = y. y could be something new, it could be something that already exists. Whatever it is, it's assigned to x. In your snippet, the value of me is the reference to "Ibraheem". You copy that value (which is a reference) to copy. But then you overwrite the value of me with a reference to another string via the assignment operator. copy still holds the original reference, because you did nothing to cause copy to change. – Cordell

@Mr. DDD: A variable in C# is a section of memory set aside to store a value. Value types (structs and primitive types) are stored directly in the variable, whereas reference types are stored elsewhere and a reference to that location is the value in the variable. When you assign a value to a variable (whether that value is a reference, a primitive type, or a struct), it does not affect any other memory locations. In your example, copy and me are two completely different variables (and thus memory locations) that happen to have the same value at some point. – Politics

@Mr.DDD if the lack of the new keyword is confusing you, consider that "Empty" can be thought of as a shortcut for new string("Empty") (conceptually, new string("Empty") won't actually compile because that's not one of the constructors for string) – Phenformin

#Anthony Pegram if i pass a non-value type to a method (say a DateTime) and inside the method i modify (say AddSecond(2) ) it, then the non-value type change everywhere. But since each stirng modificatoin will lead to a new instance be created that doen't hold for them. In such a way their behaviour are very close to value type (eg an integer, that also doesn't change everywhere), i would point out this because IMHO is that the root of all evlis – Keilakeily

@Skary, you are incorrect on one important thing, DateTime is a value type. And if you pass one to a method and call AddSeconds, not only is the argument not modified, but neither is the parameter. Anytime you add seconds to a DateTime, you have to capture the result via reassignment. String has the same behavior, but that does not make it a value type or anything like a value type, it simply makes it immutable. – Cordell

Answer 2

While the accepted answer addresses this (as do some others), I wanted to give an answer dedicated to what it seems like you're actually asking, which is about the semantics of variable assignment.

Variables in C# are simply pieces of memory that are set aside to hold a single value. It's important to note that there's no such thing as a "value variable" and a "reference variable", because variables only hold values.

The distinction between "value" and "reference" comes with the type. A Value Type (VT) means that the entire piece of data is stored within the variable.

If I have an integer variable named abc that holds the value 100, then that means that I have a four-byte block of memory within my application that stores the literal value 100 inside it. This is because int is a value type, and thus all of the data is stored within the variable.

On the other hand, if I have a string variable named foo that holds the value "Adam", then there are two actual memory locations involved. The first is the piece of memory that stores the actual characters "Adam", as well as other information about my string (its length, etc.). A reference to this location is then stored within my variable. References are very similar to pointers in C/C++; while they are not the same, the analogy is sufficient for this explanation.

So, to sum it up, the value for a reference type is a reference to another location in memory, where the value for a value type is the data itself.

When you assign something to a variable, all you're changing is that variable's value. If I have this:

string str1 = "foo";
string str2 = str1;

Then I have two string variables that hold the same value (in this case, they each hold a reference to the same string, "foo".) If then do this:

str1 = "bar";

Then I have changed the value of str1 to a reference to the string "bar". This doesn't change str2 at all, since its value is still a reference to the string "foo".

Politics

+1 i prefer this to be the answer as it actually clears the conceptual confusion for a c# beginner like myself (2 yrs c#) – Nesselrode

Good explanation. – Anabatic

Does this have to do with the immutability of strings? Cause in the case of any other class, one would have to create a designated Copy (clone) method to completely disassociate the copy from the original. – Swordcraft

Answer 3

It isn't a value type. When you use a string literal, its actually a reference stored when compiled. So when you assign a string, you are basically changing the pointer like in C++.

Durman

so why any other class is copied whit reference? – Poaceous

@Mr.DDD It isn’t. All classes behave this way. When you re-assign a reference, only this reference changes, nothing else. – Drawtube

@Adam: (Nice name, by the way). Immutability, interning, etc. are all unrelated to the question the OP is asking; the fact that it's a string is a red herring. The OP is just confused by what assignment does, not by any particular behavior belonging to string. – Politics

Answer 4

Strings behave the same as any other class. Consider:

class Test {
    public int SomeValue { get; set; }
    public Test(int someValue) { this.SomeValue = someValue; }
}

Test x = new Test(42);
Test y = x;
x = new Test(23);
Console.WriteLine(x.SomeValue + " " + y.SomeValue);

Output:

23 42

– exactly the same behaviour as in your string example.

Drawtube

Answer 5

What your example shows is the classic behavior of a reference type which string is.

Whipstitch

To be clear, his example shows the classic behavior of all assignments, reference type or not. – Politics

Answer 6

string copy = me; means that copy reference will point to same memory location where me is pointing.

Later me can point to other memory location but it won't affect copy.

Tapis

Answer 7

Your code would do the same if you used value types as well. Consider using integers:

int me = 1;
int copy = me;
me = 2;
Console.WriteLine(me);
Console.WriteLine(copy);

This will print out the following:

2
1

Trueblood

Answer 8

While the other answers said exactly what the solution to your answer was, to get a better fundamental understanding of why you will want to have a read up on heap and stack memory allocation and when data is removed from memory by the garbage collector.

Here is a good page that describes the stack and heap memory and the garbage collector. At the bottom of the article there are links to the other parts of the explanation: http://www.c-sharpcorner.com/UploadFile/rmcochran/csharp_memory01122006130034PM/csharp_memory.aspx?ArticleID=9adb0e3c-b3f6-40b5-98b5-413b6d348b91

Hopefully this should give you a better understanding of why

Analyse

I disagree; the semantics of heap vs. stack allocation (and certainly garbage collection!) are ancillary to his question and will only serve to further confuse someone who is obviously just getting started with the language. – Politics

@Adam I disagree too :) I have huge projects with C# and written thousands of code lines with, since I write C# for 3 years so far! – Poaceous

@Stuart your site is very good. I would select it as the best answer if you DIDN'T answer it while there is a chosen answer ALREADY. Please don't answer on questions having best answers. – Poaceous

@Mr.DDD: I apologize if my comment offended; it was just an assumption based on the subject of the question. It's perfectly acceptable, though, to answer a question with an accepted answer. If you think this one fits better, you can deselect the current answer and select this one. – Politics

@ِِAdam Thanks. I know I can deselect, but I hate (Ctrl + Z) Undo – Poaceous

Answer 9

Answering the original question:

Strings in C# are the reference type with value type semantics.

They are being stored on the heap because storing them on the stack might be unsafe due to the limited size of the stack.

Stretcherbearer