What does assigning a static field to an instance field not point both at the same object

Question

In this fiddle, we are assigning a static field to an instance field. When we change the static one, the instance one still has the initial value. Why is that? We thought that both should be referring to the same object but it seems that they're not.

using System;

public class Program
{
    public static string StaticString;
    public string InstanceString;

    public static void Main()
    {
        Program.StaticString = "foo";

        var p = new Program();
        p.InstanceString = Program.StaticString;

        Program.StaticString = "bar";

        Console.WriteLine(p.InstanceString);
    }
}

We were really expecting this to print bar but it printed foo.

Answer 1

In this fiddle, we are assigning a static field to an instance field.

Right. That copies the current value of the static field to the instance field. It doesn't tie the variables together forever - it just copies the current value.

When we change the static one, the instance one still has the initial value.

Yes, because you've just changed the value of the static field - why would that change the value of the instance field? They're independent variables - they just happened to hold the same value at one point. Importantly, you haven't made any change to the string object that the value of the instance field refers to. (And indeed you can't make changes to the string object, because strings are immutable.)

I view variables as being like pieces of paper with the values written on them. When the variable is a reference type, the value on the piece of paper is just a way of navigating to an object - like a street address. But copying one variable to another is always just a matter of copying what's written on one piece of paper onto another. So for example, suppose I have:

House x = new House();
House y = x;
x.DoorColor = Black;
x = null;
Console.WriteLine(y.DoorColor);

That's like:

• Creating a piece of paper called x, and writing a street address on it
• Copying what's written on piece of paper x onto a piece of paper called y
• Going to the house whose address is written on piece of paper x and painting the door black
• Rubbing out the address written on piece of paper x
• Going to the house whose address is written on piece of paper y and reporting the colour of the door

That last step would report that the door is black, right? Rubbing out the value written on piece of paper x doesn't change either what's written on piece of paper y, or anything about the house.

This isn't quite the same set of steps as in your code, but hopefully it will shed more light on it...

Answer 2

When you assign StaticString to instance string in the statement below

p.InstanceString = Program.StaticString;

The runtime will actually point InstanceString to the string "foo" not to StaticString so when you assign StaticString value bar, runtime will create a string "bar" and point the static string to it. Note Instance string is still point to memory location where we have foo.

I think it will be more easy to understand with the help of a diagram. That shows how StaticString and InstanceString are actually point to values.

Answer 3

You print p.InstanceStringwhich two lines before you set to foo. So it should print foo as it does.

Answer 4

I confused changing the value of a variable with mutating the object at which a reference points.

The fact that strings are immutable of course complicates matters. b = "foo" is really the same as b = new string("foo".ToCharArray()). We're creating a new object and assigning its reference to b. We are not mutating the existing object.

Here is an example that clarifies my mistake.

using System;
using System.Text;

public class Program
{
    public static StringBuilder StaticString;
    public StringBuilder InstanceString;

    public static void Main()
    {
        Program.StaticString = new StringBuilder("foo");

        var p = new Program();
        p.InstanceString = Program.StaticString;

        Console.WriteLine("Mutating the object at which a value points:");
        Program.StaticString.Append("bar");
        Console.WriteLine(p.InstanceString);
        Console.WriteLine(Program.StaticString);

        Console.WriteLine("\nChanging the value of a variable:");
        Program.StaticString = new StringBuilder("raboof");
        Console.WriteLine(p.InstanceString);
        Console.WriteLine(Program.StaticString);
    }
}

Output

Mutating the object at which a value points:
foobar
foobar

Changing the value of a variable:
foobar
raboof

Answer 5

Part of the explanation is that static members belong to the Type not to the instantiation of an object. The property referenced in the Console.WriteLine() is the instance property. But the property that was changed was the Type's property.

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members#:~:text=It%20belongs%20to%20the%20type%2C%20not%20to%20instances%20of%20the%20type.