Question

May I know if the “objectToBeDisposed” will be disposed if its reference are kept by the “useDisposableObject”?

using(IDisposable objectToBeDisposed = new ObjectImplementedIDisposable  ()){
ChildObject useDisposableObject = new ChildObject(objectToBeDisposed);
.... doing stuff with useDisposableObject;
}

Answer 1

Disposal, finalization and memory deallocation are 3 totally different things in the .NET world.

Disposal is only an “application logic” thing, it is implemented through the disposable pattern.
If you implement the interface IDisposable, your object can be used with the using keyword.

The using keyword will translate in a simple way:

using (IDisposable xxx = new MyObject())
{
    ....
}

means

{
    IDisposable xxx = new MyObject();
    try
    {
        ....
    }
    finally
    {
        if (xxx != null)
            xxx.Dispose();
    }
}

There is no other magic in this. That’s all.

Object finalization is instead called by garbage collector when the objects should be freed.
The time when it happens and the order between destructors is unpredictable.

class myclass { ~myclass() { this code will be called by garbage collector, i cannot call it } }

The syntax is very similar to C++ destructors but the meaning is a lot different.

And then memory deallocation.
Memory deallocation is not connected to object disposal!
You can keep forever a reference to a disposed object. Disposal is just something related to application logic.

Destructors can also be cancelled or called more than once by garbage collector (see GC.ReRegisterForFinalize and GC.SuppressFinalize).
The presence of a destructor in a class slow down a lot the garbage collector, and inside destructor, you can do almost nothing except releasing unmanaged resources.

Disposal instead as I said is an application thing, is just a method, and is not related to garbage collector.