Pass by reference vs Pass by assignment? C# vs Python

Question

I am working concurrently in C# and in Python.

Is there a difference, in terms of what is being created in memory, between passing a reference type in C#, and passing (by assignment) in Python? It seems in either case, if the variable is changed* in the function, it is changed in the outside scope as well.

(*) of course in Python it must be mutable for this to occur. An immutable object cannot be changed - but that is another topic.

Are we basically just talking different terminology for the same process, or is there a conceptual difference to be learned here, in terms of the underlying mechanism in memory?

Answer 1

First, all arguments are passed by value by default in C#. This has nothing to do with the type being a reference type or a value type, both behave exactly the same way.

Now, the question is, what is a variable? A variable is a placeholder for a value, nothing more. When a variabe is passed by copy, a copy of the value is made.

And what is the value stored in a variable? Well, if the type of the variable is a reference type, the value is basically the memory address of the object its referencing. If its a value type, then the value is the objet itself.

So when you say:

It seems in either case, if the variable is changed* in the function, it is changed in the outside scope as well.

That is deeply wrong because you seem to me be mixing up the type of the argument with how it is passed along:

First example:

var a = new object();
Foo(a);
var isNull = ReferenceEquals(a, null); //false!

void Foo(object o) { o = null; }

Here, a refence typed variable a is passed by value, a copy is made and then inside Foo its reassigned to null. a doesn't care a copy is reasigned inside Foo, it will still point to the same object.

Things of course change if you pass the argument by reference:

var a = new object();
Foo(ref a);
var isNull = ReferenceEquals(a, null); //true!

void Foo(ref object o) { o = null; }

Now you are not making a copy of a named o, you are passing a itself with an alias named o.

Things behave exactly the same with value types:

var a = 1;
Foo(a);
var isNull = 1 == 0; //false!

void Foo(int i) { i = 0; }

And

var a = 1;
Foo(ref a);
var isNull = 1 == 0; //true!

void Foo(ref int i) { i = 0; }

The difference between value types and reference types when you pass it a long by value is due to what the value of the variable is. Like we said before, reference typed variables store the address, so even if you pass along a copy, the copy points to the same object, so any changes in the object are visible from both variables:

var ii = new List<int>();
Foo(ii);
var b = ii.Count == 1; //true!

void Foo(List<int> list) { list.Add(1); } 

But with value types, the value is the object itself, so you are passing along a copy of the object, and you are therefore modifying a copy:

struct MutableStruct
{
    public int I { get; set; }
}

var m = new mutableStruct();
Foo(m);
var b = m.I == 1; //false!

void Foo(MutableStruct mutableStruct) { mutableStruct.I = 1; } 

Does this make things clearer?