.nettransactionsdisposesqltransaction

Does SqlTransaction need to have Dispose called?


Do I need to call dispose in the finally block for SqlTransaction? Pretend the developer didnt use USING anywhere, and just try/catch.

SqlTransaction sqlTrans = con.BeginTransaction();

try
{
     //Do Work
sqlTrans.Commit()
}
catch (Exception ex)
        {

           sqlTrans.Rollback();
        }

 finally
        {
            sqlTrans.Dispose();
            con.Dispose();
        }

Solution

  • Do I need to use try-finally or the using-statement to dispose the SqlTransaction?

    It does not hurt to have it. This is true for every class implementing IDisposable, otherwise it would not implement this interface.

    But normally the garbage collector deals with unreferenced objects(it doesn't mean that the GC calls dispose, which isn't true), so you need it only for unmanaged resources. But because i also don't want to call dispose on every other variable or use the using-statement everywhere, it it's always worth to look into the actual implementation of the class' Dispose method.

    SqlTransaction.Dispose:

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            SNIHandle target = null;
            RuntimeHelpers.PrepareConstrainedRegions();
            try
            {
                target = SqlInternalConnection.GetBestEffortCleanupTarget(this._connection);
                if (!this.IsZombied && !this.IsYukonPartialZombie)
                {
                    this._internalTransaction.Dispose();
                }
            }
            catch (OutOfMemoryException e)
            {
                this._connection.Abort(e);
                throw;
            }
            catch (StackOverflowException e2)
            {
                this._connection.Abort(e2);
                throw;
            }
            catch (ThreadAbortException e3)
            {
                this._connection.Abort(e3);
                SqlInternalConnection.BestEffortCleanup(target);
                throw;
            }
        }
        base.Dispose(disposing);
    }
            
    

    Without understanding all(or anything) what is happening here i can say that this is more than a simple base.Dispose(disposing). So it might be a good idea to ensure that a SqlTransaction gets disposed.

    But because SqlConnection.BeginTransaction creates the transaction it could also be a good idea to reflect this also:

    public SqlTransaction BeginTransaction(IsolationLevel iso, string transactionName)
    {
        SqlStatistics statistics = null;
        string a = ADP.IsEmpty(transactionName) ? "None" : transactionName;
        IntPtr intPtr;
        Bid.ScopeEnter(out intPtr, "<sc.SqlConnection.BeginTransaction|API> %d#, iso=%d{ds.IsolationLevel}, transactionName='%ls'\n", this.ObjectID, (int)iso, a);
        SqlTransaction result;
        try
        {
            statistics = SqlStatistics.StartTimer(this.Statistics);
            SqlTransaction sqlTransaction = this.GetOpenConnection().BeginSqlTransaction(iso, transactionName);
            GC.KeepAlive(this);
            result = sqlTransaction;
        }
        finally
        {
            Bid.ScopeLeave(ref intPtr);
            SqlStatistics.StopTimer(statistics);
        }
        return result;
    }
    

    As you can see. The GC will also keep the Connection alive when a Transaction is created. It also doesn't hold a reference to the transaction since it only returns it. Hence it might not be disposed even when the connection is already disposed. Another argument to dispose the transaction.

    You might also have a look at the TransactionScope class which is more fail-safe than BeginTransaction. Have a look at this question for more informations.