5

so lately i've been working with disposable object and i was wondering would it be benific to dispose an object inside a function ? like between those 2 functions is the use of .Dispose() really matters inside a function since all objects within a function will vanish as soon as it finishes 

void FOO()
{
    var x= new DisposableObject();
    //stuff
}

void FOO()
{
    using(var x= new DisposableObject())
    {
        //stuff
    }
}
ihisham
  • 248
  • 1
  • 10

4 Answers4

7

You should always Dispose() an object that needs it. Even if the object is garbage collected, there could be unmanaged resources that don't get released. Calling Dispose() (or a using as in your second example) ensures that the object can properly release unmanaged resources that it needs to.

itsme86
  • 19,266
  • 4
  • 41
  • 57
  • If the class is implemented correctly the finalizer will clean these unmanaged resources as well. – i3arnon Nov 06 '15 at 20:42
  • @i3arnon Please look at this: http://stackoverflow.com/questions/3458177/are-net-finalizers-always-executed – itsme86 Nov 06 '15 at 20:43
  • 3
    @i3arnon Not necessarily, and also you can't even guarantee that the finalizer will run for all objects. – Servy Nov 06 '15 at 20:44
  • @itsme86 If the process crashes or is unloaded you also can't guarantee execution of finally blocks. Of course disposing ASAP is prefered, but not mandatory (e.g. tasks http://blogs.msdn.com/b/pfxteam/archive/2012/03/25/10287435.aspx) – i3arnon Nov 06 '15 at 20:58
3

All objects within a function will vanish as soon as it finishes

The objects will stay, the local references will vanish. The objects will 'vanish' when garbage collector runs and determines they are unreachable.

Before an unreachable object is removed from memory, it's finalizer will run (if implemented), cleaning all unmanaged resources.

The problem is that all that is not deterministic. You never know when GC will run, in some cases the finalizer will not even be executed.

You should always call Dispose method if it's possible.

If you want more details about finalizers, you should read these 2 articles: part 1, part 2.

Jakub Lortz
  • 14,616
  • 3
  • 25
  • 39
2

Objects do not simply vanish.

The GC collects instances that are not referenced anymore. This may take time as the GC decides when to run and the instance will not be disposed until it does.

If this disposable has unmanaged resources and is implemented correctly the resources will be disposed by the finalizer which is a single thread.

If you're okay with the instance not being disposed for some time and the finalizer isn't busy.. then go ahead. But it's much better if you dispose of it as soon as possible.

i3arnon
  • 113,022
  • 33
  • 324
  • 344
1

Set a breakpoint in the Dispose() method and run these tests with debugging. TestMethod1 doesn't hit the breakpoint while TestMethod2 does.

As others have noted this is because of the way that GC works in .Net If you are going to implement the IDiisposeable interface, you probably want to put your class in a using statement or call .Dispose() so you have more predictable application behavior.

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestProject2
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            var disposable = new DisposableObject();
            disposable.DoSomething();
        }

        [TestMethod]
        public void TestMethod2()
        {
            using (var disposable = new DisposableObject())
            {
                disposable.DoSomething();
            }
        }
    }

    public class DisposableObject : IDisposable
    {
        public void Dispose()
        {
            // dispose here
        }

        public void DoSomething()
        {
            // do something here
        }
    }
}
robaudas
  • 1,538
  • 1
  • 9
  • 12