sanjaysingh · Oct 14, 2026
@@ -132,13 +132,12 @@ internal string InferredUserName
 
     /// <summary>
     /// A transaction object for this connector. Since only one transaction can be in progress at any given time,
-    /// this instance is recycled. To check whether a transaction is currently in progress on this connector,
-    /// see <see cref="TransactionStatus"/>.
+    /// a transaction that has not been disposed can be reused. A disposed transaction is not reused, so a later
+    /// dispose of the old reference cannot roll back a new transaction. To check whether a transaction is
+    /// currently in progress on this connector, see <see cref="TransactionStatus"/>.
     /// </summary>
     internal NpgsqlTransaction? Transaction { get; set; }
 
-    internal NpgsqlTransaction? UnboundTransaction { get; set; }
-
     /// <summary>
     /// The NpgsqlConnection that (currently) owns this connector. Null if the connector isn't
     /// owned (i.e. idle in the pool)

@@ -594,7 +594,11 @@ async ValueTask<NpgsqlTransaction> BeginTransaction(bool async, IsolationLevel l
         // But we start a user action to check the cancellation token and generate exceptions
         using var _ = connector.StartUserAction(cancellationToken);
 
-        connector.Transaction ??= new NpgsqlTransaction(connector);
+        // A disposed transaction stays disposed. Reusing it would make a later Dispose roll back
+        // whatever transaction now occupies that object (#6665).
+        if (connector.Transaction is null || connector.Transaction.IsDisposed)
+            connector.Transaction = new NpgsqlTransaction(connector);
+
         connector.Transaction.Init(level, options);
         return connector.Transaction;
     }

@@ -137,7 +137,7 @@ internal void Init(IsolationLevel isolationLevel, NpgsqlTransactionOptions optio
 
         _connector.TransactionStatus = TransactionStatus.Pending;
         _isolationLevel = isolationLevel;
-        IsDisposed = false;
+        Debug.Assert(!IsDisposed);
 
         LogMessages.StartedTransaction(_transactionLogger, isolationLevel, _connector.Id);
     }
@@ -355,7 +355,7 @@ protected override void Dispose(bool disposing)
                 }
             }
 
-            IsDisposed = true;
+            MarkDisposed();
         }
     }
 
@@ -371,7 +371,7 @@ public override ValueTask DisposeAsync()
                 return DisposeAsyncInternal();
             }
 
-            IsDisposed = true;
+            MarkDisposed();
         }
 
         return default;
@@ -390,7 +390,7 @@ async ValueTask DisposeAsyncInternal()
                 LogMessages.ExceptionDuringTransactionDispose(_transactionLogger, _connector.Id, ex);
             }
 
-            IsDisposed = true;
+            MarkDisposed();
         }
     }
 
@@ -400,8 +400,17 @@ async ValueTask DisposeAsyncInternal()
     /// </summary>
     internal void DisposeImmediately(Exception? disposeReason)
     {
-        IsDisposed = true;
         _disposeReason = disposeReason;
+        MarkDisposed();
+    }
+
+    // Drop the connector's reference so the next BeginTransaction allocates a new transaction
+    // instead of resurrecting this one.
+    void MarkDisposed()
+    {
+        IsDisposed = true;
+        if (_connector is not null && ReferenceEquals(_connector.Transaction, this))
+            _connector.Transaction = null;
     }
 
     #endregion
@@ -451,15 +460,7 @@ internal void UnbindIfNecessary()
         // See #3306
         if (!IsDisposed)
         {
-            if (_connector.UnboundTransaction is { IsDisposed: true } previousTransaction)
-            {
-                previousTransaction._connector = _connector;
-                _connector.Transaction = previousTransaction;
-            }
-            else
-                _connector.Transaction = null;
-
-            _connector.UnboundTransaction = this;
+            _connector.Transaction = null;
             _connector = null!;
         }
     }

@@ -181,6 +181,32 @@ public async Task Empty_Dispose()
         }
     }
 
+    [Test, Description("Disposing a transaction twice does not roll back a later transaction on the same pooled connector")]
+    public async Task Second_dispose_does_not_affect_a_later_transaction()
+    {
+        await using var dataSource = CreateDataSource(csb => csb.MaxPoolSize = 1);
+
+        NpgsqlTransaction first;
+        await using (var conn = await dataSource.OpenConnectionAsync())
+        {
+            first = await conn.BeginTransactionAsync();
+            await first.CommitAsync();
+            await first.DisposeAsync();
+        }
+
+        await using (var conn = await dataSource.OpenConnectionAsync())
+        {
+            var second = await conn.BeginTransactionAsync();
+            Assert.That(second, Is.Not.SameAs(first));
+
+            await first.DisposeAsync();
+            first.Dispose();
+
+            Assert.That(second.IsCompleted, Is.False);
+            await second.CommitAsync();
+        }
+    }
+
     [Test, Description("Tests that the isolation levels are properly supported")]
     [TestCase(IsolationLevel.ReadCommitted,   "read committed")]
     [TestCase(IsolationLevel.ReadUncommitted, "read uncommitted")]
@@ -651,7 +677,8 @@ public async Task Unbound_transaction_reuse()
         var tx3 = conn3.BeginTransaction();
         await using (var ___ = tx3)
         {
-            Assert.That(tx3, Is.SameAs(tx1));
+            // A disposed transaction is not recycled onto the next begin (#6665).
+            Assert.That(tx3, Is.Not.SameAs(tx1));
             using var cmd3 = conn3.CreateCommand();
             cmd3.CommandText = $"INSERT INTO {table} (name) VALUES ('Z'); SELECT 3";
             await using (var reader3 = await cmd3.ExecuteReaderAsync())