TransactionScope et transactions

Dans mon code C#, je suis en utilisant TransactionScope parce que je a dit de ne pas compter que mon programmeurs sql sera toujours utiliser les transactions et nous sommes responsables et yada yada.

Avoir dit que

Il ressemble TransactionScope objet Rouleaux de retour avant la SqlTransaction? Est-ce possible et si oui quel est la bonne méthodologie pour l'emballage d'une TransactionScope dans une transaction.

Voici le sql test

CREATE PROC ThrowError
AS

BEGIN TRANSACTION --SqlTransaction
SELECT 1/0

IF @@ERROR<> 0
BEGIN
  ROLLBACK TRANSACTION --SqlTransaction
  RETURN -1 
END
ELSE
BEGIN
  COMMIT TRANSACTION --SqlTransaction
  RETURN 0
END

go

DECLARE @RESULT INT

EXEC @RESULT = ThrowError

SELECT @RESULT

Et si je l'exécute j'ai juste le diviser par 0 et renvoie -1

Appeler du code C# je obtenir un supplément de message d'erreur

Erreur de division par zéro rencontrés.
nombre de Transactions après EXECUTE indique qu'un COMMIT ou ROLLBACK TRANSACTION essage est manquant. Précédent count = 1, compteur = 0.

Si je donne de la transaction sql un nom, puis

Ne peut pas revenir SqlTransaction.
Aucune transaction ou point d'enregistrement de ce nom a été trouvé.
Nombre de transactions après EXECUTE indique qu'un COMMIT ou ROLLBACK
Déclaration de la TRANSACTION est manquant. Précédent count = 1, compteur = 2.

à certains moments, il semble que le comte monte, jusqu'à ce que l'application soit complètement sorti de l'

Le c# est juste

        using (TransactionScope scope = new TransactionScope())
        {
             ... Execute Sql 

             scope.Commit()
         }

EDIT:

Le code sql doit travailler pour 2000 et 2005

source d'informationauteur Mike

c#sql transactions

Il y avait une mise à jour de masse pour la gestion d'erreur dans SQL Server 2005. Ces articles sont assez vastes: Gestion des erreurs de SQL 2005 et plus Tard par Erland Sommarskog et La gestion d'erreur dans SQL 2000 – un arrière-plan par Erland Sommarskog

La meilleure façon est quelque chose comme ceci:

Créer votre procédure stockée comme:

CREATE PROCEDURE YourProcedure
AS
BEGIN TRY
    BEGIN TRANSACTION --SqlTransaction
    DECLARE @ReturnValue int
    SET @ReturnValue=NULL

    IF (DAY(GETDATE())=1 --logical error
    BEGIN
        SET @ReturnValue=5
        RAISERROR('Error, first day of the month!',16,1) --send control to the BEGIN CATCH block
    END

    SELECT 1/0  --actual hard error

    COMMIT TRANSACTION --SqlTransaction
    RETURN 0

END TRY
BEGIN CATCH
    IF XACT_STATE()!=0
    BEGIN
        ROLLBACK TRANSACTION --only rollback if a transaction is in progress
    END

    --will echo back the complete original error message to the caller
    --comment out if not needed
    DECLARE @ErrorMessage nvarchar(400), @ErrorNumber int, @ErrorSeverity int, @ErrorState int, @ErrorLine int

    SELECT @ErrorMessage = N'Error %d, Line %d, Message: '+ERROR_MESSAGE(),@ErrorNumber = ERROR_NUMBER(),@ErrorSeverity = ERROR_SEVERITY(),@ErrorState = ERROR_STATE(),@ErrorLine = ERROR_LINE()
    RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState, @ErrorNumber,@ErrorLine)

    RETURN ISNULL(@ReturnValue,1)

END CATCH

GO

mais seulement pour SQL Server 2005 et jusqu'. Sans utiliser les blocs TRY-CATCH dans SQL Server 2005, vous disposez d'une période très difficile de supprimer tous les messages que SQL Server renvoie. Le extra messages vous référer à sont causés par la nature de la façon dont les restaurations sont traitées à l'aide de @@trancount:

de http://www.sommarskog.se/error-handling-I.html#trancount

@@trancount est une variable globale qui
reflète le niveau d'imbrication des
des transactions. Chaque début de TRANSACTION
augmente @@trancount par 1, et chaque
COMMIT TRANSACTION diminue
@@trancount par 1. Rien n'est fait
engagé jusqu' @@trancount atteint 0.
ROLLBACK de la TRANSACTION est annulée
tout pour l'extérieur de COMMENCER
TRANSACTION (sauf si vous avez utilisé l'
assez exotique ENREGISTRER la TRANSACTION), et
les forces @@trancount à 0, ce qui concerne de
la valeur précédente.

Quand vous sortez d'une procédure stockée, si
@@trancount n'a pas la même
la valeur qu'il avait lors de la procédure
a commencé l'exécution, SQL Server génère
erreur 266. Cette erreur n'est pas relevée,
cependant, si la procédure est appelée
à partir d'un déclencheur, directement ou
indirectement. Ni est il a soulevé de si
vous êtes en cours d'exécution avec JEU IMPLICITE
LES TRANSACTIONS SUR

Si vous ne voulez pas d'obtenir le message d'avertissement concernant le nombre de transactions ne correspondent pas, vous devez n'avoir qu'une transaction ouverte à la fois. Pour ce faire, créez tous de votre procédure est comme ceci:

CREATE PROC YourProcedure
AS
DECLARE @SelfTransaction char(1)
SET @SelfTransaction='N'

IF @@trancount=0
BEGIN
    SET @SelfTransaction='Y'
    BEGIN TRANSACTION --SqlTransaction
END

SELECT 1/0

IF @@ERROR<> 0
BEGIN
    IF @SelfTransaction='Y'
    BEGIN
        ROLLBACK TRANSACTION --SqlTransaction
    END
    RETURN -1 
END
ELSE
BEGIN
    IF @SelfTransaction='Y'
    BEGIN
        COMMIT TRANSACTION --SqlTransaction
    END
    RETURN 0
END

GO

En faisant cela, vous seul problème les commandes de transactions si vous n'êtes pas déjà dans une transaction. Si vous code tous de vos procédures de cette façon, seule la procédure ou le code C# qui émet le début de TRANSACTION seront effectivement émettre le COMMIT/ROLLBACK et de la transaction compte toujours un match (vous n'obtiendrez pas une erreur).

en C# à partir de TransactionScope De Documentation De Classe:

static public int CreateTransactionScope(
string connectString1, string connectString2,
string commandText1, string commandText2)
{
//Initialize the return value to zero and create a StringWriter to display results.
int returnValue = 0;
System.IO.StringWriter writer = new System.IO.StringWriter();
try
{
//Create the TransactionScope to execute the commands, guaranteeing
//that both commands can commit or roll back as a single unit of work.
using (TransactionScope scope = new TransactionScope())
{
using (SqlConnection connection1 = new SqlConnection(connectString1))
{
//Opening the connection automatically enlists it in the 
//TransactionScope as a lightweight transaction.
connection1.Open();
//Create the SqlCommand object and execute the first command.
SqlCommand command1 = new SqlCommand(commandText1, connection1);
returnValue = command1.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command1: {0}", returnValue);
//If you get here, this means that command1 succeeded. By nesting
//the using block for connection2 inside that of connection1, you
//conserve server and network resources as connection2 is opened
//only when there is a chance that the transaction can commit.   
using (SqlConnection connection2 = new SqlConnection(connectString2))
{
//The transaction is escalated to a full distributed
//transaction when connection2 is opened.
connection2.Open();
//Execute the second command in the second database.
returnValue = 0;
SqlCommand command2 = new SqlCommand(commandText2, connection2);
returnValue = command2.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command2: {0}", returnValue);
}
}
//The Complete method commits the transaction. If an exception has been thrown,
//Complete is not  called and the transaction is rolled back.
scope.Complete();
}
}
catch (TransactionAbortedException ex)
{
writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message);
}
catch (ApplicationException ex)
{
writer.WriteLine("ApplicationException Message: {0}", ex.Message);
}
//Display messages.
Console.WriteLine(writer.ToString());
return returnValue;
}

Juste une pensée, mais vous pourriez être en mesure d'utiliser le TransactionAbortedException attraper pour obtenir l'erreur réelle et ignorer le nombre de transactions incompatibilité d'avertissement.

12

Ne pas utiliser les transactions dans les deux votre code C# et la sprocs. Un seul suffit. Qui presque toujours votre code C#, seulement, il sait ce que l'ensemble des mises à jour du dbase doit être rejeté ou commis dans son ensemble.
2

Pour la prise en charge de SQL Server 2000, l'utilisation TransactionScope pour rendre votre vie plus facile. Cependant, voir en bas pour pourquoi il a des limites.

Erreur SQL de manipulation avant d'TRY/CATCH est aléatoire. Erland article posté par KM explique la déclaration/champ d'application/lot abandon des erreurs, qui le rend si. En gros, le code peut tout simplement s'arrêter et vous êtes de gauche avec des verrous sur les rangs, etc.

C'est ce qui se passe au-dessus de votre restauration ne fonctionne pas si vous obtenez l'erreur 226 sur les transactions compte.

Si vous ne soutenir que SQL Server 2005+, puis utiliser TRY/CATCH qui intercepte toutes les erreurs et aussi l'utilisation de SET XACT_ABORT on. TRY/CATCH rend SQL Server beaucoup plus résistants et les pièges de toutes les erreurs d'exécution. SET XACT_ABORT on supprime également d'erreur 226 car il questions de restauration automatiquement et s'assure que tous les verrous sont relâchés.

BTW:

SÉLECTIONNEZ 1/0 est un excellent exemple de pourquoi vous devriez utiliser SQL pour la gestion des erreurs.

Utiliser un DataAdapter pour remplir
- une Table de données à partir d'une procédure stockée avec une sélection de 1/0 -> pas d'erreur interceptée
- un DataSet à partir d'une procédure stockée avec une sélection de 1/0 -> erreur interceptée
SQL TRY/CATCH face à cette...

Votre devez utiliser un try catch

BEGIN TRANSACTION --SqlTransaction
BEGIN TRY
SELECT 1/0
COMMIT TRANSACTION --SqlTransaction
RETURN 0
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION --SqlTransaction
RETURN -1 
END CATCH

Et cette question devrait répondre à votre question à propos de TransactionScope et les Restaurations
Comment TransactionScope roll back transactions?

public string ExecuteReader(string SqlText)
{
SqlCommand cmd;
string retrunValue = "";
try
{
c.Open();
cmd = new SqlCommand();
cmd.CommandType = CommandType.Text;                
cmd.Connection = c;
cmd.CommandText = SqlText;
retrunValue = Convert.ToString(cmd.ExecuteScalar());
c.Close();
}
catch (Exception SqlExc)
{
c.Close();
throw SqlExc;
}
return (retrunValue);
}

-1

Je sais que c'est un incroyablement banal suggestion, mais ne serait pas une bonne solution pour éviter la division par zéro en premier lieu? Assez bien toutes les opérations DML (insert, select, update) peut être réécrit pour éviter de diviser par des zéros à travers l'utilisation de CAS annuels.

Vous devez vous connecter pour publier un commentaire.