SqlTransaction en VB

¿Qué pasa si en alguna en un procesos de actualización de datos de una base de datos falla a la mitad? Lo normal en la mayoría de los casos es deshacer todo lo que se ha hecho y dejar la base de datos como estaba. Este proceso sería muy complicado hacerlo a mano, por no decir imposible. Para esto están las transacciones, que de una manera muy fácil nos ayudan a resolver este tipo de problemas, sobre todo es util cuando hay varias tablas involucradas en los cambios a realizar, pues  las operaciones son indivisibles, lo que significa que o se ejecutan todas las operaciones o no se ejecuta ninguna. En el Caso de las Transacciones con las Bases de Datos, si la Transacción ha dado error se hace un “Rollback” para deshacer todos los cambios.


Aquí ingresaremos datos a una tabla llamada personal dentro de una base de datos llamada empleado, lo primero que hacemos es crear una cadena de conexión y abrir una conexión con ésta. Con esta conexión abierta creamos la transacción (con el método “BeginTransaction”) y ejecutamos la instrucción de insertar datos. Si todo ha ido bien, hacemos un “Commit” de la transacción y si algo ha fallado hacemos un “Rollback”. Es importante hacer un ”Commit” ya que si no, el sistema hará un “Rollback” automáticamente al cerrar la conexión.

este es el diseño del formulario a utilizar tanto en VB como en C#

Ejemplo Transacciones en VB

Imports System.Data

Imports System.Data.SqlClient

Public Class Form1

    Dim conexion As New SqlConnectionStringBuilder

       

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        With conexion

            .DataSource = "USER-PC\PABLETORETO"

            .InitialCatalog = "empleado"

            .IntegratedSecurity = True

        End With

    End Sub

    Private Sub Agregar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Agregar.Click

        Using con As New SqlConnection(conexion.ConnectionString)

            con.Open()

            'Crear el objeto Transaction

            Dim transaccion As SqlTransaction = con.BeginTransaction

            Dim sentencia As String = "insert into personal " & _

        "(nombre, apellido, puesto, sueldo) " & _

        "VALUES (@nombre, @apellido, @puesto, @sueldo)"

            Dim cmd As New SqlCommand(sentencia, con)

            With cmd

                .Parameters.AddWithValue("@nombre", nombre.Text)

                .Parameters.AddWithValue("@apellido", apellido.Text)

                .Parameters.AddWithValue("@puesto", puesto.Text)

                .Parameters.AddWithValue("@sueldo", sueldo.Text)

            End With

            'Asignamos la transacción al método Transaction del comando, esto siempre debemos

            'hacerlo en todos los comandos que modifiquen los datos, si no lo asignamos, recibiremos un error.

            cmd.Transaction = transaccion

            Try

                cmd.ExecuteNonQuery()

                transaccion.Commit()

                MessageBox.Show("Se han actualizado los datos")

            Catch ex As Exception

                ' Si hay error, desahacemos lo que se haya hecho

                transaccion.Rollback()

                MessageBox.Show("No se han actualizado los datos" & vbCrLf & ex.Message)

            End Try

        End Using

    End Sub

End Class

Ejemplo Transacciones en C#

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Data.SqlClient;

namespace transaccionesC

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        SqlConnectionStringBuilder conexion = new SqlConnectionStringBuilder();

        private void Form1_Load(object sender, EventArgs e)

        {

          conexion.DataSource = @"USER-PC\PABLETORETO";

          conexion.InitialCatalog = "empleado";

          conexion.IntegratedSecurity = true;

    }

        private void Agregar_Click(object sender, EventArgs e)

        {

            using (SqlConnection con = new SqlConnection(conexion.ConnectionString)) {

                    con.Open();

                    //Crear el objeto Transaction

                    SqlTransaction transaccion = con.BeginTransaction();

                    string sentencia = "insert into personal " + "(nombre, apellido, puesto, sueldo) " + "VALUES (@nombre, @apellido, @puesto, @sueldo)";

                    SqlCommand cmd = new SqlCommand(sentencia, con);

                    cmd.Parameters.AddWithValue("@nombre", nombre.Text);

                    cmd.Parameters.AddWithValue("@apellido", apellido.Text);

                    cmd.Parameters.AddWithValue("@puesto", puesto.Text);

                    cmd.Parameters.AddWithValue("@sueldo", sueldo.Text);

                    //Asignamos la transacción al método Transaction del comando, esto siempre debemos

                    //hacerlo en todos los comandos que modifiquen los datos, si no lo asignamos, recibiremos un error.

                    cmd.Transaction = transaccion;

                    try {

                           cmd.ExecuteNonQuery();

                           transaccion.Commit();

                           MessageBox.Show("Se han actualizado los datos");

                    } catch (Exception ex) {

                           // Si hay error, desahacemos lo que se haya hecho

                           transaccion.Rollback();

                           MessageBox.Show("No se han actualizado los datos" + ex.Message);

                    } } } } }

Cómo hemos visto el uso de transacciones desde .NET es muy fácil y hace nuestras aplicaciones más robustas. Pero, ¿qué pasa cuando entran en juego varias bases de datos, o incluso varios gestores de base de datos (varios Sql Server)? Para eso tenemos el TransactionScope, que podemos ver en http://msdn.microsoft.com/en-us/library/system.transactions.transactionscope.aspx,