Estou tentando determinar o comportamento de várias conexões com o banco de dados em uma transação distribuída.

Eu tenho um processo de execução longo que gera uma série de threads e cada thread é responsável por gerenciar suas conexões com o banco de dados e coisas do tipo. Tudo isso é executado dentro do escopo da transação e cada thread é inscrito na transação por meio de umDependentTransaction objeto.

Quando fui colocar esse processo em paralelo, tive alguns problemas, a saber, que parece haver algum tipo de bloqueio que impede que as consultas sejam executadas ao mesmo tempo na transação.

O que eu gostaria de saber é como o coordenador de transações lida com consultas de várias conexões para o mesmo banco de dados e se é aconselhável transmitir um objeto de conexão entre threads?

Li que o MS SQL permite apenas uma conexão por transação, mas claramente posso criar e inicializar mais de uma conexão com o mesmo banco de dados na mesma transação. Simplesmente não consigo executar os threads em paralelo sem obter uma exceção "Contexto de transação em uso por outra sessão" ao abrir as conexões. O resultado é que as conexões precisam esperar para serem executadas em vez de executadas ao mesmo tempo e, no final, o código é executado até a conclusão, mas não há ganho líquido para segmentar o aplicativo devido a esse problema de bloqueio.

O código se parece com isso.

    Sub StartThreads()
        Using Scope As New TransactionScope
            Dim TL(100) As Tasks.Task
            Dim dTx As DependentTransaction
            For i As Int32 = 0 To 100
                Dim A(1) As Object
                dTx = CType(Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete), DependentTransaction)
                'A(0) = some_other_data
                A(1) = dTx 'the Dependent Transaction

                TL(i) = Tasks.Task.Factory.StartNew(AddressOf Me.ProcessData, A) 'Start the thread and add it to the array
            Next

            Tasks.Task.WaitAll(TL) 'Wait for threads to finish

            Scope.Complete()
        End Using
    End Sub
    Dim TransLock As New Object
    Sub ProcessData(ByVal A As Object)
        Dim DTX As DependentTransaction = A(1)
        Dim Trans As Transactions.TransactionScope
        Dim I As Int32
        Do While True
            Try
                SyncLock (TransLock)
                    Trans = New Transactions.TransactionScope(DTX, TimeSpan.FromMinutes(1))
                End SyncLock
                Exit Do
            Catch ex As TransactionAbortedException
                If ex.ToString.Contains("Failure while attempting to promote transaction") Then
                ElseIf ex.Message = "The transaction has aborted." Then
                    Throw New Exception(ex.ToString)
                    Exit Sub
                End If
                I += 1
                If I > 5 Then
                    Throw New Exception(ex.ToString)
                End If
            Catch ex As Exception

            End Try
            Thread.Sleep(10)
        Loop
        Using Trans
            Using DALS As New DAC.DALScope
                Do While True
                    Try
                        SyncLock (TransLock)
                            'This opens two connection to the same DB for later use.
                            DALS.CurrentDAL.OpenConnection(DAC.DAL.ConnectionList.FirstConnection)
                            DALS.CurrentDAL.OpenConnection(DAC.DAL.ConnectionList.SecondConnection)
                        End SyncLock
                        Exit Do
                    Catch ex As Exception
                        'This is usually where I find the bottleneck
                        '"Transaction context in use by another session" is the exception that I get
                        Thread.Sleep(100)
                    End Try
                Loop

                '*****************
                'Do some work here
                '*****************

                Trans.Complete()
            End Using
        End Using
        DTX.Complete()
    End Sub

EDITAR

Meus testes mostraram conclusivamente que isso simplesmente não pode ser feito. Mesmo se houver mais de uma conexão ou a mesma conexão for usada, todas as solicitações na transação ou as perguntas serão processadas seqüencialmente.

Talvez eles mudem esse comportamento no futuro.