Transaktionen in .net

Question

Was sind die besten Praktiken Transaktionen in C # .Net 2.0 zu tun. Was sind die Klassen, die verwendet werden soll? Was sind die Gefahren für usw. Blick auf all das Zeug Commit und Rollback. Ich fange gerade ein Projekt, wo ich vielleicht einige Transaktionen zu tun, während Daten in die DB einfügen. Jegliche Antworten oder Links für noch grundlegende Dinge über Transaktionen sind willkommen.

Answer 1

Es gibt 2 Arten von Transaktionen; Verbindung Transaktionen und Umgebungs Transaktionen. Eine Verbindungstransaktion (wie SqlTransaction) direkt an die DB-Verbindung (wie SqlConnection) gebunden, was bedeutet, dass Sie die Verbindung vorbei um zu halten haben - OK in einigen Fällen aber nicht erlaubt „erstellen / Nutzung / release“ Nutzung und erlaubt keine Quer db Arbeit. Ein Beispiel (formatiert für Leerzeichen):

using (IDbTransaction tran = conn.BeginTransaction()) {
    try {
        // your code
        tran.Commit();
    }  catch {
        tran.Rollback();
        throw;
    }
}

Nicht zu chaotisch, aber beschränkt auf unsere Verbindung „conn“. Wenn wir verschiedene Methoden aufrufen wollen, müssen wir jetzt passieren „conn“ um.

Die Alternative ist eine Ambient-Transaktion; neu in .NET 2.0, das Transaction Objekt (System .Transactions.dll) kann eine Reihe von Operationen (geeigneter Anbieter verwenden wird über die Umgebungs Transaktion automatisch einzutragen). Dies macht es leicht (nicht transaktions) Code Nachrüstung in bestehende und zu mehreren Anbietern zu sprechen (obwohl DTC wird einlassen, wenn Sie mehr als ein Gespräch).

Zum Beispiel:

using(TransactionScope tran = new TransactionScope()) {
    CallAMethodThatDoesSomeWork();
    CallAMethodThatDoesSomeMoreWork();
    tran.Complete();
}

hier beachten, dass sich die beiden Methoden, um ihre eigenen Verbindungen verarbeiten kann (offen / Nutzung / close / dispose), doch werden sie leise Teil der Ambient-Transaktion werden, ohne dass wir etwas in passieren müssen.

Wenn Ihr Code Fehler, Dispose () ohne komplettes () aufgerufen werden, so wird es wieder aufgerollt werden. Die erwartete Verschachtelung usw. unterstützt wird, obwohl Sie nicht Rollback kann eine innere Transaktion noch die äußere Transaktion abzuschließen. Wenn jemand unglücklich ist, wird die Transaktion abgebrochen

Der andere Vorteil ist, dass es Transaction nicht nur auf Datenbanken gebunden ist; jeder Transaktion-aware-Provider kann es verwenden. WCF, zum Beispiel. Oder es gibt sogar einige Transaction-kompatible Objektmodelle um (das heißt .NET-Klassen mit Rollback-Funktion - vielleicht einfacher, als ein Andenken, obwohl ich das nie selbst benutzt habe nähern)

.

Alles in allem ein sehr, sehr nützliches Objekt.

Einige Einschränkungen:

• Auf SQL Server 2000 wird eine Transaction sofort zu DTC gehen; dies ist in SQL Server 2005 festgelegt und oben, kann es die LTM (viel weniger Overhead), bis Sie auf 2 Quellen usw. sprechen, wenn es um die DTC erhöht ist.
• Es ist ein Glitch das bedeutet, müssen Sie möglicherweise zwicken Ihre Verbindungszeichenfolge

Answer 2

protected void Button1_Click(object sender, EventArgs e)
   {


       using (SqlConnection connection1 = new SqlConnection("Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Database.mdf;Integrated Security=True;User Instance=True"))
       {
           connection1.Open();

           // Start a local transaction.
           SqlTransaction sqlTran = connection1.BeginTransaction();

           // Enlist a command in the current transaction.
           SqlCommand command = connection1.CreateCommand();
           command.Transaction = sqlTran;

           try
           {
               // Execute two separate commands.
               command.CommandText =
                "insert into [doctor](drname,drspecialization,drday) values ('a','b','c')";
               command.ExecuteNonQuery();
               command.CommandText =
                "insert into [doctor](drname,drspecialization,drday) values ('x','y','z')";
               command.ExecuteNonQuery();

               // Commit the transaction.
               sqlTran.Commit();
               Label3.Text = "Both records were written to database.";
           }
           catch (Exception ex)
           {
               // Handle the exception if the transaction fails to commit.
               Label4.Text = ex.Message;


               try
               {
                   // Attempt to roll back the transaction.
                   sqlTran.Rollback();
               }
               catch (Exception exRollback)
               {
                   // Throws an InvalidOperationException if the connection 
                   // is closed or the transaction has already been rolled 
                   // back on the server.
                   Label5.Text = exRollback.Message;

               }
           }
       }


   }

Answer 3

Sie können auch die Transaktion wickeln oben in seine eigene gespeicherte Prozedur und behandeln es auf diese Weise anstelle von Transaktionen in C # zu tun selbst.

Answer 4

, wenn Sie gerade brauchen es für db-related stuff, einige OR Mapper (z NHibernate) Unterstützung transactinos aus der Box per default.

Answer 5

Es hängt auch davon ab, was Sie brauchen. Für grundlegende SQL-Transaktionen können Sie versuchen, TSQL Transaktionen tun von TRANS mit BEGIN und COMMIT TRANS in Ihrem Code. Das ist der einfachste Weg, aber es hat die Komplexität und Sie müssen vorsichtig sein, richtig zu begehen (und Rollback).

würde ich so etwas wie

verwenden

SQLTransaction trans = null;
using(trans = new SqlTransaction)
{
    ...
    Do SQL stuff here passing my trans into my various SQL executers
    ...
    trans.Commit  // May not be quite right
}

Jeder Fehler werden Sie direkt aus dem using Pop und die Transaktion wird immer Commit oder Rollback (je nachdem, was Sie sagen, es zu tun). Das größte Problem, das wir konfrontiert war dafür, dass es immer verpflichtet. Die Verwendung gewährleistet, wobei der Umfang der Transaktion begrenzt ist.