passing an object to a function in a the same class to initialize the values, but not by reference

Question

I'm looking for some clarification and confirmation that this is indeed doing nothing.

Say I have an object

public class Person
{
    public string Name { get; set; }
}

and I am going to use this object and for some reason it has to be initialized, which should happen in the constructor but for this example its going to happen in a call to an initialize function

public class myClass
{
    private void doingSomething()
    {
        Person p = new Person();
        Initialize(p);
    }

    private void Initialize(Person person)
    {
        person.Name = "";
    }
}

This is just a waste correct. If I really wanted to change the values doesn't it have to be passed using ref, out, or returning a different Person?

If I'm wrong i'd appreciate an explanation. I found this while looking through some old code and feel confused because I can't believe it's there.

Answer 1

doesn't it have to be passed using ref, out, or returning a different Person?

Nope.

Consider the stack and the heap. For primitive values (integers are a good example) they just exist on the stack. When they're passed to a method, a copy of them is supplied to that next frame on the stack.

For reference types however, what gets passed to the next frame on the stack? The reference does. Consider it like a "pointer". A simple value which indicates where in the heap the actual object is.

This is only ever invoked once in your example:

new Person()

So only one instance of Person exists in memory. The "pointer" to that instance was copied into the stack frame. If you change the value of the "pointer" itself:

private void Initialize(Person person)
{
    person = new Person();
}

Then no effect would come to the original instance. But that's not what happened. The "pointer" was followed and the instance was changed:

person.Name = "";

The variable person was unaffected by this statement. No operation was made to modify it. But a property on the object in memory that the person variable points to was modified. That change is visible anywhere a reference to that object exists, inside or outside the method, anywhere in the system.