Deadlock Detection in Distributed Systems: Deadlock victim not recognised when using two different SQL-Server on different machines

Question

I have a reproducible case where NO deadlock victim is detected.

The configuration is as follows:

• Database 1 runs on SQL Server 1 on Machine 1
• Database 2 runs on SQL Server 2 on Machine 2

The MSDTCs on Machine 1 and Machine 2 are configured correctly and transactions across multiple databases generally work without problems.

My program is written in C# and works with .NET Framework 4.8. If I now open two TransactionScopes and perform CRUD operations between Database 1 and Database 2, a deadlock occurs, which is not recognized by the MSDTCs. Both TransactionScopes block until the database connection times out, which throws an exception.

The same situation with the following configuration results in the MSDTC correctly detecting a deadlock and determining a deadlock victim. One TransactionScope can complete and the other fails immediately because of the deadlock victim exception:

• Database 1 runs on SQL Server 1 on Machine 1
• Database 2 runs on SQL Server 1 on Machine 1

The only difference is that in the second case only one MSDTC is involved in the transactions. I suspect that in the first case the deadlock situation is not recognized because two MSDTC are involved. Is there a configuration for the MSDTC that I need to apply so that all deadlocks are detected?

My Code looks like this:

public class TransactionProblem
{        
    private readonly AutoResetEvent _are = new AutoResetEvent(false);

    public void Execute()
    {
        var task_A = new Task(ExecuteTransaction);
        var task_B = new Task(ExecuteTransaction);

        // start task_A
        task_A.Start();

        // start stask_B -> wait until task_A triggers the signal to force the deadlock
        _are.WaitOne(); 
        task_B.Start();

        // wait for both tasks to be completed
        Task.WaitAll(task_A, task_B);
    }

    private void ExecuteTransaction()
    {
        // local helper method
        TransactionScope CreateTransactionScope()
        {
            var transactionScopeOptions = new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead };
            return new TransactionScope(TransactionScopeOption.Required, transactionScopeOptions);
        }

        using (var scope = CreateTransactionScope())
        {
            using (Context contextSrc = UnitOfWorkFactory.CreateForeignDb())
            {
                using (Context contextDst = UnitOfWorkFactory.CreateOwnDb())
                {
                    // update data
                    var item = contextSrc.MyTable.Where(t => t.State == 1).FirstOrDefault();
                    var itemToUpdate = contextDst.MyTable.Where(i => item.Id == i.Id).FirstOrDefault(); // here task_B waits for task_A
                    itemToUpdate.Amount = item.Amount;
                    item.State = 0;

                    // save destination DB
                    contextDst.ChangeTracker.DetectChanges();
                    contextDst.SaveChanges();
                }

                _are.Set();
                // wait to give task_B the chance to execute the "update data" code above to force the deadlock
                Thread.Sleep(1000);

                // save source DB
                contextSrc.ChangeTracker.DetectChanges();
                contextSrc.SaveChanges(); // here task_A waits for task_B
            }

            scope.Complete();
        }
    }
}

My Entity looks like this:

public class MyTable
{
    [Key]
    public Guid Id { get; set; }        
    public short Amount { get; set; }
    public byte State { get; set; }
}

SQL-Server Activity Monitor:

Deadlock Victim will be detected:

Deadlock Victim will be NOT detected: