Will these variables be garbage-collected?

Question

I was practicing my coding chops today and solving the "remove all elements of a certain value from a linked list" problem today. The solution I came up with was

public void RemoveAll ( T val ) 
{
    if(_root == null)
       return;

    if(_root.Value == val)
    {
       _root = _root.Next;
       RemoveAll(val);
    }    

    Node last = _root, 
          cur = _root.Next;  
    while(cur != null)
    {
       if(cur.Value == val)
           last.Next = cur.Next;
       else
           last = cur;
       cur = cur.Next;
    }
}

and here's my question:

When cur.Value == val I'm doing something like changing the list from

A -> B -> C

to

A -> C

Will the compiler or run-time environment see that B is no longer in use and dispose of it? Or should I do that explicitely?

I have a second question which is whether a call stack blows up for recursive void methods. As you see here, there is a chance of the method calling itself. But since it's a method that doesn't return a value, can't the run-time environment just wipe the data about the last call? There is no reason for it to remain in memory (right?).

How would you do that explicitly? `B=null` or what? But then B just points to null and the object is still in memory. — Thomas Weller, Jul 17 '16 at 19:27
Sure, it will be collected, not disposed. And you will blow the stack sooner or later, consider while (_root != null && _root.Value == val) _root = _root.Next; — Hans Passant, Jul 17 '16 at 19:54

score 1 · Accepted Answer · edited May 23 '17 at 11:44

Will the compiler or run-time environment see that B is no longer in use and dispose of it? Or should I do that explicitely?

GC, when it runs, will realize there is no active references to that object and clean it up (assuming nobody else holds a reference to that object). You can't manually clean a single object in .NET. In .NET memory is managed and cleaned by Garbage Collector as needed.

I have a second question which is whether a call stack blows up for recursive void methods. As you see here, there is a chance of the method calling itself. But since it's a method that doesn't return a value, can't the run-time environment just wipe the data about the last call? There is no reason for it to remain in memory (right?).

You're describing tail recursion. C# compiler will not generate tail-recursive calls. Becaus eof that it's possible you're going to run into StackOverflowException if your recursion is too deep.

That limitation is not a CLR limitation - .NET Framework does support tail calls. It's C# compiler which doesn't emit tail IL opcode. You can get Tail Recursion working in .NET Framework when generating IL by hand or when using F#, which generates tail calls whenever appropriate.

See https://stackoverflow.com/a/15865150/1163867 for more details.

PS. I think your code has a bug. Looks like you should return early after recursive call into RemoveAll:

if(_root.Value == val)
{
   _root = _root.Next;
   RemoveAll(val);
   return;
}

Per your referenced link, while the C# compiler doesn't emit the `tail` opcode, the JIT compiler can still detect and optimize for tail recursion. Using C# doesn't mean you'll never see tail recursion optimized away, just that the C# compiler itself won't help with the optimization. The bigger issue here is the lack of the `return;` statement after the recursive call; IMHO your answer should be emphatic about this, so it's clear that the entire discussion about tail recursion is moot unless the method returns immediately after its recursive call. — Peter Duniho, Jul 17 '16 at 20:52

Will these variables be garbage-collected?

1 Answers1