comment utiliser sqltransaction dans c #

L'exemple suivant crée une occurrence de SqlConnection et un SqlTransaction. Il montre également comment utiliser la BeginTransaction, Commit et Rollback méthodes. La transaction est annulée sur une erreur, ou si elle est éliminée sans avoir d'abord été commis. Try/Catch de la gestion d'erreur est utilisée pour gérer les erreurs lors de la tentative de valider ou d'annuler la transaction.

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

Voir SqlTransaction Classe

Vous pouvez créer un SqlTransaction à partir d'un SqlConnection.

Et l'utiliser pour créer n'importe quel nombre de SqlCommands

SqlTransaction transaction = connection.BeginTransaction();
var cmd1 = new SqlCommand(command1Text, connection, transaction);
var cmd2 = new SqlCommand(command2Text, connection, transaction);

Ou

var cmd1 = new SqlCommand(command1Text, connection, connection.BeginTransaction());
var cmd2 = new SqlCommand(command2Text, connection, cmd1.Transaction);

---

Si la défaillance de commandes jamais cause des changements inattendus ne pas utiliser la transaction.

si la défaillance de commandes pourrait cause des changements imprévus, les mettre dans un bloc Try/Catch et de la restauration de l'opération en un autre bloc Try/Catch.

Selon MSDN:

Try/Catch la gestion des exceptions doit toujours être utilisé quand restauration une transaction. Une Restauration génère un InvalidOperationException si la connexion est interrompue ou si la transaction a déjà été déployé sur le serveur.

Voici un exemple de code:

string connStr = "[connection string]";
string cmdTxt = "[t-sql command text]";

using (var conn = new SqlConnection(connStr))
{
    conn.Open();
    var cmd = new SqlCommand(cmdTxt, conn, conn.BeginTransaction());


    try
    {
        cmd.ExecuteNonQuery();
        //before this line, nothing has happened yet
        cmd.Transaction.Commit();
    }
    catch(System.Exception ex)
    {
        //You should always use a Try/Catch for transaction's rollback
        try
        {
            cmd.Transaction.Rollback();
        }
        catch(System.Exception ex2)
        {
            throw ex2;
        }
        throw ex;
    }

    conn.Close();
}

La transaction est restaurée dans le cas où il est éliminés avant Commit ou Rollback est appelé.

De sorte que vous n'avez pas besoin de s'inquiéter à propos de l'app en cours de fermeture.

D'abord, vous n'avez pas besoin d'une transaction puisque vous êtes juste de l'interrogation des instructions select et depuis qu'ils sont à la fois instruction select, vous pouvez simplement de les combiner en une seule requête séparés par l'espace et utiliser un jeu de données pour obtenir les toutes les tables extraites. Ses mieux de cette façon parce que vous avez fait une seule transaction à la base de données parce que les transactions de base de données sont chers donc votre code est plus rapide.
Deuxième de vous avez vraiment utiliser une transaction, suffit d'attribuer à la transaction, à la SqlCommand comme

sqlCommand.Transaction = transaction;

Et aussi il suffit d'utiliser une SqlCommand ne pas déclarer plus d'un, puisque les variables consomment de l'espace et nous sommes également sur le thème de rendre votre code plus efficace, faire que par l'affectation de commandText différents de la chaîne de requête et de les exécuter comme

sqlCommand.CommandText = "select * from table1";
sqlCommand.ExecuteNonQuery();
sqlCommand.CommandText = "select * from table2";
sqlCommand.ExecuteNonQuery();