SqlConnection.BeginTransaction Método

Definición

Espacio de nombres:

Microsoft.Data.SqlClient

Ensamblado:

Microsoft.Data.SqlClient.dll

Paquete:

Microsoft.Data.SqlClient v5.2.0

Sobrecargas

BeginTransaction()	Inicia una transacción de base de datos.
BeginTransaction(IsolationLevel)	Inicia una transacción de base de datos con el nivel de aislamiento especificado.
BeginTransaction(String)	Inicia una transacción de base de datos con el nombre de transacción especificado.
BeginTransaction(IsolationLevel, String)	Inicia una transacción de la base de datos con el nivel de aislamiento y el nombre de transacción especificados.

BeginTransaction()

Inicia una transacción de base de datos.

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

Devoluciones

SqlTransaction

Objeto que representa la nueva transacción.

Excepciones

SqlException

No se permiten transacciones paralelas al usar Conjuntos de resultados activos múltiples (MARS).

InvalidOperationException

No se admiten transacciones paralelas.

Ejemplos

En el ejemplo siguiente se crea un SqlConnection objeto y .SqlTransaction También muestra cómo usar los BeginTransactionmétodos , y CommitRollback .

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

Comentarios

Este comando se asigna a la implementación SQL Server de BEGIN TRANSACTION.

Debe confirmar o revertir explícitamente la transacción mediante el Commit método o Rollback . Para asegurarse de que el proveedor de datos de .NET Framework para SQL Server modelo de administración de transacciones funciona correctamente, evite usar otros modelos de administración de transacciones, como el proporcionado por SQL Server.

Nota:

Si no especifica un nivel de aislamiento, se usa el nivel de aislamiento predeterminado. Para especificar un nivel de aislamiento con el BeginTransaction método , use la sobrecarga que toma el iso parámetro (BeginTransaction). El nivel de aislamiento establecido para una transacción persiste una vez completada la transacción y hasta que se cierra o elimina la conexión. Establecer el nivel de aislamiento en Instantánea en una base de datos en la que el nivel de aislamiento de instantánea no está habilitado no produce una excepción. La transacción se completará con el nivel de aislamiento predeterminado.

Precaución

Si se inicia una transacción y se produce un error de nivel 16 o superior en el servidor, la transacción no se revertirá hasta que se invoque el Read método. No se produce ninguna excepción en ExecuteReader.

Precaución

Cuando la consulta devuelve una gran cantidad de datos y llama a BeginTransaction, se produce una SqlException excepción porque SQL Server no permite transacciones paralelas al usar MARS. Para evitar este problema, asocie siempre una transacción con el comando, la conexión o ambos antes de que los lectores estén abiertos.

Para obtener más información sobre SQL Server transacciones, vea Transacciones (Transact-SQL).

BeginTransaction(IsolationLevel)

Inicia una transacción de base de datos con el nivel de aislamiento especificado.

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

Parámetros

iso

IsolationLevel

Nivel de aislamiento en el que tiene que ejecutarse la transacción.

Devoluciones

SqlTransaction

Objeto que representa la nueva transacción.

Excepciones

SqlException

No se permiten transacciones paralelas al usar Conjuntos de resultados activos múltiples (MARS).

InvalidOperationException

No se admiten transacciones paralelas.

Ejemplos

En el ejemplo siguiente se crea un SqlConnection objeto y .SqlTransaction También muestra cómo usar los BeginTransactionmétodos , y CommitRollback .

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

Comentarios

Este comando se asigna a la implementación SQL Server de BEGIN TRANSACTION.

Debe confirmar o revertir explícitamente la transacción mediante el Commit método o Rollback . Para asegurarse de que el proveedor de datos de .NET Framework para SQL Server modelo de administración de transacciones funciona correctamente, evite usar otros modelos de administración de transacciones, como el proporcionado por SQL Server.

Nota:

Después de confirmar o revertir una transacción, el nivel de aislamiento de la transacción persiste para todos los comandos posteriores que están en modo de confirmación automática (el valor predeterminado SQL Server). Esto puede generar resultados inesperados, como un nivel de aislamiento de REPEATABLE READ persistente y bloquear a otros usuarios fuera de una fila. Para restablecer el nivel de aislamiento al valor predeterminado (READ COMMITTED), ejecute la instrucción TRANSACT-SQL SET TRANSACTION ISOLATION LEVEL READ COMMITTED o llame SqlConnection.BeginTransaction inmediatamente a seguida de SqlTransaction.Commit. Para obtener más información sobre los niveles de aislamiento de SQL Server, vea Niveles de aislamiento de transacción.

Para obtener más información sobre SQL Server transacciones, vea Transacciones (Transact-SQL).

Precaución

Cuando la consulta devuelve una gran cantidad de datos y llama a BeginTransaction, se produce una SqlException excepción porque SQL Server no permite transacciones paralelas al usar MARS. Para evitar este problema, asocie siempre una transacción con el comando, la conexión o ambos antes de que los lectores estén abiertos.

BeginTransaction(String)

Inicia una transacción de base de datos con el nombre de transacción especificado.

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

Parámetros

transactionName

String

Nombre de la transacción.

Devoluciones

SqlTransaction

Objeto que representa la nueva transacción.

Excepciones

SqlException

No se permiten transacciones paralelas al usar Conjuntos de resultados activos múltiples (MARS).

InvalidOperationException

No se admiten transacciones paralelas.

Ejemplos

En el ejemplo siguiente se crea un SqlConnection objeto y .SqlTransaction También muestra cómo usar los BeginTransactionmétodos , y CommitRollback .

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

Comentarios

Este comando se asigna a la implementación SQL Server de BEGIN TRANSACTION.

La longitud del transactionName parámetro no debe superar los 32 caracteres; de lo contrario, se producirá una excepción.

El valor del transactionName parámetro se puede usar en llamadas posteriores a Rollback y en el savePoint parámetro del Save método .

Debe confirmar o revertir explícitamente la transacción mediante el Commit método o Rollback . Para asegurarse de que el proveedor de datos .NET para SQL Server modelo de administración de transacciones funciona correctamente, evite usar otros modelos de administración de transacciones, como el proporcionado por SQL Server.

Para obtener más información sobre SQL Server transacciones, vea Transacciones (Transact-SQL).

Precaución

Cuando la consulta devuelve una gran cantidad de datos y llama a BeginTransaction, se produce una SqlException excepción porque SQL Server no permite transacciones paralelas al usar MARS. Para evitar este problema, asocie siempre una transacción con el comando, la conexión o ambos antes de que los lectores estén abiertos.

BeginTransaction(IsolationLevel, String)

Inicia una transacción de la base de datos con el nivel de aislamiento y el nombre de transacción especificados.

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

Parámetros

iso

IsolationLevel

Nivel de aislamiento en el que tiene que ejecutarse la transacción.

transactionName

String

Nombre de la transacción.

Devoluciones

SqlTransaction

Objeto que representa la nueva transacción.

Excepciones

SqlException

No se permiten transacciones paralelas al usar Conjuntos de resultados activos múltiples (MARS).

InvalidOperationException

No se admiten transacciones paralelas.

Ejemplos

En el ejemplo siguiente se crea un SqlConnection objeto y .SqlTransaction También muestra cómo usar los BeginTransactionmétodos , y CommitRollback .

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

Comentarios

Este comando se asigna a la implementación SQL Server de BEGIN TRANSACTION.

El valor del transactionName parámetro se puede usar en llamadas posteriores a Rollback y en el savePoint parámetro del Save método .

Debe confirmar o revertir explícitamente la transacción mediante el Commit método o Rollback . Para asegurarse de que el modelo de administración de transacciones de SQL Server funciona correctamente, evite usar otros modelos de administración de transacciones, como el proporcionado por SQL Server.

Nota:

Después de confirmar o revertir una transacción, el nivel de aislamiento de la transacción persiste para todos los comandos posteriores que están en modo de confirmación automática (el valor predeterminado SQL Server). Esto puede generar resultados inesperados, como un nivel de aislamiento de REPEATABLE READ persistente y bloquear a otros usuarios fuera de una fila. Para restablecer el nivel de aislamiento al valor predeterminado (READ COMMITTED), ejecute la instrucción TRANSACT-SQL SET TRANSACTION ISOLATION LEVEL READ COMMITTED o llame SqlConnection.BeginTransaction inmediatamente a seguida de SqlTransaction.Commit. Para obtener más información sobre los niveles de aislamiento de SQL Server, vea Niveles de aislamiento de transacción.

Para obtener más información sobre SQL Server transacciones, vea Transacciones (Transact-SQL).

Precaución

Cuando la consulta devuelve una gran cantidad de datos y llama a BeginTransaction, se produce una SqlException excepción porque SQL Server no permite transacciones paralelas al usar MARS. Para evitar este problema, asocie siempre una transacción con el comando, la conexión o ambos antes de que los lectores estén abiertos.