.NET IDisposable inline temps

Question

I use code rush and refactor pro (highlight possible code issues and so on like ReSharper) and they were telling me I had undisposed locals (that implemented IDisposable). So I changed the code to this with two using statements:

using (Reports.StudentRegisters.StudentQueriesDataTable studentDataTable = new Reports.StudentRegisters.StudentQueriesDataTable())
        {
            using (StudentQueriesTableAdapter studentTableAdapter = new StudentQueriesTableAdapter())
            {
                try
                {
                    studentTableAdapter.FillByQAbsenceRegRow(studentDataTable, year, school, division, progArea, sinceWeek, missedLessons, includeWdlTrn, ageMin, ageMax, studentGLH);
                    ds = new DataSet();
                    ds.Tables.Add((DataTable)studentDataTable);
                    ReportDocument.SetDataSource(ds.Tables[0]);
                }
                catch (Exception err)
                {
                    LogReportError(err, this.CrystalViewer, null, ErrorType.Reporting);
                }
            }
        }

Since the studentTableAdapter is used once I could in line it like below:

using (Reports.StudentRegisters.StudentQueriesDataTable studentDataTable = new Reports.StudentRegisters.StudentQueriesDataTable())
        {
                try
                {
                    (new StudentQueriesTableAdapter()).FillByQAbsenceRegRow(studentDataTable, year, school, division, progArea, sinceWeek, missedLessons, includeWdlTrn, ageMin, ageMax, studentGLH);
                    ds = new DataSet();
                    ds.Tables.Add((DataTable)studentDataTable);
                    ReportDocument.SetDataSource(ds.Tables[0]);
                }
                catch (Exception err)
                {
                    LogReportError(err, this.CrystalViewer, null, ErrorType.Reporting);
                }
        }

Obviously in this solution I now have no way to call dispose on the StudentQueriesTableAdapter. Is this called automatically as there is no reference to the object anymore or would this potentially leave something not disposed properly.

I will stress i'm not interested in whether I actually need to use dispose on the two objects, I know some things implement it and it's not really required (Although should always be done). I'm specifically interested in if it is called.

Answer 1

Dispose() isn't called automatically on objects that go out of scope - you need to wrap a reference to StudentQueriesTableAdapter in a using() {...} for it to be disposed correctly.

Another option is to combine the using and try, to reduce the nesting somewhat:

using (Reports.StudentRegisters.StudentQueriesDataTable studentDataTable = new Reports.StudentRegisters.StudentQueriesDataTable())
    {
        StudentQueriesTableAdapter studentTableAdapter;

        try
        {
            studentTableAdapter = new StudentQueriesTableAdapter();
            studentTableAdapter.FillByQAbsenceRegRow(studentDataTable, year, school, division, progArea, sinceWeek, missedLessons, includeWdlTrn, ageMin, ageMax, studentGLH);
            ds = new DataSet();
            ds.Tables.Add((DataTable)studentDataTable);
            ReportDocument.SetDataSource(ds.Tables[0]);
        }
        catch (Exception err)
        {
            LogReportError(err, this.CrystalViewer, null, ErrorType.Reporting);
        }
        finally
        {
            if (studentTableAdapter != null)
                studentTableAdapter.Dispose(); // or Close(), depending on which method is public
        }
    }

This is essentially what a using {} does - wrap it in a try/finally clause

Note that, although some objects may implement IDisposable with the Dispose method not doing anything, you should always wrap any IDisposable objects in a using - it is part of the contract of using that class, otherwise you may end up leaking resources (eg if an empty Dispose method is later filled out in a future version)

Answer 2

While it's part of the spec to have an item that implements IDisposable to have a finalizer that performs that call if it wasn't performed earlier, this is a bad, bad habit. If you instantiate an object that implements IDisposable and are finished with it, call Dispose.

Answer 3

Dispose is only called on objects that implement IDisposable() which you use using block on.

Thanks

Answer 4

No, it will not get called. Using(foo){ DoSomething() } is (roughly) functionally equivalent to:

var objectToDispose = foo as IDisposable;
try
{
    DoSomething();
}
finally
{
    if(objectToDispose != null)
        objectToDispose.Dispose();
}

Because of this, your StudentQueriesTableAdapter does not get disposed.

I often try to reduce nesting with multiple disposes like this:

using (var foo = new Foo())
using (var bar = new Bar(foo))
{
    DoSomething();
}