SqlConnection.BeginTransaction Methode

Definition

Namespace:

Microsoft.Data.SqlClient

Assembly:

Microsoft.Data.SqlClient.dll

Paket:

Microsoft.Data.SqlClient v5.2.0

Überlädt

BeginTransaction()	Startet eine Datenbanktransaktion.
BeginTransaction(IsolationLevel)	Startet eine Datenbanktransaktion mit dem angegebenen Isolationsgrad.
BeginTransaction(String)	Startet eine Datenbanktransaktion mit dem angegebenen Transaktionsnamen.
BeginTransaction(IsolationLevel, String)	Startet eine Datenbanktransaktion mit dem angegebenen Isolationsgrad und Transaktionsnamen.

BeginTransaction()

Startet eine Datenbanktransaktion.

public:
 Microsoft::Data::SqlClient::SqlTransaction ^ BeginTransaction();

public Microsoft.Data.SqlClient.SqlTransaction BeginTransaction ();

override this.BeginTransaction : unit -> Microsoft.Data.SqlClient.SqlTransaction

Public Function BeginTransaction () As SqlTransaction

Gibt zurück

SqlTransaction

Ein Objekt, das die neue Transaktion darstellt.

Ausnahmen

SqlException

Parallele Transaktionen sind bei Verwendung von MARS (Multiple Active Result Sets) nicht zulässig.

InvalidOperationException

Parallele Transaktionen werden nicht unterstützt.

Beispiele

Im folgenden Beispiel werden ein SqlConnection und ein SqlTransactionerstellt. Außerdem wird veranschaulicht, wie die BeginTransactionMethoden , a Commitund Rollback verwendet werden.

using Microsoft.Data.SqlClient;

namespace Transaction1CS
{
    class Program
    {
        static void Main()
        {
            string connectionString =
                "Persist Security Info=False;Integrated Security=SSPI;database=Northwind;server=(local)";
            ExecuteSqlTransaction(connectionString);
            Console.ReadLine();
        }
        private static void ExecuteSqlTransaction(string connectionString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                SqlCommand command = connection.CreateCommand();
                SqlTransaction transaction;

                // Start a local transaction.
                transaction = connection.BeginTransaction();

                // Must assign both transaction object and connection
                // to Command object for a pending local transaction
                command.Connection = connection;
                command.Transaction = transaction;

                try
                {
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (100, 'Description')";
                    command.ExecuteNonQuery();
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (101, 'Description')";
                    command.ExecuteNonQuery();

                    // Attempt to commit the transaction.
                    transaction.Commit();
                    Console.WriteLine("Both records are written to database.");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Commit Exception Type: {0}", ex.GetType());
                    Console.WriteLine("  Message: {0}", ex.Message);

                    // Attempt to roll back the transaction.
                    try
                    {
                        transaction.Rollback();
                    }
                    catch (Exception ex2)
                    {
                        // This catch block will handle any errors that may have occurred
                        // on the server that would cause the rollback to fail, such as
                        // a closed connection.
                        Console.WriteLine("Rollback Exception Type: {0}", ex2.GetType());
                        Console.WriteLine("  Message: {0}", ex2.Message);
                    }
                }
            }
        }
    }
}

Hinweise

Dieser Befehl wird der SQL Server Implementierung von BEGIN TRANSACTION zugeordnet.

Sie müssen die Transaktion explizit mit der Commit -Methode oder committen oder Rollback zurücksetzen. Um sicherzustellen, dass der .NET Framework-Datenanbieter für SQL Server Transaktionsverwaltungsmodell ordnungsgemäß funktioniert, vermeiden Sie die Verwendung anderer Transaktionsverwaltungsmodelle, z. B. des von SQL Server bereitgestellten.

Hinweis

Wenn Sie keine Isolationsstufe angeben, wird die Standardisolationsstufe verwendet. Um eine Isolationsstufe mit der BeginTransaction -Methode anzugeben, verwenden Sie die Überladung, die den iso Parameter (BeginTransaction) annimmt. Die für eine Transaktion festgelegte Isolationsstufe bleibt nach Abschluss der Transaktion und bis die Verbindung geschlossen oder verworfen wird. Das Festlegen der Isolationsstufe auf Momentaufnahme in einer Datenbank, in der die Isolationsstufe für Momentaufnahmen nicht aktiviert ist, löst keine Ausnahme aus. Die Transaktion wird mit der Standardisolationsstufe abgeschlossen.

Achtung

Wenn eine Transaktion gestartet wird und ein Fehler der Ebene 16 oder höher auf dem Server auftritt, wird ein Rollback für die Transaktion erst ausgeführt, wenn die Read Methode aufgerufen wird. Für ExecuteReader wird keine Ausnahme ausgelöst.

Achtung

Wenn Ihre Abfrage eine große Menge an Daten zurückgibt und aufruftBeginTransaction, wird ein SqlException ausgelöst, da SQL Server bei Verwendung von MARS keine parallelen Transaktionen zulässt. Um dieses Problem zu vermeiden, ordnen Sie immer eine Transaktion dem Befehl, der Verbindung oder beiden zu, bevor Leser geöffnet sind.

Weitere Informationen zu SQL Server Transaktionen finden Sie unter Transaktionen (Transact-SQL).

BeginTransaction(IsolationLevel)

Startet eine Datenbanktransaktion mit dem angegebenen Isolationsgrad.

public:
 Microsoft::Data::SqlClient::SqlTransaction ^ BeginTransaction(System::Data::IsolationLevel iso);

public Microsoft.Data.SqlClient.SqlTransaction BeginTransaction (System.Data.IsolationLevel iso);

override this.BeginTransaction : System.Data.IsolationLevel -> Microsoft.Data.SqlClient.SqlTransaction

Public Function BeginTransaction (iso As IsolationLevel) As SqlTransaction

Parameter

iso

IsolationLevel

Die Isolationsstufe, unter der die Transaktion ausgeführt werden soll.

Gibt zurück

SqlTransaction

Ein Objekt, das die neue Transaktion darstellt.

Ausnahmen

SqlException

Parallele Transaktionen sind bei Verwendung von MARS (Multiple Active Result Sets) nicht zulässig.

InvalidOperationException

Parallele Transaktionen werden nicht unterstützt.

Beispiele

Im folgenden Beispiel werden ein SqlConnection und ein SqlTransactionerstellt. Außerdem wird veranschaulicht, wie die BeginTransactionMethoden , a Commitund Rollback verwendet werden.

using Microsoft.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString =
            "Persist Security Info=False;Integrated Security=SSPI;database=Northwind;server=(local)";
        ExecuteSqlTransaction(connectionString);
        Console.ReadLine();
    }
    private static void ExecuteSqlTransaction(string connectionString)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            SqlCommand command = connection.CreateCommand();
            SqlTransaction transaction;

            // Start a local transaction.
            transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);

            // Must assign both transaction object and connection
            // to Command object for a pending local transaction
            command.Connection = connection;
            command.Transaction = transaction;

            try
            {
                command.CommandText =
                    "Insert into Region (RegionID, RegionDescription) VALUES (100, 'Description')";
                command.ExecuteNonQuery();
                command.CommandText =
                    "Insert into Region (RegionID, RegionDescription) VALUES (101, 'Description')";
                command.ExecuteNonQuery();
                transaction.Commit();
                Console.WriteLine("Both records are written to database.");
            }
            catch (Exception e)
            {
                try
                {
                    transaction.Rollback();
                }
                catch (SqlException ex)
                {
                    if (transaction.Connection != null)
                    {
                        Console.WriteLine("An exception of type " + ex.GetType() +
                            " was encountered while attempting to roll back the transaction.");
                    }
                }

                Console.WriteLine("An exception of type " + e.GetType() +
                    " was encountered while inserting the data.");
                Console.WriteLine("Neither record was written to database.");
            }
        }
    }
}

Hinweise

Dieser Befehl wird der SQL Server Implementierung von BEGIN TRANSACTION zugeordnet.

Sie müssen die Transaktion explizit mit der Commit -Methode oder committen oder Rollback zurücksetzen. Um sicherzustellen, dass der .NET Framework-Datenanbieter für SQL Server Transaktionsverwaltungsmodell ordnungsgemäß funktioniert, vermeiden Sie die Verwendung anderer Transaktionsverwaltungsmodelle, z. B. des von SQL Server bereitgestellten.

Hinweis

Nachdem ein Commit für eine Transaktion durchgeführt oder ein Rollback ausgeführt wurde, bleibt die Isolationsstufe der Transaktion für alle nachfolgenden Befehle erhalten, die sich im Autocommit-Modus befinden (standardeinstellung SQL Server). Dies kann zu unerwarteten Ergebnissen führen, z. B. zu einer Isolationsstufe von REPEATABLE READ, die andere Benutzer aus einer Zeile zurückhält und sperrt. Um die Isolationsstufe auf den Standard (READ COMMITTED) zurückzusetzen, führen Sie die Transact-SQL SET TRANSACTION ISOLATION LEVEL READ COMMITTED-Anweisung aus, oder rufen Sie SqlConnection.BeginTransaction sofort gefolgt von auf SqlTransaction.Commit. Weitere Informationen zu SQL Server Isolationsstufen finden Sie unter Transaktionsisolationsstufen.

Weitere Informationen zu SQL Server Transaktionen finden Sie unter Transaktionen (Transact-SQL).

Achtung

Wenn Ihre Abfrage eine große Menge an Daten zurückgibt und aufruftBeginTransaction, wird ein SqlException ausgelöst, da SQL Server bei Verwendung von MARS keine parallelen Transaktionen zulässt. Um dieses Problem zu vermeiden, ordnen Sie immer eine Transaktion dem Befehl, der Verbindung oder beiden zu, bevor Leser geöffnet sind.

BeginTransaction(String)

Startet eine Datenbanktransaktion mit dem angegebenen Transaktionsnamen.

public:
 Microsoft::Data::SqlClient::SqlTransaction ^ BeginTransaction(System::String ^ transactionName);

public Microsoft.Data.SqlClient.SqlTransaction BeginTransaction (string transactionName);

override this.BeginTransaction : string -> Microsoft.Data.SqlClient.SqlTransaction

Public Function BeginTransaction (transactionName As String) As SqlTransaction

Parameter

transactionName

String

Der Name der Transaktion.

Gibt zurück

SqlTransaction

Ein Objekt, das die neue Transaktion darstellt.

Ausnahmen

SqlException

Parallele Transaktionen sind bei Verwendung von MARS (Multiple Active Result Sets) nicht zulässig.

InvalidOperationException

Parallele Transaktionen werden nicht unterstützt.

Beispiele

Im folgenden Beispiel werden ein SqlConnection und ein SqlTransactionerstellt. Außerdem wird veranschaulicht, wie die BeginTransactionMethoden , a Commitund Rollback verwendet werden.

using Microsoft.Data.SqlClient;

namespace Transaction1CS
{
    class Program
    {
        static void Main()
        {
            string connectionString =
                "Persist Security Info=False;Integrated Security=SSPI;database=Northwind;server=(local)";
            ExecuteSqlTransaction(connectionString);
            Console.ReadLine();
        }
        private static void ExecuteSqlTransaction(string connectionString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                SqlCommand command = connection.CreateCommand();
                SqlTransaction transaction;

                // Start a local transaction.
                transaction = connection.BeginTransaction("SampleTransaction");

                // Must assign both transaction object and connection
                // to Command object for a pending local transaction
                command.Connection = connection;
                command.Transaction = transaction;

                try
                {
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (100, 'Description')";
                    command.ExecuteNonQuery();
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (101, 'Description')";
                    command.ExecuteNonQuery();

                    // Attempt to commit the transaction.
                    transaction.Commit();
                    Console.WriteLine("Both records are written to database.");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Commit Exception Type: {0}", ex.GetType());
                    Console.WriteLine("  Message: {0}", ex.Message);

                    // Attempt to roll back the transaction.
                    try
                    {
                        transaction.Rollback("SampleTransaction");
                    }
                    catch (Exception ex2)
                    {
                        // This catch block will handle any errors that may have occurred
                        // on the server that would cause the rollback to fail, such as
                        // a closed connection.
                        Console.WriteLine("Rollback Exception Type: {0}", ex2.GetType());
                        Console.WriteLine("  Message: {0}", ex2.Message);
                    }
                }
            }
        }
    }
}

Hinweise

Dieser Befehl wird der SQL Server Implementierung von BEGIN TRANSACTION zugeordnet.

Die Länge des transactionName Parameters darf 32 Zeichen nicht überschreiten, andernfalls wird eine Ausnahme ausgelöst.

Der Wert im transactionName Parameter kann in späteren Aufrufen Rollback von und im savePoint Parameter der Save -Methode verwendet werden.

Sie müssen die Transaktion explizit mit der Commit -Methode oder committen oder Rollback zurücksetzen. Um sicherzustellen, dass der .NET-Datenanbieter für SQL Server Transaktionsverwaltungsmodell ordnungsgemäß funktioniert, vermeiden Sie die Verwendung anderer Transaktionsverwaltungsmodelle, z. B. des von SQL Server bereitgestellten.

Weitere Informationen zu SQL Server Transaktionen finden Sie unter Transaktionen (Transact-SQL).

Achtung

Wenn Ihre Abfrage eine große Menge an Daten zurückgibt und aufruftBeginTransaction, wird ein SqlException ausgelöst, da SQL Server bei Verwendung von MARS keine parallelen Transaktionen zulässt. Um dieses Problem zu vermeiden, ordnen Sie immer eine Transaktion dem Befehl, der Verbindung oder beiden zu, bevor Leser geöffnet sind.

BeginTransaction(IsolationLevel, String)

Startet eine Datenbanktransaktion mit dem angegebenen Isolationsgrad und Transaktionsnamen.

public:
 Microsoft::Data::SqlClient::SqlTransaction ^ BeginTransaction(System::Data::IsolationLevel iso, System::String ^ transactionName);

public Microsoft.Data.SqlClient.SqlTransaction BeginTransaction (System.Data.IsolationLevel iso, string transactionName);

override this.BeginTransaction : System.Data.IsolationLevel * string -> Microsoft.Data.SqlClient.SqlTransaction

Public Function BeginTransaction (iso As IsolationLevel, transactionName As String) As SqlTransaction

Parameter

iso

IsolationLevel

Die Isolationsstufe, unter der die Transaktion ausgeführt werden soll.

transactionName

String

Der Name der Transaktion.

Gibt zurück

SqlTransaction

Ein Objekt, das die neue Transaktion darstellt.

Ausnahmen

SqlException

Parallele Transaktionen sind bei Verwendung von MARS (Multiple Active Result Sets) nicht zulässig.

InvalidOperationException

Parallele Transaktionen werden nicht unterstützt.

Beispiele

Im folgenden Beispiel werden ein SqlConnection und ein SqlTransactionerstellt. Außerdem wird veranschaulicht, wie die BeginTransactionMethoden , a Commitund Rollback verwendet werden.

using Microsoft.Data.SqlClient;

namespace Transaction1CS
{
    class Program
    {
        static void Main()
        {
            string connectionString =
                "Persist Security Info=False;Integrated Security=SSPI;database=Northwind;server=(local)";
            ExecuteSqlTransaction(connectionString);
            Console.ReadLine();
        }
        private static void ExecuteSqlTransaction(string connectionString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                SqlCommand command = connection.CreateCommand();
                SqlTransaction transaction;

                // Start a local transaction.
                transaction = connection.BeginTransaction(
                    IsolationLevel.ReadCommitted, "SampleTransaction");

                // Must assign both transaction object and connection
                // to Command object for a pending local transaction.
                command.Connection = connection;
                command.Transaction = transaction;

                try
                {
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (100, 'Description')";
                    command.ExecuteNonQuery();
                    command.CommandText =
                        "Insert into Region (RegionID, RegionDescription) VALUES (101, 'Description')";
                    command.ExecuteNonQuery();
                    transaction.Commit();
                    Console.WriteLine("Both records are written to database.");
                }
                catch (Exception e)
                {
                    try
                    {
                        transaction.Rollback("SampleTransaction");
                    }
                    catch (SqlException ex)
                    {
                        if (transaction.Connection != null)
                        {
                            Console.WriteLine("An exception of type " + ex.GetType() +
                                " was encountered while attempting to roll back the transaction.");
                        }
                    }

                    Console.WriteLine("An exception of type " + e.GetType() +
                        " was encountered while inserting the data.");
                    Console.WriteLine("Neither record was written to database.");
                }
            }
        }
    }
}

Hinweise

Dieser Befehl wird der SQL Server Implementierung von BEGIN TRANSACTION zugeordnet.

Der Wert im transactionName Parameter kann in späteren Aufrufen Rollback von und im savePoint Parameter der Save -Methode verwendet werden.

Sie müssen die Transaktion explizit mit der Commit -Methode oder committen oder Rollback zurücksetzen. Um sicherzustellen, dass das SQL Server Transaktionsverwaltungsmodell ordnungsgemäß funktioniert, vermeiden Sie die Verwendung anderer Transaktionsverwaltungsmodelle, z. B. das von SQL Server bereitgestellte.

Hinweis

Nachdem ein Commit für eine Transaktion durchgeführt oder ein Rollback ausgeführt wurde, bleibt die Isolationsstufe der Transaktion für alle nachfolgenden Befehle erhalten, die sich im Autocommit-Modus befinden (standardeinstellung SQL Server). Dies kann zu unerwarteten Ergebnissen führen, z. B. zu einer Isolationsstufe von REPEATABLE READ, die andere Benutzer aus einer Zeile zurückhält und sperrt. Um die Isolationsstufe auf den Standard (READ COMMITTED) zurückzusetzen, führen Sie die Transact-SQL SET TRANSACTION ISOLATION LEVEL READ COMMITTED-Anweisung aus, oder rufen Sie SqlConnection.BeginTransaction sofort gefolgt von auf SqlTransaction.Commit. Weitere Informationen zu SQL Server Isolationsstufen finden Sie unter Transaktionsisolationsstufen.

Weitere Informationen zu SQL Server Transaktionen finden Sie unter Transaktionen (Transact-SQL).

Achtung

Wenn Ihre Abfrage eine große Menge an Daten zurückgibt und aufruftBeginTransaction, wird ein SqlException ausgelöst, da SQL Server bei Verwendung von MARS keine parallelen Transaktionen zulässt. Um dieses Problem zu vermeiden, ordnen Sie immer eine Transaktion dem Befehl, der Verbindung oder beiden zu, bevor Leser geöffnet sind.