Cannot set an object to null inside a method [duplicate]

Answer 1

You're not actually passing parent to node by reference here. This means a value of parent is being copied to node in the test function. In this case, that value simply points to a Node object.

node.key = 1111 works as you expect because it uses that value to access the same object which parent is also pointing to. i.e. both node and parent contain values pointing to the same locations in memory. As such, both can observe the modification.

However when you say node = null, you're assigning a new value to the node variable inside the test function. This means you're changing the pointer stored as the value in that particular variable to null, which in no way modifies the value for parent - that's still pointing to the Node object.

Mind my amateur ASCII art, but I think it's kind of like this:

    Test.test(parent);       

         <node object>
           ^       ^ 
           .           .
           .               .
           .                   .
    +------.----+                   .  +-----------+
    |      .    |                       .          |
    |      .    |    (-> copied to)    |    .      |
    |  parent   |                      |    node   |
    +-----------+                      +-----------+
    Program.Main scope                 Test.test scope


    node = null;       

         <node object>
           ^ 
           .
           .
           .
    +------.----+                      +-----------+
    |      .    |                      |           |
    |      .    |                      |           |
    |  parent   |                      | node=null |
    +-----------+                      +-----------+
    Program.Main scope                 Test.test scope

Whereas if you happened to use public static void test(ref Node node) you could think of it more like this:

    Test.test(parent);       

         <node object>
           ^ 
           .
           .
           .
    +------.----+                      +-----------+
    |  parent <============================ node   |
    |           |                      |           |
    |           |                      |           |
    +-----------+                      +-----------+
    Program.Main scope                 Test.test scope


    node = null;       

         <node object>
            Lonely


    +-----------+                      +-----------+
    |  parent <============================ node   |
    |     =     |                      |           |
    |    null   |                      |           |
    +-----------+                      +-----------+
    Program.Main scope                 Test.test scope

Answer 2

This is because parameters are passed by value, so in your test method, a copy of parent variable has been created, you are just setting the copy of variable to null. Though you still can manipulate the object because the copy variable is pointing to the object in the heap.

class Program
{
    static void Main(string[] args)
    {
        Foo foo = new Foo();
        SetNull(foo);

        Console.WriteLine(foo.ID);// print 2
    }

    private static void SetNull(Foo foo)
    {
        foo.ID = 2;
        foo = null;
    }
}


class Foo
{
    public int ID { get; set; }
}

Answer 3

Use the ref keyword:

public static void Test(ref Node node) {
    node = null;
}

// Usage

Node parent = ...
Test( ref parent );
Assert( parent == null );

Answer 4

Rewrite this method here with a different variable name for the purpose of example:

public static void test(Node PassedNode)
    {
       PassedNode.key = 1111;
       PassedNode = null;
    }

PassedNode inside the test method points to the Node parent = new Node(); object that was initially passed in and so when you modify the values of the properties of PassedNode inside the test method, then these changes will affect the object in the Main method because there's only one object. When you write PassedNode = null then PassedNode in the test method doesn't point to the original object anymore and that's all that happens: the object itself still lives on. If you want to clear the original reference, then you need to do that in the calling method.