Kann ich einen Verweis auf eine ausstehende Transaktion von einem SqlConnection-Objekt abrufen?

Wow ich wusste nicht, hoffen diese auf den ersten. Ich bin überrascht, dass CreateCommand() gibt nicht den Befehl, die Transaktion, wenn die Verwendung lokaler SQL-Server-Transaktionen, und, dass die Transaktion nicht ausgesetzt, auf das SqlConnection-Objekt. Tatsächlich, wenn die Reflexion auf das SqlConnection-die aktuelle Transaktion ist nicht einmal gespeicherte Objekt. In der edit ist unten, ich gab Ihnen einige Hinweise, um die Spur des Objekts über einige Ihrer internen Klassen.

Ich weiß, Sie können nicht ändern die Methode aber könnte Sie eine TransactionScope-rund um die Methode bar? Also, wenn Sie haben:

public static void CallingFooBar()
{
   using (var ts=new TransactionScope())
   {
      var foo=new Foo();
      foo.Bar();
      ts.Complete();
   }
}

Dies funktioniert, getestet habe ich mit ähnliche code zu verkaufen und sobald ich die wrapper-alle funktioniert gut, wenn Sie können dies tun, natürlich. Wie schon darauf achten, wenn mehr als eine Verbindung geöffnet ist bis in die TransactionScope-Sie eskaliert werden, um eine Verteilte Transaktion, die, sofern Sie Ihr system so konfiguriert ist, dass Sie erhalten Sie eine Fehlermeldung.

Eintragen mit dem DTC ist auch um ein Vielfaches langsamer als eine lokale Transaktion.

Bearbeiten

wenn Sie wirklich wollen, um zu versuchen und verwenden Sie reflektion, SqlConnection hat eine SqlInternalConnection dies wiederum hat eine Eigenschaft AvailableInternalTransaction gibt eine SqlInternalTransaction, diese hat eine Eigenschaft " Parent gibt das SqlTransaction-Sie brauchen würde.

InformationsquelleAutor der Antwort JoshBerke

Für jeden, der interessiert ist, die C# - version des decorator-Klasse, Denis made in VB.NET hier ist es:

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;

namespace DataAccessLayer
{
    ///<summary>
    ///Decorator for the connection class, exposing additional info like it's transaction.
    ///</summary>
    public class ConnectionWithExtraInfo : IDbConnection
    {
        private IDbConnection connection = null;
        private IDbTransaction transaction = null;

        public IDbConnection Connection
        {
            get { return connection; }
        }

        public IDbTransaction Transaction
        {
            get { return transaction; }
        }

        public ConnectionWithExtraInfo(IDbConnection connection)
        {
            this.connection = connection;
        }

        #region IDbConnection Members

        public IDbTransaction BeginTransaction(IsolationLevel il)
        {
            transaction = connection.BeginTransaction(il);
            return transaction;
        }

        public IDbTransaction BeginTransaction()
        {
            transaction = connection.BeginTransaction();
            return transaction;
        }

        public void ChangeDatabase(string databaseName)
        {
            connection.ChangeDatabase(databaseName);
        }

        public void Close()
        {
            connection.Close();
        }

        public string ConnectionString
        {
            get 
            {
                return connection.ConnectionString; 
            }
            set 
            {
                connection.ConnectionString = value;
            }
        }

        public int ConnectionTimeout
        {
            get { return connection.ConnectionTimeout; }
        }

        public IDbCommand CreateCommand()
        {
            return connection.CreateCommand();
        }

        public string Database
        {
            get { return connection.Database; }
        }

        public void Open()
        {
            connection.Open();
        }

        public ConnectionState State
        {
            get { return connection.State; }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            connection.Dispose();
        }

        #endregion
    }
}

InformationsquelleAutor der Antwort victorvartan

Ich bin ein großer Verfechter von einfachen, so wie über das schreiben eines wrappers über IDBConnection (DELEGATE-PATTERN) , stellt die Transaktion. (Sorry für VB.NET code Schreibe ich dieses in VB.NET jetzt) so Etwas wie dieses:

  Public class MyConnection
      Implements IDbConnection

      Private itsConnection as IDbConnection
      Private itsTransaction as IDbTransaction

      Public Sub New(ByVal conn as IDbConnection)
         itsConnection = conn
      End Sub

      //...  'All the implementations would look like
      Public Sub Dispose() Implements IDbConnection.Dispose
         itsConnection.Dispose()
      End Sub
      //...

      //    'Except BeginTransaction which would look like
       Public Overridable Function BeginTransaction() As IDbTransaction Implements IDbConnection.BeginTransaction
         itsTransaction = itsConnection.BeginTransaction()
         Return itsTransaction
       End Function  


      //'Now you can create a property and use it everywhere without any hacks
       Public ReadOnly Property Transaction
          Get
              return itsTransaction
          End Get
       End Property

    End Class

So würden Sie instanziieren Sie diese als:

Dim myConn as new MyConnection(new SqlConnection(...))

, und dann können Sie die Transaktion zu jeder Zeit:

 myConn.Transaction

InformationsquelleAutor der Antwort Denis