Czy SqlTransaction wymaga wywołania Dispose?

Question

Czy muszę wywołać dispose w bloku finally dla SqlTransaction? Udawaj, że programista nie używał USING nigdzie i po prostu spróbuj/złap.

Answer 1

Czy muszę używać try-finally lub using -statement pozbyć się SqlTransaction?

Nie zaszkodzi mieć to. Dotyczy to każdej klasy implementującej IDisposable, w przeciwnym razie nie implementowałby tego interfejsu.

Ale zwykle śmieciarz poradziłby sobie z nim, gdyby obiekt nie był już przywoływany. Ponieważ nie chcę również wywoływać dispose na co drugiej zmiennej lub używać using-statement wszędzie, zawsze warto przyjrzeć się faktycznej implementacji metody klasy "Dispose.

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); 
} 

Bez zrozumienia wszystkich (lub cokolwiek) co się dzieje tutaj, mogę powiedzieć, że jest to więcej niż prosty base.Dispose(disposing). Więc może być dobrym pomysłem zapewnienie, że SqlTransaction zostanie usunięty.

Ale ponieważ SqlConnection.BeginTransaction tworzy transakcję może to być dobry pomysł, aby reflect tym również:

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; 
} 

Jak widać. Model GC będzie również utrzymywać połączenie połączenia podczas tworzenia transakcji. Nie ma również odniesienia do transakcji, ponieważ zwraca ją tylko. Dlatego może nie zostać usunięty, nawet gdy połączenie jest już usunięte. Kolejny argument do dyspozycji transakcji.

Możesz również rzucić okiem na TransactionScope class, który jest bardziej odporny na awarie niż BeginTransaction. Zajrzyj na stronę this question, aby uzyskać więcej informacji.

Answer 2

W ogólnym przypadku, każdy obiekt IDisposable, który konstruujesz lub pozyskujesz i który posiadasz, musisz się pozbyć.

W konkretnym przypadku istnieją pewne wyjątki, ale SqlTransaction nie jest jednym z nich.

Jak na the documentation of SqlTransaction.Dispose:

Uwalnia niezarządzani zasoby wykorzystywane przez DbTransaction i opcjonalnie zwalnia zarządzanych zasobów.

(podkreślenie moje)

Ponieważ dokumentacja nie wskazuje, że te niezarządzani zasoby są uwalniane podczas wydawania commit lub rollback, trzeba będzie wyrzucać tego obiektu.

Answer 3

Myślę, że możesz po prostu zamknąć połączenie. Sprawdziłem kod BCL - wygląda na to, że połączenia dbają o jego transakcję - nie ma potrzeby zamykania go jawnie.