Quelle est la raison du “contexte de Transaction en cours d'utilisation par une autre session”

C'est un peu tard pour la réponse 🙂 mais espérons qu'il sera utile pour les autres.
Réponse contient trois parties:

1. Que signifie "contexte de Transaction en cours d'utilisation par une autre session".
2. Comment reproduire l'erreur "contexte de Transaction en cours d'utilisation par une autre session".

1. Que signifie le "contexte de Transaction en cours d'utilisation par une autre session."

Avis Important: le contexte de Transaction verrou est acquis juste avant et immédiatement libéré après que l'interaction entre SqlConnection et SQL Server.

Lorsque vous exécuter une Requête SQL, SqlConnection "regards" est-il une opération d'emballage. Il peut être SqlTransaction ("native" pour SqlConnection) ou Transaction de System.Transactions de l'assemblée.

Lors de la transaction de trouvé SqlConnection l'utilise pour communiquer avec SQL Server et au moment où ils communiquer Transaction contexte est exclusivement verrouillé.

Ce n' TransactionScope? Il crée Transaction et fournit .NET Framework de Composants informations à ce sujet, donc tout le monde y compris SqlConnection peut (et doit) utiliser.

Donc déclarer TransactionScope nous sommes en train de créer de nouvelles Transactions qui sont disponibles pour tous "transactable" objets instanciés dans le courant Thread.

Décrit erreur signifie que le suivant:

1. Nous avons créé plusieurs SqlConnections sous le même TransactionContext (ce qui signifie qu'elles ont trait à la même transaction)
2. Nous avons demandé à ces SqlConnection pour communiquer avec SQL Server simultanément
3. L'un d'eux verrouillé actuel Transaction contexte et la prochaine avaient envoyé erreur

2. Comment reproduire l'erreur "contexte de Transaction en cours d'utilisation par une autre session."

Tout d'abord, le contexte de transaction est utilisé ("verrouillé") au moment même de l'exécution d'une commande sql. Il est donc difficile à reproduire ce comportement sûr.

Mais nous pouvons essayer de le faire par le démarrage de plusieurs threads d'exécution relativement long SQL opérations effectuées en vertu de la transaction unique.
Nous allons préparer la table [dbo].[Persons] dans [tests] Base de données:

USE [tests]
GO
DROP TABLE [dbo].[Persons]
GO
CREATE TABLE [dbo].[Persons](
[Id] [bigint] IDENTITY(1,1) NOT NULL PRIMARY KEY,
[Name] [nvarchar](1024) NOT NULL,
[Nick] [nvarchar](1024) NOT NULL,
[Email] [nvarchar](1024) NOT NULL)
GO
DECLARE @Counter INT
SET @Counter = 500
WHILE (@Counter > 0) BEGIN
INSERT [dbo].[Persons] ([Name], [Nick], [Email])
VALUES ('Sheev Palpatine', 'DarthSidious', '[email protected]')
SET @Counter = @Counter - 1
END
GO

Et de se reproduire "contexte de Transaction en cours d'utilisation par une autre session." erreur avec le code C# basé sur la Pie-grièche exemple de code

using System;
using System.Collections.Generic;
using System.Threading;
using System.Transactions;
using System.Data.SqlClient;
namespace SO.SQL.Transactions
{
public static class TxContextInUseRepro
{
const int Iterations = 100;
const int ThreadCount = 10;
const int MaxThreadSleep = 50;
const string ConnectionString = "Initial Catalog=tests;Data Source=.;" +
"User ID=testUser;PWD=Qwerty12;";
static readonly Random Rnd = new Random();
public static void Main()
{
var txOptions = new TransactionOptions();
txOptions.IsolationLevel = IsolationLevel.ReadCommitted;
using (var ctx = new TransactionScope(
TransactionScopeOption.Required, txOptions))
{
var current = Transaction.Current;
DependentTransaction dtx = current.DependentClone(
DependentCloneOption.BlockCommitUntilComplete);               
for (int i = 0; i < Iterations; i++)
{
// make the transaction distributed
using (SqlConnection con1 = new SqlConnection(ConnectionString))
using (SqlConnection con2 = new SqlConnection(ConnectionString))
{
con1.Open();
con2.Open();
}
var threads = new List<Thread>();
for (int j = 0; j < ThreadCount; j++)
{
Thread t1 = new Thread(o => WorkCallback(dtx));
threads.Add(t1);
t1.Start();
}
for (int j = 0; j < ThreadCount; j++)
threads[j].Join();
}
dtx.Complete();
ctx.Complete();
}
}
private static void WorkCallback(DependentTransaction dtx)
{
using (var txScope1 = new TransactionScope(dtx))
{
using (SqlConnection con2 = new SqlConnection(ConnectionString))
{
Thread.Sleep(Rnd.Next(MaxThreadSleep));
con2.Open();
using (var cmd = new SqlCommand("SELECT * FROM [dbo].[Persons]", con2))
using (cmd.ExecuteReader()) { } // simply recieve data
}
txScope1.Complete();
}
}
}
}

Et en guise de conclusion, quelques mots sur la mise en œuvre de l'appui de transaction dans votre application:

• Éviter les multi-thread des opérations de données, si c'est possible (peu importe le chargement ou la sauvegarde). E. g. enregistrer SELECT/UPDATE/etc... les demandes dans une seule file d'attente et à les servir avec un seul thread travailleur;
• Dans les applications multi-thread utiliser les transactions. Toujours. Partout. Même pour la lecture;
• Ne partagent pas seule transaction entre plusieurs threads. Il provoque d'étranges, non évidente, transcendantale et pas reproductible messages d'erreur:
  • "Contexte de Transaction en cours d'utilisation par une autre session.": de multiples interactions simultanées avec le serveur sous une transaction;
  • "Délai d'attente expiré. Le délai écoulé avant la fin de l'opération ou le serveur ne répond pas.": ne dépendant pas de transactions ont été effectuées;
  • "La transaction est dans le doute.";
  • ... et je suppose que beaucoup d'autres ...
• N'oubliez pas de définir le Niveau d'Isolation pour TransactionScope. Par défaut est Serializable mais dans la plupart des cas ReadCommitted est assez;
• Ne pas oublier de Terminer() TransactionScope et DependentTransaction

OriginalL'auteur Ilya Chidyakin

Prendre du recul et de se concentrer plus sur votre code et moins dans plusieurs threads info flottant autour.

Si votre scénario n'implique pas de filetage, il pourrait se rapportent à des œuvres qui ne sont pas fermés comme vous l'attendez.

Peut-être que le code sql que vous appelez n'a pas atteint la transaction de validation de l'instruction. Ou il y a autre chose à ce niveau. Peut-être que vous avez utilisé une occurrence de SqlConnection paramètre de la transaction dans le .net code, et réutilisez la même instance de l'autre code qui utilise la TransactionScope. Essayez de les ajouter à l'aide de() instructions le cas échéant, assurez-vous que tout est fermé, comme vous l'attendez.

OriginalL'auteur eglasius

Vous devez créer un DependentTransaction pour chaque thread, puis à l'intérieur de la thread créer & ouvrir la connexion db à l'intérieur d'un TransacctionScope à l'aide de la dependentTransaction dans le ctor.

            //client code / main thread
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, timeout))
{
Transaction currentTransaction = Transaction.Current;
currentTransaction.TransactionCompleted += OnCompleted;
DependentTransaction dependentTransaction;
int nWorkers = Config.Instance.NumDBComponentWorkers;
for (int i = 0; i < nWorkers; i++)
{
dependentTransaction = currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
this.startWorker(dependentTransaction);
}
do
{
//loop + wait
Thread.Sleep(150);
} while (this.status == DBComponentStatus.Running);
//No errors-commit transaction
if (this.status == DBComponentStatus.Finished && this.onCanCommit())
{
scope.Complete();
}
}
//workers
protected override void startWorker(DependentTransaction dependentTransaction)
{
Thread thread = new Thread(workerMethod);
thread.Start(dependentTransaction);
}
protected override void workerMethod(object transaction)
{
int executedStatements = 0;
DependentTransaction dependentTransaction;
dependentTransaction = transaction as DependentTransaction;
System.Diagnostics.Debug.Assert(dependentTransaction != null); //testing
try
{
//Transaction.Current = dependentTransaction;
using (TransactionScope scope = new TransactionScope(dependentTransaction))
{
using (SqlConnection conn = new SqlConnection(this.GetConnectionString(this.parameters)))
{
/* Perform transactional work here */
conn.Open();
string statement = string.Empty;
using (SqlCommand cmd = conn.CreateCommand())
{
}
}
//No errors-commit transaction
if (this.status == DBComponentStatus.Finished)
{
scope.Complete();
}
}
}
catch (Exception e)
{
this.status = DBComponentStatus.Aborted;
}
finally
{
dependentTransaction.Complete();
dependentTransaction.Dispose();
}
}

OriginalL'auteur Tochas