From eee45ffef703527f727c159e32105d3dcc376148 Mon Sep 17 00:00:00 2001
From: Normen Scheiber <46715105+nscheibe@users.noreply.github.com>
Date: Wed, 30 Nov 2022 19:25:50 +0100
Subject: [PATCH] Added explicit setting of client session handle via
 parameter. (#70)

---
 .../TransactionCollectionTests.cs             |  671 ++++---
 src/Transactions/MongoDbEnlistmentScope.cs    |   87 +-
 src/Transactions/MongoTransactionClient.cs    |  439 ++---
 .../MongoTransactionCollection.cs             | 1693 +++++++++--------
 src/Transactions/MongoTransactionDatabase.cs  |  827 ++++----
 .../MongoTransactionFilteredCollection.cs     |   32 +-
 .../TransactionClientExtensions.cs            |   19 +-
 .../TransactionCollectionExtensions.cs        |   37 +-
 .../TransactionDatabaseExtensions.cs          |   19 +-
 src/Transactions/TransactionStore.cs          |   73 +-
 10 files changed, 1989 insertions(+), 1908 deletions(-)

diff --git a/src/Transactions.Tests/TransactionCollectionTests.cs b/src/Transactions.Tests/TransactionCollectionTests.cs
index 2cba1de..dd4b366 100644
--- a/src/Transactions.Tests/TransactionCollectionTests.cs
+++ b/src/Transactions.Tests/TransactionCollectionTests.cs
@@ -8,447 +8,446 @@
 using static System.Transactions.TransactionScopeAsyncFlowOption;
 using static System.Transactions.TransactionScopeOption;
 
-namespace MongoDB.Extensions.Transactions.Tests
+namespace MongoDB.Extensions.Transactions.Tests;
+
+public class TransactionCollectionTests : IClassFixture<MongoReplicaSetResource>
 {
-    public class TransactionCollectionTests : IClassFixture<MongoReplicaSetResource>
+    private readonly MongoReplicaSetResource _mongoResource;
+
+    public TransactionCollectionTests(MongoReplicaSetResource mongoResource)
     {
-        private readonly MongoReplicaSetResource _mongoResource;
+        _mongoResource = mongoResource;
+    }
 
-        public TransactionCollectionTests(MongoReplicaSetResource mongoResource)
-        {
-            _mongoResource = mongoResource;
-        }
+    [Fact]
+    public async Task Transaction_SuccessFull()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        var id = Guid.NewGuid();
 
-        [Fact]
-        public async Task Transaction_SuccessFull()
+
+        // act
+        using (var scope = new TransactionScope(Enabled))
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            var id = Guid.NewGuid();
+            User user = new(id, "Foo");
+            await collection.InsertOneAsync(user);
 
+            scope.Complete();
+        }
 
-            // act
-            using (var scope = new TransactionScope(Enabled))
+        // assert
+        Assert.Single(await collection.Find(x => x.Id == id).ToListAsync());
+    }
+
+    [Fact]
+    public async Task Transaction_Fails_WithException()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        var id = Guid.NewGuid();
+
+        // act
+        try
+        {
+            using (new TransactionScope(Enabled))
             {
                 User user = new(id, "Foo");
                 await collection.InsertOneAsync(user);
-
-                scope.Complete();
+                throw new InvalidOperationException();
             }
-
-            // assert
-            Assert.Single(await collection.Find(x => x.Id == id).ToListAsync());
         }
-
-        [Fact]
-        public async Task Transaction_Fails_WithException()
+        catch
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            var id = Guid.NewGuid();
+            // ignored
+        }
 
-            // act
-            try
-            {
-                using (new TransactionScope(Enabled))
-                {
-                    User user = new(id, "Foo");
-                    await collection.InsertOneAsync(user);
-                    throw new InvalidOperationException();
-                }
-            }
-            catch
+        // assert
+        Assert.Empty(await collection.Find(x => x.Id == id).ToListAsync());
+    }
+
+    [Fact]
+    public async Task Transaction_Fails_WithoutCommit()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        var id = Guid.NewGuid();
+
+        // act
+        try
+        {
+            using (new TransactionScope(Enabled))
             {
-                // ignored
+                User user = new(id, "Foo");
+                await collection.InsertOneAsync(user);
             }
-
-            // assert
-            Assert.Empty(await collection.Find(x => x.Id == id).ToListAsync());
         }
-
-        [Fact]
-        public async Task Transaction_Fails_WithoutCommit()
+        catch
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            var id = Guid.NewGuid();
+            // ignored
+        }
 
-            // act
-            try
-            {
-                using (new TransactionScope(Enabled))
-                {
-                    User user = new(id, "Foo");
-                    await collection.InsertOneAsync(user);
-                }
-            }
-            catch
-            {
-                // ignored
-            }
+        // assert
+        Assert.Empty(await collection.Find(x => x.Id == id).ToListAsync());
+    }
 
-            // assert
-            Assert.Empty(await collection.Find(x => x.Id == id).ToListAsync());
+    [Fact]
+    public async Task Transaction_Should_ReadChangesDuringTransaction()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        var id = Guid.NewGuid();
+        IReadOnlyList<User> users = Array.Empty<User>();
+
+        // act
+        using (new TransactionScope(Enabled))
+        {
+            User user = new User(id, "Foo3");
+            await collection.InsertOneAsync(user);
+            users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
         }
 
-        [Fact]
-        public async Task Transaction_Should_ReadChangesDuringTransaction()
+        // assert
+        Assert.Single(users);
+        Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+    }
+
+    [Fact]
+    public async Task NestedTransaction_Should_Succeed()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        using (var scope = new TransactionScope(Enabled))
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            var id = Guid.NewGuid();
-            IReadOnlyList<User> users = Array.Empty<User>();
-
-            // act
-            using (new TransactionScope(Enabled))
+            User user1 = new(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
+
+            using (var innerScope =
+                new TransactionScope(Enabled))
             {
-                User user = new User(id, "Foo3");
-                await collection.InsertOneAsync(user);
-                users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+                User user2 = new(Guid.NewGuid(), "Foo2");
+                await collection.InsertOneAsync(user2);
+                innerScope.Complete();
             }
 
-            // assert
-            Assert.Single(users);
-            Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_Should_Succeed()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
+        // assert
+        List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+        Assert.Equal(2, dbUsers.Count);
+    }
 
-            // act
-            using (var scope = new TransactionScope(Enabled))
+    [Fact]
+    public async Task NestedTransaction_InnerTransactionNotCommitted()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        TransactionAbortedException ex = await Assert.ThrowsAsync<TransactionAbortedException>(
+            async () =>
             {
-                User user1 = new(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
-
-                using (var innerScope =
-                    new TransactionScope(Enabled))
+                using (var scope = new TransactionScope(Enabled))
                 {
-                    User user2 = new(Guid.NewGuid(), "Foo2");
-                    await collection.InsertOneAsync(user2);
-                    innerScope.Complete();
-                }
+                    User user1 = new(Guid.NewGuid(), "Foo1");
+                    await collection.InsertOneAsync(user1);
 
-                scope.Complete();
-            }
+                    using (var innerScope =
+                        new TransactionScope(Enabled))
+                    {
+                        User user2 =
+                            new(Guid.NewGuid(), "Foo2");
+                        await collection.InsertOneAsync(user2);
+                    }
 
-            // assert
-            List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
-            Assert.Equal(2, dbUsers.Count);
-        }
+                    scope.Complete();
+                }
+            });
 
-        [Fact]
-        public async Task NestedTransaction_InnerTransactionNotCommitted()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-
-            // act
-            TransactionAbortedException ex = await Assert.ThrowsAsync<TransactionAbortedException>(
-                async () =>
+        // assert
+        Assert.Equal("The transaction has aborted.", ex.Message);
+        Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+    }
+
+    [Fact]
+    public async Task NestedTransaction_InnerThrowsException()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        TransactionAbortedException ex = await Assert.ThrowsAsync<TransactionAbortedException>(
+            async () =>
+            {
+                using (var scope = new TransactionScope(Enabled))
                 {
-                    using (var scope = new TransactionScope(Enabled))
-                    {
-                        User user1 = new(Guid.NewGuid(), "Foo1");
-                        await collection.InsertOneAsync(user1);
+                    User user1 = new(Guid.NewGuid(), "Foo1");
+                    await collection.InsertOneAsync(user1);
 
-                        using (var innerScope =
-                            new TransactionScope(Enabled))
+                    try
+                    {
+                        using (var innerScope = new TransactionScope(Enabled))
                         {
                             User user2 =
                                 new(Guid.NewGuid(), "Foo2");
                             await collection.InsertOneAsync(user2);
+                            throw new Exception();
                         }
-
-                        scope.Complete();
                     }
-                });
+                    catch
+                    {
+                    }
 
-            // assert
-            Assert.Equal("The transaction has aborted.", ex.Message);
-            Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
-        }
+                    scope.Complete();
+                }
+            });
 
-        [Fact]
-        public async Task NestedTransaction_InnerThrowsException()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-
-            // act
-            TransactionAbortedException ex = await Assert.ThrowsAsync<TransactionAbortedException>(
-                async () =>
-                {
-                    using (var scope = new TransactionScope(Enabled))
-                    {
-                        User user1 = new(Guid.NewGuid(), "Foo1");
-                        await collection.InsertOneAsync(user1);
+        // assert
+        Assert.Equal("The transaction has aborted.", ex.Message);
+        Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+    }
 
-                        try
-                        {
-                            using (var innerScope = new TransactionScope(Enabled))
-                            {
-                                User user2 =
-                                    new(Guid.NewGuid(), "Foo2");
-                                await collection.InsertOneAsync(user2);
-                                throw new Exception();
-                            }
-                        }
-                        catch
-                        {
-                        }
+    [Fact]
+    public async Task NestedTransaction_RequiresNew_Should_Succeed()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        await collection
+            .InsertOneAsync(new User(Guid.NewGuid(), "Foo2"));
+
+        // act
+        using (var scope = new TransactionScope(RequiresNew, Enabled))
+        {
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
 
-                        scope.Complete();
-                    }
-                });
+            using (var innerScope = new TransactionScope(RequiresNew, Enabled))
+            {
+                var user2 = new User(Guid.NewGuid(), "Foo2");
+                await collection.InsertOneAsync(user2);
+                innerScope.Complete();
+            }
 
-            // assert
-            Assert.Equal("The transaction has aborted.", ex.Message);
-            Assert.Empty(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_RequiresNew_Should_Succeed()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            await collection
-                .InsertOneAsync(new User(Guid.NewGuid(), "Foo2"));
-
-            // act
-            using (var scope = new TransactionScope(RequiresNew, Enabled))
-            {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
+        // assert
+        List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+        Assert.Equal(3, dbUsers.Count);
+    }
 
-                using (var innerScope = new TransactionScope(RequiresNew, Enabled))
-                {
-                    var user2 = new User(Guid.NewGuid(), "Foo2");
-                    await collection.InsertOneAsync(user2);
-                    innerScope.Complete();
-                }
+    [Fact]
+    public async Task NestedTransaction_RequiresNew_InnerTransactionNotCommitted()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
 
-                scope.Complete();
+        // act
+        using (var scope = new TransactionScope(RequiresNew, Enabled))
+        {
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
+
+            using (var innerScope = new TransactionScope(RequiresNew, Enabled))
+            {
+                var user2 = new User(Guid.NewGuid(), "Foo2");
+                await collection.InsertOneAsync(user2);
             }
 
-            // assert
-            List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
-            Assert.Equal(3, dbUsers.Count);
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_RequiresNew_InnerTransactionNotCommitted()
+        // assert
+        Assert.Single(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+    }
+
+    [Fact]
+    public async Task NestedTransaction_RequiresNew_InnerThrowsException()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        using (var scope = new TransactionScope(RequiresNew, Enabled))
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
 
-            // act
-            using (var scope = new TransactionScope(RequiresNew, Enabled))
+            try
             {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
-
                 using (var innerScope = new TransactionScope(RequiresNew, Enabled))
                 {
                     var user2 = new User(Guid.NewGuid(), "Foo2");
                     await collection.InsertOneAsync(user2);
+                    throw new Exception();
                 }
-
-                scope.Complete();
+            }
+            catch
+            {
             }
 
-            // assert
-            Assert.Single(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_RequiresNew_InnerThrowsException()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
+        // assert
+        Assert.Single(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+    }
 
-            // act
-            using (var scope = new TransactionScope(RequiresNew, Enabled))
-            {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
+    [Fact]
+    public async Task NestedTransaction_Suppress_Should_Succeed()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
 
-                try
-                {
-                    using (var innerScope = new TransactionScope(RequiresNew, Enabled))
-                    {
-                        var user2 = new User(Guid.NewGuid(), "Foo2");
-                        await collection.InsertOneAsync(user2);
-                        throw new Exception();
-                    }
-                }
-                catch
-                {
-                }
+        // act
+        using (var scope = new TransactionScope(TransactionScopeOption.Suppress, Enabled))
+        {
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
 
-                scope.Complete();
+            using (var innerScope = new TransactionScope(Enabled))
+            {
+                var user2 = new User(Guid.NewGuid(), "Foo2");
+                await collection.InsertOneAsync(user2);
+                innerScope.Complete();
             }
 
-            // assert
-            Assert.Single(await collection.Find(FilterDefinition<User>.Empty).ToListAsync());
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_Suppress_Should_Succeed()
+        // assert
+        List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+        Assert.Equal(2, dbUsers.Count);
+    }
+
+    [Fact]
+    public async Task NestedTransaction_Suppress_InnerTransactionNotCommitted()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        using (var scope =
+            new TransactionScope(TransactionScopeOption.Suppress, Enabled))
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
 
-            // act
-            using (var scope = new TransactionScope(TransactionScopeOption.Suppress, Enabled))
+            using (var innerScope =
+                new TransactionScope(TransactionScopeOption.Suppress, Enabled))
             {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
-
-                using (var innerScope = new TransactionScope(Enabled))
-                {
-                    var user2 = new User(Guid.NewGuid(), "Foo2");
-                    await collection.InsertOneAsync(user2);
-                    innerScope.Complete();
-                }
-
-                scope.Complete();
+                var user2 = new User(Guid.NewGuid(), "Foo2");
+                await collection.InsertOneAsync(user2);
             }
 
-            // assert
-            List<User> dbUsers = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
-            Assert.Equal(2, dbUsers.Count);
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task NestedTransaction_Suppress_InnerTransactionNotCommitted()
+        // assert
+        List<User> users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+        Assert.Equal(2, users.Count);
+    }
+
+    [Fact]
+    public async Task NestedTransaction_Suppress_InnerThrowsException()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+
+        // act
+        using (var scope =
+            new TransactionScope(TransactionScopeOption.Suppress, Enabled))
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
+            var user1 = new User(Guid.NewGuid(), "Foo1");
+            await collection.InsertOneAsync(user1);
 
-            // act
-            using (var scope =
-                new TransactionScope(TransactionScopeOption.Suppress, Enabled))
+            try
             {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
-
                 using (var innerScope =
                     new TransactionScope(TransactionScopeOption.Suppress, Enabled))
                 {
                     var user2 = new User(Guid.NewGuid(), "Foo2");
                     await collection.InsertOneAsync(user2);
+                    throw new Exception();
                 }
-
-                scope.Complete();
             }
-
-            // assert
-            List<User> users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
-            Assert.Equal(2, users.Count);
-        }
-
-        [Fact]
-        public async Task NestedTransaction_Suppress_InnerThrowsException()
-        {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-
-            // act
-            using (var scope =
-                new TransactionScope(TransactionScopeOption.Suppress, Enabled))
+            catch
             {
-                var user1 = new User(Guid.NewGuid(), "Foo1");
-                await collection.InsertOneAsync(user1);
-
-                try
-                {
-                    using (var innerScope =
-                        new TransactionScope(TransactionScopeOption.Suppress, Enabled))
-                    {
-                        var user2 = new User(Guid.NewGuid(), "Foo2");
-                        await collection.InsertOneAsync(user2);
-                        throw new Exception();
-                    }
-                }
-                catch
-                {
-                }
-
-                scope.Complete();
             }
 
-            // assert
-            List<User> users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
-            Assert.Equal(2, users.Count);
+            scope.Complete();
         }
 
-        [Fact]
-        public async Task Transaction_SuccessFull_Concurrent()
+        // assert
+        List<User> users = await collection.Find(FilterDefinition<User>.Empty).ToListAsync();
+        Assert.Equal(2, users.Count);
+    }
+
+    [Fact]
+    public async Task Transaction_SuccessFull_Concurrent()
+    {
+        // arrange
+        IMongoDatabase database = _mongoResource.CreateDatabase();
+        IMongoCollection<User> collection =
+            database.GetCollection<User>("users").AsTransactionCollection();
+        var tasks = new List<Task>();
+        const int taskCount = 10;
+        const int documentCount = 10;
+        await collection.InsertOneAsync(
+            new User(Guid.NewGuid(), "Foo"));
+
+        // act
+        for (var i = 0; i < taskCount; i++)
         {
-            // arrange
-            IMongoDatabase database = _mongoResource.CreateDatabase();
-            IMongoCollection<User> collection =
-                database.GetCollection<User>("users").AsTransactionCollection();
-            var tasks = new List<Task>();
-            const int taskCount = 10;
-            const int documentCount = 10;
-            await collection.InsertOneAsync(
-                new User(Guid.NewGuid(), "Foo"));
-
-            // act
-            for (var i = 0; i < taskCount; i++)
+            async Task task()
             {
-                async Task task()
+                for (var j = 0; j < documentCount; j++)
                 {
-                    for (var j = 0; j < documentCount; j++)
+                    using (var scope = new TransactionScope(Enabled))
                     {
-                        using (var scope = new TransactionScope(Enabled))
-                        {
-                            await collection.InsertOneAsync(
-                                new User(Guid.NewGuid(), "Foo"));
+                        await collection.InsertOneAsync(
+                            new User(Guid.NewGuid(), "Foo"));
 
-                            scope.Complete();
-                        }
+                        scope.Complete();
                     }
                 }
-
-                tasks.Add(task());
             }
 
-            await Task.WhenAll(tasks);
-
-            // assert
-            Assert.Equal(101, await collection.CountDocumentsAsync(FilterDefinition<User>.Empty));
+            tasks.Add(task());
         }
+
+        await Task.WhenAll(tasks);
+
+        // assert
+        Assert.Equal(101, await collection.CountDocumentsAsync(FilterDefinition<User>.Empty));
     }
 }
diff --git a/src/Transactions/MongoDbEnlistmentScope.cs b/src/Transactions/MongoDbEnlistmentScope.cs
index dc7b6bf..4c5fd62 100644
--- a/src/Transactions/MongoDbEnlistmentScope.cs
+++ b/src/Transactions/MongoDbEnlistmentScope.cs
@@ -1,63 +1,64 @@
 using System.Transactions;
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public class MongoDbEnlistmentScope : IEnlistmentNotification
 {
-    public class MongoDbEnlistmentScope : IEnlistmentNotification
-    {
-        public delegate void Unregister();
+    public delegate void Unregister();
+
+    private readonly Unregister _unregister;
+    private readonly IClientSessionHandle _sessionHandle;
 
-        private readonly Unregister _unregister;
-        private readonly IClientSessionHandle _sessionHandle;
+    public MongoDbEnlistmentScope(
+        IClientSessionHandle sessionHandle,
+        Unregister unregister)
+    {
+        _sessionHandle = sessionHandle;
+        _unregister = unregister;
+    }
 
-        public MongoDbEnlistmentScope(IClientSessionHandle sessionHandle, Unregister unregister)
+    public void Commit(Enlistment enlistment)
+    {
+        try
         {
-            _sessionHandle = sessionHandle;
-            _unregister = unregister;
+            _sessionHandle.CommitTransaction();
+            enlistment.Done();
         }
-
-        public void Commit(Enlistment enlistment)
+        finally
         {
-            try
-            {
-                _sessionHandle.CommitTransaction();
-                enlistment.Done();
-            }
-            finally
-            {
-                _unregister();
-            }
+            _unregister();
         }
+    }
 
-        public void InDoubt(Enlistment enlistment)
+    public void InDoubt(Enlistment enlistment)
+    {
+        try
         {
-            try
-            {
-                _sessionHandle.AbortTransaction();
-                enlistment.Done();
-            }
-            finally
-            {
-                _unregister();
-            }
+            _sessionHandle.AbortTransaction();
+            enlistment.Done();
         }
-
-        public void Prepare(PreparingEnlistment preparingEnlistment)
+        finally
         {
-            preparingEnlistment.Prepared();
+            _unregister();
         }
+    }
+
+    public void Prepare(PreparingEnlistment preparingEnlistment)
+    {
+        preparingEnlistment.Prepared();
+    }
 
-        public void Rollback(Enlistment enlistment)
+    public void Rollback(Enlistment enlistment)
+    {
+        try
+        {
+            _sessionHandle.AbortTransaction();
+            enlistment.Done();
+        }
+        finally
         {
-            try
-            {
-                _sessionHandle.AbortTransaction();
-                enlistment.Done();
-            }
-            finally
-            {
-                _unregister();
-            }
+            _unregister();
         }
     }
 }
diff --git a/src/Transactions/MongoTransactionClient.cs b/src/Transactions/MongoTransactionClient.cs
index c158cf5..4cbaccf 100644
--- a/src/Transactions/MongoTransactionClient.cs
+++ b/src/Transactions/MongoTransactionClient.cs
@@ -1,292 +1,307 @@
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson;
 using MongoDB.Driver;
 using MongoDB.Driver.Core.Clusters;
 
-namespace MongoDB.Extensions.Transactions
-{
-    public class MongoTransactionClient : IMongoClient
-    {
-        private readonly IMongoClient _client;
+namespace MongoDB.Extensions.Transactions;
 
-        public MongoTransactionClient(IMongoClient client)
-        {
-            _client = client;
-        }
+public class MongoTransactionClient : IMongoClient
+{
+    private readonly IMongoClient _client;
+    private readonly IClientSessionHandle? _clientSessionHandle;
 
-        public void DropDatabase(
-            string name,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _client.DropDatabase(session, name, cancellationToken);
-                return;
-            }
+    public MongoTransactionClient(IMongoClient client)
+    {
+        _client = client;
+    }
 
-            _client.DropDatabase(name, cancellationToken);
-        }
+    public MongoTransactionClient(
+        IMongoClient client,
+        IClientSessionHandle clientSessionHandle)
+    {
+        _client = client;
+        _clientSessionHandle = clientSessionHandle;
+    }
 
-        public void DropDatabase(
-            IClientSessionHandle session,
-            string name,
-            CancellationToken cancellationToken = default)
+    public void DropDatabase(
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             _client.DropDatabase(session, name, cancellationToken);
+            return;
         }
 
-        public Task DropDatabaseAsync(
-            string name,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.DropDatabaseAsync(session, name, cancellationToken);
-            }
+        _client.DropDatabase(name, cancellationToken);
+    }
 
-            return _client.DropDatabaseAsync(name, cancellationToken);
-        }
+    public void DropDatabase(
+        IClientSessionHandle session,
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        _client.DropDatabase(session, name, cancellationToken);
+    }
 
-        public Task DropDatabaseAsync(
-            IClientSessionHandle session,
-            string name,
-            CancellationToken cancellationToken = default)
+    public Task DropDatabaseAsync(
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.DropDatabaseAsync(session, name, cancellationToken);
         }
 
-        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings? settings = null)
-        {
-            return _client.GetDatabase(name, settings).AsTransactionDatabase();
-        }
-
-        public IAsyncCursor<string> ListDatabaseNames(CancellationToken cancellationToken = default)
-        {
-            return _client.ListDatabaseNames(cancellationToken);
-        }
+        return _client.DropDatabaseAsync(name, cancellationToken);
+    }
 
-        public IAsyncCursor<string> ListDatabaseNames(
-            ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabaseNames(session, options, cancellationToken);
-            }
+    public Task DropDatabaseAsync(
+        IClientSessionHandle session,
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.DropDatabaseAsync(session, name, cancellationToken);
+    }
 
-            return _client.ListDatabaseNames(options, cancellationToken);
-        }
+    public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings? settings = null)
+    {
+        return _client.GetDatabase(name, settings).AsTransactionDatabase();
+    }
 
-        public IAsyncCursor<string> ListDatabaseNames(
-            IClientSessionHandle session,
-            CancellationToken cancellationToken = default)
-        {
-            return _client.ListDatabaseNames(session, cancellationToken);
-        }
+    public IAsyncCursor<string> ListDatabaseNames(CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabaseNames(cancellationToken);
+    }
 
-        public IAsyncCursor<string> ListDatabaseNames(
-            IClientSessionHandle session,
-            ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<string> ListDatabaseNames(
+        ListDatabaseNamesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabaseNames(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabaseNamesAsync(session, cancellationToken);
-            }
-
-            return _client.ListDatabaseNamesAsync(cancellationToken);
-        }
+        return _client.ListDatabaseNames(options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
-            ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabaseNamesAsync(session, cancellationToken);
-            }
+    public IAsyncCursor<string> ListDatabaseNames(
+        IClientSessionHandle session,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabaseNames(session, cancellationToken);
+    }
 
-            return _client.ListDatabaseNamesAsync(options, cancellationToken);
-        }
+    public IAsyncCursor<string> ListDatabaseNames(
+        IClientSessionHandle session,
+        ListDatabaseNamesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabaseNames(session, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
-            IClientSessionHandle session,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabaseNamesAsync(session, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
-            IClientSessionHandle session,
-            ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            return _client.ListDatabaseNamesAsync(session, options, cancellationToken);
-        }
+        return _client.ListDatabaseNamesAsync(cancellationToken);
+    }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
+        ListDatabaseNamesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabases(session, cancellationToken);
-            }
-
-            return _client.ListDatabases(cancellationToken);
+            return _client.ListDatabaseNamesAsync(session, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(
-            ListDatabasesOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabases(session, options, cancellationToken);
-            }
+        return _client.ListDatabaseNamesAsync(options, cancellationToken);
+    }
 
-            return _client.ListDatabases(options, cancellationToken);
-        }
+    public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
+        IClientSessionHandle session,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabaseNamesAsync(session, cancellationToken);
+    }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(
-            IClientSessionHandle session,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
+        IClientSessionHandle session,
+        ListDatabaseNamesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabaseNamesAsync(session, options, cancellationToken);
+    }
+
+    public IAsyncCursor<BsonDocument> ListDatabases(
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabases(session, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(
-            IClientSessionHandle session,
-            ListDatabasesOptions options,
-            CancellationToken cancellationToken = default)
+        return _client.ListDatabases(cancellationToken);
+    }
+
+    public IAsyncCursor<BsonDocument> ListDatabases(
+        ListDatabasesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabases(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabasesAsync(session, cancellationToken);
-            }
-
-            return _client.ListDatabasesAsync(cancellationToken);
-        }
+        return _client.ListDatabases(options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
-            ListDatabasesOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.ListDatabasesAsync(session, options, cancellationToken);
-            }
+    public IAsyncCursor<BsonDocument> ListDatabases(
+        IClientSessionHandle session,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabases(session, cancellationToken);
+    }
 
-            return _client.ListDatabasesAsync(options, cancellationToken);
-        }
+    public IAsyncCursor<BsonDocument> ListDatabases(
+        IClientSessionHandle session,
+        ListDatabasesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabases(session, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
-            IClientSessionHandle session,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabasesAsync(session, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
-            IClientSessionHandle session,
-            ListDatabasesOptions options,
-            CancellationToken cancellationToken = default)
+        return _client.ListDatabasesAsync(cancellationToken);
+    }
+
+    public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
+        ListDatabasesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.ListDatabasesAsync(session, options, cancellationToken);
         }
 
-        public IClientSessionHandle StartSession(
-            ClientSessionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _client.StartSession(options, cancellationToken);
-        }
+        return _client.ListDatabasesAsync(options, cancellationToken);
+    }
 
-        public Task<IClientSessionHandle> StartSessionAsync(
-            ClientSessionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _client.StartSessionAsync(options, cancellationToken);
-        }
+    public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
+        IClientSessionHandle session,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabasesAsync(session, cancellationToken);
+    }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.Watch(session, pipeline, options, cancellationToken);
-            }
+    public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
+        IClientSessionHandle session,
+        ListDatabasesOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.ListDatabasesAsync(session, options, cancellationToken);
+    }
 
-            return _client.Watch(pipeline, options, cancellationToken);
-        }
+    public IClientSessionHandle StartSession(
+        ClientSessionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.StartSession(options, cancellationToken);
+    }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IClientSessionHandle> StartSessionAsync(
+        ClientSessionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.StartSessionAsync(options, cancellationToken);
+    }
+
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.Watch(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _client.WatchAsync(session, pipeline, options, cancellationToken);
-            }
+        return _client.Watch(pipeline, options, cancellationToken);
+    }
 
-            return _client.WatchAsync(pipeline, options, cancellationToken);
-        }
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.Watch(session, pipeline, options, cancellationToken);
+    }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _client.WatchAsync(session, pipeline, options, cancellationToken);
         }
 
-        public IMongoClient WithReadConcern(ReadConcern readConcern)
-        {
-            return _client.WithReadConcern(readConcern).AsTransactionClient();
-        }
-
-        public IMongoClient WithReadPreference(ReadPreference readPreference)
-        {
-            return _client.WithReadPreference(readPreference).AsTransactionClient();
-        }
+        return _client.WatchAsync(pipeline, options, cancellationToken);
+    }
 
-        public IMongoClient WithWriteConcern(WriteConcern writeConcern)
-        {
-            return _client.WithWriteConcern(writeConcern).AsTransactionClient();
-        }
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _client.WatchAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public ICluster Cluster => _client.Cluster;
+    public IMongoClient WithReadConcern(ReadConcern readConcern)
+    {
+        return _client.WithReadConcern(readConcern).AsTransactionClient();
+    }
 
-        public MongoClientSettings Settings => _client.Settings;
+    public IMongoClient WithReadPreference(ReadPreference readPreference)
+    {
+        return _client.WithReadPreference(readPreference).AsTransactionClient();
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool TryGetSession(out IClientSessionHandle sessionHandle) =>
-            TransactionStore.TryGetSession(_client, out sessionHandle);
+    public IMongoClient WithWriteConcern(WriteConcern writeConcern)
+    {
+        return _client.WithWriteConcern(writeConcern).AsTransactionClient();
     }
+
+    public ICluster Cluster => _client.Cluster;
+
+    public MongoClientSettings Settings => _client.Settings;
+
+    private bool TryGetSession(out IClientSessionHandle sessionHandle)
+    {
+        if (_clientSessionHandle is { } clientSessionHandle)
+        {
+            sessionHandle = clientSessionHandle;
+            return true;
+        }
+
+        return TransactionStore.TryGetSession(
+            _client, out sessionHandle);
+    }            
 }
diff --git a/src/Transactions/MongoTransactionCollection.cs b/src/Transactions/MongoTransactionCollection.cs
index 3c987ba..713d098 100644
--- a/src/Transactions/MongoTransactionCollection.cs
+++ b/src/Transactions/MongoTransactionCollection.cs
@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson;
@@ -8,1073 +7,1091 @@
 
 #pragma warning disable 618
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public class MongoTransactionCollection<T> : IMongoCollection<T>
 {
-    public class MongoTransactionCollection<T> : IMongoCollection<T>
+    private readonly IMongoCollection<T> _collection;
+    private readonly IClientSessionHandle? _clientSessionHandle;
+
+    public MongoTransactionCollection(
+        IMongoCollection<T> collection)
+    {
+        _collection = collection;
+    }
+
+    public MongoTransactionCollection(
+        IMongoCollection<T> collection,
+        IClientSessionHandle clientSessionHandle)
     {
-        private readonly IMongoCollection<T> _collection;
+        _collection = collection;
+        _clientSessionHandle = clientSessionHandle;
+    }
 
-        public MongoTransactionCollection(IMongoCollection<T> collection)
+    public IAsyncCursor<TResult> Aggregate<TResult>(
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _collection = collection;
+            return Aggregate(session, pipeline, options, cancellationToken);
         }
 
-        public IAsyncCursor<TResult> Aggregate<TResult>(
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return Aggregate(session, pipeline, options, cancellationToken);
-            }
+        return _collection.Aggregate(pipeline, options, cancellationToken);
+    }
 
-            return _collection.Aggregate(pipeline, options, cancellationToken);
-        }
+    public IAsyncCursor<TResult> Aggregate<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.Aggregate(session, pipeline, options, cancellationToken);
+    }
 
-        public IAsyncCursor<TResult> Aggregate<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.Aggregate(session, pipeline, options, cancellationToken);
+            return AggregateAsync(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return AggregateAsync(session, pipeline, options, cancellationToken);
-            }
+        return _collection.AggregateAsync(pipeline, options, cancellationToken);
+    }
 
-            return _collection.AggregateAsync(pipeline, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.AggregateAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public void AggregateToCollection<TResult>(
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.AggregateAsync(session, pipeline, options, cancellationToken);
+            AggregateToCollection(session, pipeline, options, cancellationToken);
+            return;
         }
 
-        public void AggregateToCollection<TResult>(
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                AggregateToCollection(session, pipeline, options, cancellationToken);
-                return;
-            }
+        _collection.AggregateToCollection(pipeline, options, cancellationToken);
+    }
 
-            _collection.AggregateToCollection(pipeline, options, cancellationToken);
-        }
+    public void AggregateToCollection<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _collection.AggregateToCollection(session, pipeline, options, cancellationToken);
+    }
 
-        public void AggregateToCollection<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task AggregateToCollectionAsync<TResult>(
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _collection.AggregateToCollection(session, pipeline, options, cancellationToken);
+            return AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
         }
 
-        public Task AggregateToCollectionAsync<TResult>(
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
-            }
+        return _collection.AggregateToCollectionAsync(pipeline, options, cancellationToken);
+    }
 
-            return _collection.AggregateToCollectionAsync(pipeline, options, cancellationToken);
-        }
+    public Task AggregateToCollectionAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<T, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.AggregateToCollectionAsync(session,
+            pipeline,
+            options,
+            cancellationToken);
+    }
 
-        public Task AggregateToCollectionAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<T, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public BulkWriteResult<T> BulkWrite(
+        IEnumerable<WriteModel<T>> requests,
+        BulkWriteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.AggregateToCollectionAsync(session,
-                pipeline,
-                options,
-                cancellationToken);
+            return BulkWrite(session, requests, options, cancellationToken);
         }
 
-        public BulkWriteResult<T> BulkWrite(
-            IEnumerable<WriteModel<T>> requests,
-            BulkWriteOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return BulkWrite(session, requests, options, cancellationToken);
-            }
+        return _collection.BulkWrite(requests, options, cancellationToken);
+    }
 
-            return _collection.BulkWrite(requests, options, cancellationToken);
-        }
+    public BulkWriteResult<T> BulkWrite(
+        IClientSessionHandle session,
+        IEnumerable<WriteModel<T>> requests,
+        BulkWriteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.BulkWrite(session, requests, options, cancellationToken);
+    }
 
-        public BulkWriteResult<T> BulkWrite(
-            IClientSessionHandle session,
-            IEnumerable<WriteModel<T>> requests,
-            BulkWriteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<BulkWriteResult<T>> BulkWriteAsync(
+        IEnumerable<WriteModel<T>> requests,
+        BulkWriteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.BulkWrite(session, requests, options, cancellationToken);
+            return BulkWriteAsync(session, requests, options, cancellationToken);
         }
 
-        public Task<BulkWriteResult<T>> BulkWriteAsync(
-            IEnumerable<WriteModel<T>> requests,
-            BulkWriteOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return BulkWriteAsync(session, requests, options, cancellationToken);
-            }
+        return _collection.BulkWriteAsync(requests, options, cancellationToken);
+    }
 
-            return _collection.BulkWriteAsync(requests, options, cancellationToken);
-        }
+    public Task<BulkWriteResult<T>> BulkWriteAsync(
+        IClientSessionHandle session,
+        IEnumerable<WriteModel<T>> requests,
+        BulkWriteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.BulkWriteAsync(session, requests, options, cancellationToken);
+    }
 
-        public Task<BulkWriteResult<T>> BulkWriteAsync(
-            IClientSessionHandle session,
-            IEnumerable<WriteModel<T>> requests,
-            BulkWriteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public long Count(
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.BulkWriteAsync(session, requests, options, cancellationToken);
+            return Count(session, filter, options, cancellationToken);
         }
 
-        public long Count(
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return Count(session, filter, options, cancellationToken);
-            }
+        return _collection.Count(filter, options, cancellationToken);
+    }
 
-            return _collection.Count(filter, options, cancellationToken);
-        }
+    public long Count(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.Count(session, filter, options, cancellationToken);
+    }
 
-        public long Count(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<long> CountAsync(
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.Count(session, filter, options, cancellationToken);
+            return CountAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<long> CountAsync(
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return CountAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.CountAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.CountAsync(filter, options, cancellationToken);
-        }
+    public Task<long> CountAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.CountAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<long> CountAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public long CountDocuments(
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.CountAsync(session, filter, options, cancellationToken);
+            return CountDocuments(session, filter, options, cancellationToken);
         }
 
-        public long CountDocuments(
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return CountDocuments(session, filter, options, cancellationToken);
-            }
+        return _collection.CountDocuments(filter, options, cancellationToken);
+    }
 
-            return _collection.CountDocuments(filter, options, cancellationToken);
-        }
+    public long CountDocuments(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.CountDocuments(session, filter, options, cancellationToken);
+    }
 
-        public long CountDocuments(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<long> CountDocumentsAsync(
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.CountDocuments(session, filter, options, cancellationToken);
+            return CountDocumentsAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<long> CountDocumentsAsync(
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return CountDocumentsAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.CountDocumentsAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.CountDocumentsAsync(filter, options, cancellationToken);
-        }
+    public Task<long> CountDocumentsAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        CountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.CountDocumentsAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<long> CountDocumentsAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            CountOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public DeleteResult DeleteMany(
+        FilterDefinition<T> filter,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.CountDocumentsAsync(session, filter, options, cancellationToken);
+            return DeleteMany(session, filter, cancellationToken: cancellationToken);
         }
 
-        public DeleteResult DeleteMany(
-            FilterDefinition<T> filter,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteMany(session, filter, cancellationToken: cancellationToken);
-            }
+        return _collection.DeleteMany(filter, cancellationToken);
+    }
 
-            return _collection.DeleteMany(filter, cancellationToken);
+    public DeleteResult DeleteMany(
+        FilterDefinition<T> filter,
+        DeleteOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return DeleteMany(session, filter, options, cancellationToken);
         }
 
-        public DeleteResult DeleteMany(
-            FilterDefinition<T> filter,
-            DeleteOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteMany(session, filter, options, cancellationToken);
-            }
+        return _collection.DeleteMany(filter, options, cancellationToken);
+    }
 
-            return _collection.DeleteMany(filter, options, cancellationToken);
-        }
+    public DeleteResult DeleteMany(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        DeleteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.DeleteMany(session, filter, options, cancellationToken);
+    }
 
-        public DeleteResult DeleteMany(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            DeleteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<DeleteResult> DeleteManyAsync(
+        FilterDefinition<T> filter,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.DeleteMany(session, filter, options, cancellationToken);
+            return DeleteManyAsync(session, filter, cancellationToken: cancellationToken);
         }
 
-        public Task<DeleteResult> DeleteManyAsync(
-            FilterDefinition<T> filter,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteManyAsync(session, filter, cancellationToken: cancellationToken);
-            }
+        return _collection.DeleteManyAsync(filter, cancellationToken);
+    }
 
-            return _collection.DeleteManyAsync(filter, cancellationToken);
+    public Task<DeleteResult> DeleteManyAsync(
+        FilterDefinition<T> filter,
+        DeleteOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return DeleteManyAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<DeleteResult> DeleteManyAsync(
-            FilterDefinition<T> filter,
-            DeleteOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteManyAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.DeleteManyAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.DeleteManyAsync(filter, options, cancellationToken);
-        }
+    public Task<DeleteResult> DeleteManyAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        DeleteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.DeleteManyAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<DeleteResult> DeleteManyAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            DeleteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public DeleteResult DeleteOne(
+        FilterDefinition<T> filter,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.DeleteManyAsync(session, filter, options, cancellationToken);
+            return DeleteOne(session, filter, cancellationToken: cancellationToken);
         }
 
-        public DeleteResult DeleteOne(
-            FilterDefinition<T> filter,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteOne(session, filter, cancellationToken: cancellationToken);
-            }
+        return _collection.DeleteOne(filter, cancellationToken);
+    }
 
-            return _collection.DeleteOne(filter, cancellationToken);
+    public DeleteResult DeleteOne(
+        FilterDefinition<T> filter,
+        DeleteOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return DeleteOne(session, filter, options, cancellationToken);
         }
 
-        public DeleteResult DeleteOne(
-            FilterDefinition<T> filter,
-            DeleteOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteOne(session, filter, options, cancellationToken);
-            }
+        return _collection.DeleteOne(filter, options, cancellationToken);
+    }
 
-            return _collection.DeleteOne(filter, options, cancellationToken);
-        }
+    public DeleteResult DeleteOne(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        DeleteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.DeleteOne(session, filter, options, cancellationToken);
+    }
 
-        public DeleteResult DeleteOne(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            DeleteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<DeleteResult> DeleteOneAsync(
+        FilterDefinition<T> filter,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.DeleteOne(session, filter, options, cancellationToken);
+            return DeleteOneAsync(session, filter, cancellationToken: cancellationToken);
         }
 
-        public Task<DeleteResult> DeleteOneAsync(
-            FilterDefinition<T> filter,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteOneAsync(session, filter, cancellationToken: cancellationToken);
-            }
+        return _collection.DeleteOneAsync(filter, cancellationToken);
+    }
 
-            return _collection.DeleteOneAsync(filter, cancellationToken);
+    public Task<DeleteResult> DeleteOneAsync(
+        FilterDefinition<T> filter,
+        DeleteOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return DeleteOneAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<DeleteResult> DeleteOneAsync(
-            FilterDefinition<T> filter,
-            DeleteOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DeleteOneAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.DeleteOneAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.DeleteOneAsync(filter, options, cancellationToken);
-        }
+    public Task<DeleteResult> DeleteOneAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        DeleteOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.DeleteOneAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<DeleteResult> DeleteOneAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            DeleteOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<TField> Distinct<TField>(
+        FieldDefinition<T, TField> field,
+        FilterDefinition<T> filter,
+        DistinctOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.DeleteOneAsync(session, filter, options, cancellationToken);
+            return Distinct(session, field, filter, options, cancellationToken);
         }
 
-        public IAsyncCursor<TField> Distinct<TField>(
-            FieldDefinition<T, TField> field,
-            FilterDefinition<T> filter,
-            DistinctOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return Distinct(session, field, filter, options, cancellationToken);
-            }
+        return _collection.Distinct(field, filter, options, cancellationToken);
+    }
 
-            return _collection.Distinct(field, filter, options, cancellationToken);
-        }
+    public IAsyncCursor<TField> Distinct<TField>(
+        IClientSessionHandle session,
+        FieldDefinition<T, TField> field,
+        FilterDefinition<T> filter,
+        DistinctOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.Distinct(session, field, filter, options, cancellationToken);
+    }
 
-        public IAsyncCursor<TField> Distinct<TField>(
-            IClientSessionHandle session,
-            FieldDefinition<T, TField> field,
-            FilterDefinition<T> filter,
-            DistinctOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(
+        FieldDefinition<T, TField> field,
+        FilterDefinition<T> filter,
+        DistinctOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.Distinct(session, field, filter, options, cancellationToken);
+            return DistinctAsync(session, field, filter, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<TField>> DistinctAsync<TField>(
-            FieldDefinition<T, TField> field,
-            FilterDefinition<T> filter,
-            DistinctOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return DistinctAsync(session, field, filter, options, cancellationToken);
-            }
+        return _collection.DistinctAsync(field, filter, options, cancellationToken);
+    }
 
-            return _collection.DistinctAsync(field, filter, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(
+        IClientSessionHandle session,
+        FieldDefinition<T, TField> field,
+        FilterDefinition<T> filter,
+        DistinctOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.DistinctAsync(session, field, filter, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<TField>> DistinctAsync<TField>(
-            IClientSessionHandle session,
-            FieldDefinition<T, TField> field,
-            FilterDefinition<T> filter,
-            DistinctOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.DistinctAsync(session, field, filter, options, cancellationToken);
-        }
+    public long EstimatedDocumentCount(
+        EstimatedDocumentCountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.EstimatedDocumentCount(options, cancellationToken);
+    }
 
-        public long EstimatedDocumentCount(
-            EstimatedDocumentCountOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.EstimatedDocumentCount(options, cancellationToken);
-        }
+    public Task<long> EstimatedDocumentCountAsync(
+        EstimatedDocumentCountOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.EstimatedDocumentCountAsync(options, cancellationToken);
+    }
 
-        public Task<long> EstimatedDocumentCountAsync(
-            EstimatedDocumentCountOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<TProjection> FindSync<TProjection>(
+        FilterDefinition<T> filter,
+        FindOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.EstimatedDocumentCountAsync(options, cancellationToken);
+            return FindSync(session, filter, options, cancellationToken);
         }
 
-        public IAsyncCursor<TProjection> FindSync<TProjection>(
-            FilterDefinition<T> filter,
-            FindOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindSync(session, filter, options, cancellationToken);
-            }
+        return _collection.FindSync(filter, options, cancellationToken);
+    }
 
-            return _collection.FindSync(filter, options, cancellationToken);
-        }
+    public IAsyncCursor<TProjection> FindSync<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        FindOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindSync(session, filter, options, cancellationToken);
+    }
 
-        public IAsyncCursor<TProjection> FindSync<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            FindOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(
+        FilterDefinition<T> filter,
+        FindOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindSync(session, filter, options, cancellationToken);
+            return FindAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(
-            FilterDefinition<T> filter,
-            FindOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.FindAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.FindAsync(filter, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        FindOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            FindOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public TProjection FindOneAndDelete<TProjection>(
+        FilterDefinition<T> filter,
+        FindOneAndDeleteOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindAsync(session, filter, options, cancellationToken);
+            return FindOneAndDelete(session, filter, options, cancellationToken);
         }
 
-        public TProjection FindOneAndDelete<TProjection>(
-            FilterDefinition<T> filter,
-            FindOneAndDeleteOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndDelete(session, filter, options, cancellationToken);
-            }
+        return _collection.FindOneAndDelete(filter, options, cancellationToken);
+    }
 
-            return _collection.FindOneAndDelete(filter, options, cancellationToken);
-        }
+    public TProjection FindOneAndDelete<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        FindOneAndDeleteOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndDelete(session, filter, options, cancellationToken);
+    }
 
-        public TProjection FindOneAndDelete<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            FindOneAndDeleteOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(
+        FilterDefinition<T> filter,
+        FindOneAndDeleteOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndDelete(session, filter, options, cancellationToken);
+            return FindOneAndDeleteAsync(session, filter, options, cancellationToken);
         }
 
-        public Task<TProjection> FindOneAndDeleteAsync<TProjection>(
-            FilterDefinition<T> filter,
-            FindOneAndDeleteOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndDeleteAsync(session, filter, options, cancellationToken);
-            }
+        return _collection.FindOneAndDeleteAsync(filter, options, cancellationToken);
+    }
 
-            return _collection.FindOneAndDeleteAsync(filter, options, cancellationToken);
-        }
+    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        FindOneAndDeleteOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndDeleteAsync(session, filter, options, cancellationToken);
+    }
 
-        public Task<TProjection> FindOneAndDeleteAsync<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            FindOneAndDeleteOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public TProjection FindOneAndReplace<TProjection>(
+        FilterDefinition<T> filter,
+        T replacement,
+        FindOneAndReplaceOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndDeleteAsync(session, filter, options, cancellationToken);
+            return FindOneAndReplace(session, filter, replacement, options, cancellationToken);
         }
 
-        public TProjection FindOneAndReplace<TProjection>(
-            FilterDefinition<T> filter,
-            T replacement,
-            FindOneAndReplaceOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndReplace(session, filter, replacement, options, cancellationToken);
-            }
+        return _collection.FindOneAndReplace(filter, replacement, options, cancellationToken);
+    }
 
-            return _collection.FindOneAndReplace(filter, replacement, options, cancellationToken);
-        }
+    public TProjection FindOneAndReplace<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        FindOneAndReplaceOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndReplace(session,
+            filter,
+            replacement,
+            options,
+            cancellationToken);
+    }
 
-        public TProjection FindOneAndReplace<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            FindOneAndReplaceOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(
+        FilterDefinition<T> filter,
+        T replacement,
+        FindOneAndReplaceOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndReplace(session,
+            return FindOneAndReplaceAsync(session,
                 filter,
                 replacement,
                 options,
                 cancellationToken);
         }
 
-        public Task<TProjection> FindOneAndReplaceAsync<TProjection>(
-            FilterDefinition<T> filter,
-            T replacement,
-            FindOneAndReplaceOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndReplaceAsync(session,
-                    filter,
-                    replacement,
-                    options,
-                    cancellationToken);
-            }
-
-            return _collection.FindOneAndReplaceAsync(filter,
-                replacement,
-                options,
-                cancellationToken);
-        }
+        return _collection.FindOneAndReplaceAsync(filter,
+            replacement,
+            options,
+            cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        FindOneAndReplaceOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndReplaceAsync(
+            session,
+            filter,
+            replacement,
+            options,
+            cancellationToken);
+    }
 
-        public Task<TProjection> FindOneAndReplaceAsync<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            FindOneAndReplaceOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public TProjection FindOneAndUpdate<TProjection>(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        FindOneAndUpdateOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndReplaceAsync(session,
-                filter,
-                replacement,
-                options,
-                cancellationToken);
+            return FindOneAndUpdate(session, filter, update, options, cancellationToken);
         }
 
-        public TProjection FindOneAndUpdate<TProjection>(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            FindOneAndUpdateOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndUpdate(session, filter, update, options, cancellationToken);
-            }
+        return _collection.FindOneAndUpdate(filter, update, options, cancellationToken);
+    }
 
-            return _collection.FindOneAndUpdate(filter, update, options, cancellationToken);
-        }
+    public TProjection FindOneAndUpdate<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        FindOneAndUpdateOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndUpdate(session,
+            filter,
+            update,
+            options,
+            cancellationToken);
+    }
 
-        public TProjection FindOneAndUpdate<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            FindOneAndUpdateOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        FindOneAndUpdateOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndUpdate(session,
-                filter,
-                update,
-                options,
-                cancellationToken);
+            return FindOneAndUpdateAsync(session, filter, update, options, cancellationToken);
         }
 
-        public Task<TProjection> FindOneAndUpdateAsync<TProjection>(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            FindOneAndUpdateOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return FindOneAndUpdateAsync(session, filter, update, options, cancellationToken);
-            }
+        return _collection.FindOneAndUpdateAsync(filter, update, options, cancellationToken);
+    }
 
-            return _collection.FindOneAndUpdateAsync(filter, update, options, cancellationToken);
-        }
+    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        FindOneAndUpdateOptions<T, TProjection>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.FindOneAndUpdateAsync(session,
+            filter,
+            update,
+            options,
+            cancellationToken);
+    }
 
-        public Task<TProjection> FindOneAndUpdateAsync<TProjection>(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            FindOneAndUpdateOptions<T, TProjection>? options = null,
-            CancellationToken cancellationToken = default)
+    public void InsertOne(
+        T document,
+        InsertOneOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.FindOneAndUpdateAsync(session,
-                filter,
-                update,
-                options,
-                cancellationToken);
+            InsertOne(session, document, options, cancellationToken);
+            return;
         }
 
-        public void InsertOne(
-            T document,
-            InsertOneOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                InsertOne(session, document, options, cancellationToken);
-                return;
-            }
+        _collection.InsertOne(document, options, cancellationToken);
+    }
 
-            _collection.InsertOne(document, options, cancellationToken);
-        }
+    public void InsertOne(
+        IClientSessionHandle session,
+        T document,
+        InsertOneOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _collection.InsertOne(session, document, options, cancellationToken);
+    }
 
-        public void InsertOne(
-            IClientSessionHandle session,
-            T document,
-            InsertOneOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task InsertOneAsync(T document, CancellationToken cancellationToken)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _collection.InsertOne(session, document, options, cancellationToken);
+            return InsertOneAsync(session, document, cancellationToken: cancellationToken);
         }
 
-        public Task InsertOneAsync(T document, CancellationToken cancellationToken)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return InsertOneAsync(session, document, cancellationToken: cancellationToken);
-            }
+        return _collection.InsertOneAsync(document, cancellationToken);
+    }
 
-            return _collection.InsertOneAsync(document, cancellationToken);
+    public Task InsertOneAsync(
+        T document,
+        InsertOneOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return InsertOneAsync(session, document, options, cancellationToken);
         }
 
-        public Task InsertOneAsync(
-            T document,
-            InsertOneOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return InsertOneAsync(session, document, options, cancellationToken);
-            }
+        return _collection.InsertOneAsync(document, options, cancellationToken);
+    }
 
-            return _collection.InsertOneAsync(document, options, cancellationToken);
-        }
+    public Task InsertOneAsync(
+        IClientSessionHandle session,
+        T document,
+        InsertOneOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.InsertOneAsync(session, document, options, cancellationToken);
+    }
 
-        public Task InsertOneAsync(
-            IClientSessionHandle session,
-            T document,
-            InsertOneOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public void InsertMany(
+        IEnumerable<T> documents,
+        InsertManyOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.InsertOneAsync(session, document, options, cancellationToken);
+            // ReSharper disable once PossibleMultipleEnumeration
+            InsertMany(session, documents, options, cancellationToken);
+            return;
         }
 
-        public void InsertMany(
-            IEnumerable<T> documents,
-            InsertManyOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                // ReSharper disable once PossibleMultipleEnumeration
-                InsertMany(session, documents, options, cancellationToken);
-                return;
-            }
+        // ReSharper disable once PossibleMultipleEnumeration
+        _collection.InsertMany(documents, options, cancellationToken);
+    }
 
-            // ReSharper disable once PossibleMultipleEnumeration
-            _collection.InsertMany(documents, options, cancellationToken);
-        }
+    public void InsertMany(
+        IClientSessionHandle session,
+        IEnumerable<T> documents,
+        InsertManyOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _collection.InsertMany(session, documents, options, cancellationToken);
+    }
 
-        public void InsertMany(
-            IClientSessionHandle session,
-            IEnumerable<T> documents,
-            InsertManyOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task InsertManyAsync(
+        IEnumerable<T> documents,
+        InsertManyOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _collection.InsertMany(session, documents, options, cancellationToken);
+            return InsertManyAsync(session, documents, options, cancellationToken);
         }
 
-        public Task InsertManyAsync(
-            IEnumerable<T> documents,
-            InsertManyOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return InsertManyAsync(session, documents, options, cancellationToken);
-            }
+        return _collection.InsertManyAsync(documents, options, cancellationToken);
+    }
 
-            return _collection.InsertManyAsync(documents, options, cancellationToken);
-        }
+    public Task InsertManyAsync(
+        IClientSessionHandle session,
+        IEnumerable<T> documents,
+        InsertManyOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.InsertManyAsync(session, documents, options, cancellationToken);
+    }
 
-        public Task InsertManyAsync(
-            IClientSessionHandle session,
-            IEnumerable<T> documents,
-            InsertManyOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<TResult> MapReduce<TResult>(
+        BsonJavaScript map,
+        BsonJavaScript reduce,
+        MapReduceOptions<T, TResult>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.InsertManyAsync(session, documents, options, cancellationToken);
+            return MapReduce(session, map, reduce, options, cancellationToken);
         }
 
-        public IAsyncCursor<TResult> MapReduce<TResult>(
-            BsonJavaScript map,
-            BsonJavaScript reduce,
-            MapReduceOptions<T, TResult>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return MapReduce(session, map, reduce, options, cancellationToken);
-            }
+        return _collection.MapReduce(map, reduce, options, cancellationToken);
+    }
 
-            return _collection.MapReduce(map, reduce, options, cancellationToken);
-        }
+    public IAsyncCursor<TResult> MapReduce<TResult>(
+        IClientSessionHandle session,
+        BsonJavaScript map,
+        BsonJavaScript reduce,
+        MapReduceOptions<T, TResult>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.MapReduce(session, map, reduce, options, cancellationToken);
+    }
 
-        public IAsyncCursor<TResult> MapReduce<TResult>(
-            IClientSessionHandle session,
-            BsonJavaScript map,
-            BsonJavaScript reduce,
-            MapReduceOptions<T, TResult>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(
+        BsonJavaScript map,
+        BsonJavaScript reduce,
+        MapReduceOptions<T, TResult>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.MapReduce(session, map, reduce, options, cancellationToken);
+            return MapReduceAsync(session, map, reduce, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(
-            BsonJavaScript map,
-            BsonJavaScript reduce,
-            MapReduceOptions<T, TResult>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return MapReduceAsync(session, map, reduce, options, cancellationToken);
-            }
+        return _collection.MapReduceAsync(map, reduce, options, cancellationToken);
+    }
 
-            return _collection.MapReduceAsync(map, reduce, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(
+        IClientSessionHandle session,
+        BsonJavaScript map,
+        BsonJavaScript reduce,
+        MapReduceOptions<T, TResult>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.MapReduceAsync(session, map, reduce, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(
-            IClientSessionHandle session,
-            BsonJavaScript map,
-            BsonJavaScript reduce,
-            MapReduceOptions<T, TResult>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.MapReduceAsync(session, map, reduce, options, cancellationToken);
-        }
+    public IFilteredMongoCollection<TDerivedDocument> OfType<TDerivedDocument>()
+        where TDerivedDocument : T
+    {
+        return _collection.OfType<TDerivedDocument>().AsTransactionCollection();
+    }
 
-        public IFilteredMongoCollection<TDerivedDocument> OfType<TDerivedDocument>()
-            where TDerivedDocument : T
+    public ReplaceOneResult ReplaceOne(
+        FilterDefinition<T> filter,
+        T replacement,
+        ReplaceOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.OfType<TDerivedDocument>().AsTransactionCollection();
+            return ReplaceOne(session, filter, replacement, options, cancellationToken);
         }
 
-        public ReplaceOneResult ReplaceOne(
-            FilterDefinition<T> filter,
-            T replacement,
-            ReplaceOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return ReplaceOne(session, filter, replacement, options, cancellationToken);
-            }
+        return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
+    }
 
-            return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
+    public ReplaceOneResult ReplaceOne(
+        FilterDefinition<T> filter,
+        T replacement,
+        UpdateOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return ReplaceOne(session, filter, replacement, options, cancellationToken);
         }
 
-        public ReplaceOneResult ReplaceOne(
-            FilterDefinition<T> filter,
-            T replacement,
-            UpdateOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return ReplaceOne(session, filter, replacement, options, cancellationToken);
-            }
+        return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
+    }
 
-            return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
-        }
+    public ReplaceOneResult ReplaceOne(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        ReplaceOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
+    }
 
-        public ReplaceOneResult ReplaceOne(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            ReplaceOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
-        }
+    public ReplaceOneResult ReplaceOne(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        UpdateOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
+    }
 
-        public ReplaceOneResult ReplaceOne(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            UpdateOptions options,
-            CancellationToken cancellationToken = default)
+    public Task<ReplaceOneResult> ReplaceOneAsync(
+        FilterDefinition<T> filter,
+        T replacement,
+        ReplaceOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
+            return ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
         }
 
-        public Task<ReplaceOneResult> ReplaceOneAsync(
-            FilterDefinition<T> filter,
-            T replacement,
-            ReplaceOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
-            }
+        return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
+    }
 
-            return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
+    public Task<ReplaceOneResult> ReplaceOneAsync(
+        FilterDefinition<T> filter,
+        T replacement,
+        UpdateOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
+        {
+            return ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
         }
 
-        public Task<ReplaceOneResult> ReplaceOneAsync(
-            FilterDefinition<T> filter,
-            T replacement,
-            UpdateOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
-            }
+        return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
+    }
 
-            return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
-        }
+    public Task<ReplaceOneResult> ReplaceOneAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        ReplaceOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.ReplaceOneAsync(session,
+            filter,
+            replacement,
+            options,
+            cancellationToken);
+    }
 
-        public Task<ReplaceOneResult> ReplaceOneAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            ReplaceOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.ReplaceOneAsync(session,
-                filter,
-                replacement,
-                options,
-                cancellationToken);
-        }
+    public Task<ReplaceOneResult> ReplaceOneAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        T replacement,
+        UpdateOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.ReplaceOneAsync(session,
+            filter,
+            replacement,
+            options,
+            cancellationToken);
+    }
 
-        public Task<ReplaceOneResult> ReplaceOneAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            T replacement,
-            UpdateOptions options,
-            CancellationToken cancellationToken = default)
+    public UpdateResult UpdateMany(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.ReplaceOneAsync(session,
-                filter,
-                replacement,
-                options,
-                cancellationToken);
+            return UpdateMany(session, filter, update, options, cancellationToken);
         }
 
-        public UpdateResult UpdateMany(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return UpdateMany(session, filter, update, options, cancellationToken);
-            }
+        return _collection.UpdateMany(filter, update, options, cancellationToken);
+    }
 
-            return _collection.UpdateMany(filter, update, options, cancellationToken);
-        }
+    public UpdateResult UpdateMany(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.UpdateMany(session, filter, update, options, cancellationToken);
+    }
 
-        public UpdateResult UpdateMany(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<UpdateResult> UpdateManyAsync(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.UpdateMany(session, filter, update, options, cancellationToken);
+            return UpdateManyAsync(session, filter, update, options, cancellationToken);
         }
 
-        public Task<UpdateResult> UpdateManyAsync(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return UpdateManyAsync(session, filter, update, options, cancellationToken);
-            }
+        return _collection.UpdateManyAsync(filter, update, options, cancellationToken);
+    }
 
-            return _collection.UpdateManyAsync(filter, update, options, cancellationToken);
-        }
+    public Task<UpdateResult> UpdateManyAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.UpdateManyAsync(session, filter, update, options, cancellationToken);
+    }
 
-        public Task<UpdateResult> UpdateManyAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public UpdateResult UpdateOne(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.UpdateManyAsync(session, filter, update, options, cancellationToken);
+            return UpdateOne(session, filter, update, options, cancellationToken);
         }
 
-        public UpdateResult UpdateOne(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return UpdateOne(session, filter, update, options, cancellationToken);
-            }
+        return _collection.UpdateOne(filter, update, options, cancellationToken);
+    }
 
-            return _collection.UpdateOne(filter, update, options, cancellationToken);
-        }
+    public UpdateResult UpdateOne(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.UpdateOne(session, filter, update, options, cancellationToken);
+    }
 
-        public UpdateResult UpdateOne(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<UpdateResult> UpdateOneAsync(
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.UpdateOne(session, filter, update, options, cancellationToken);
+            return UpdateOneAsync(session, filter, update, options, cancellationToken);
         }
 
-        public Task<UpdateResult> UpdateOneAsync(
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return UpdateOneAsync(session, filter, update, options, cancellationToken);
-            }
+        return _collection.UpdateOneAsync(filter, update, options, cancellationToken);
+    }
 
-            return _collection.UpdateOneAsync(filter, update, options, cancellationToken);
-        }
+    public Task<UpdateResult> UpdateOneAsync(
+        IClientSessionHandle session,
+        FilterDefinition<T> filter,
+        UpdateDefinition<T> update,
+        UpdateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.UpdateOneAsync(session, filter, update, options, cancellationToken);
+    }
 
-        public Task<UpdateResult> UpdateOneAsync(
-            IClientSessionHandle session,
-            FilterDefinition<T> filter,
-            UpdateDefinition<T> update,
-            UpdateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.UpdateOneAsync(session, filter, update, options, cancellationToken);
+            return Watch(session, pipeline, options, cancellationToken);
         }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return Watch(session, pipeline, options, cancellationToken);
-            }
+        return _collection.Watch(pipeline, options, cancellationToken);
+    }
 
-            return _collection.Watch(pipeline, options, cancellationToken);
-        }
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.Watch(session, pipeline, options, cancellationToken);
+    }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _collection.Watch(session, pipeline, options, cancellationToken);
+            return WatchAsync(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return WatchAsync(session, pipeline, options, cancellationToken);
-            }
+        return _collection.WatchAsync(pipeline, options, cancellationToken);
+    }
 
-            return _collection.WatchAsync(pipeline, options, cancellationToken);
-        }
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _collection.WatchAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _collection.WatchAsync(session, pipeline, options, cancellationToken);
-        }
+    public IMongoCollection<T> WithReadConcern(ReadConcern readConcern)
+    {
+        return _collection.WithReadConcern(readConcern).AsTransactionCollection();
+    }
 
-        public IMongoCollection<T> WithReadConcern(ReadConcern readConcern)
-        {
-            return _collection.WithReadConcern(readConcern).AsTransactionCollection();
-        }
+    public IMongoCollection<T> WithReadPreference(ReadPreference readPreference)
+    {
+        return _collection.WithReadPreference(readPreference).AsTransactionCollection();
+    }
 
-        public IMongoCollection<T> WithReadPreference(ReadPreference readPreference)
-        {
-            return _collection.WithReadPreference(readPreference).AsTransactionCollection();
-        }
+    public IMongoCollection<T> WithWriteConcern(WriteConcern writeConcern)
+    {
+        return _collection.WithWriteConcern(writeConcern).AsTransactionCollection();
+    }
 
-        public IMongoCollection<T> WithWriteConcern(WriteConcern writeConcern)
-        {
-            return _collection.WithWriteConcern(writeConcern).AsTransactionCollection();
-        }
+    public CollectionNamespace CollectionNamespace => _collection.CollectionNamespace;
 
-        public CollectionNamespace CollectionNamespace => _collection.CollectionNamespace;
+    public IMongoDatabase Database => _collection.Database;
 
-        public IMongoDatabase Database => _collection.Database;
+    public IBsonSerializer<T> DocumentSerializer => _collection.DocumentSerializer;
 
-        public IBsonSerializer<T> DocumentSerializer => _collection.DocumentSerializer;
+    public IMongoIndexManager<T> Indexes => _collection.Indexes;
 
-        public IMongoIndexManager<T> Indexes => _collection.Indexes;
+    public MongoCollectionSettings Settings => _collection.Settings;
 
-        public MongoCollectionSettings Settings => _collection.Settings;
+    private bool TryGetSession(out IClientSessionHandle sessionHandle)
+    {
+        if (_clientSessionHandle is { } clientSessionHandle)
+        {
+            sessionHandle = clientSessionHandle;
+            return true;
+        }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool TryGetSession(out IClientSessionHandle sessionHandle) =>
-            TransactionStore.TryGetSession(_collection.Database.Client, out sessionHandle);
+        return TransactionStore.TryGetSession(
+            _collection.Database.Client, out sessionHandle);
     }
 }
diff --git a/src/Transactions/MongoTransactionDatabase.cs b/src/Transactions/MongoTransactionDatabase.cs
index 3df8553..936a378 100644
--- a/src/Transactions/MongoTransactionDatabase.cs
+++ b/src/Transactions/MongoTransactionDatabase.cs
@@ -1,546 +1,561 @@
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson;
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
-{
-    public class MongoTransactionDatabase : IMongoDatabase
-    {
-        private readonly IMongoDatabase _database;
+namespace MongoDB.Extensions.Transactions;
 
-        public MongoTransactionDatabase(IMongoDatabase database)
-        {
-            _database = database;
-        }
+public class MongoTransactionDatabase : IMongoDatabase
+{
+    private readonly IMongoDatabase _database;
+    private readonly IClientSessionHandle? _clientSessionHandle;
 
-        public IAsyncCursor<TResult> Aggregate<TResult>(
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return Aggregate(session, pipeline, options, cancellationToken);
-            }
+    public MongoTransactionDatabase(IMongoDatabase database)
+    {
+        _database = database;
+    }
 
-            return _database.Aggregate(pipeline, options, cancellationToken);
-        }
+    public MongoTransactionDatabase(
+        IMongoDatabase database,
+        IClientSessionHandle clientSessionHandle)
+    {
+        _database = database;
+        _clientSessionHandle = clientSessionHandle;
+    }
 
-        public IAsyncCursor<TResult> Aggregate<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<TResult> Aggregate<TResult>(
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _database.Aggregate(session, pipeline, options, cancellationToken);
+            return Aggregate(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.AggregateAsync(session, pipeline, options, cancellationToken);
-            }
+        return _database.Aggregate(pipeline, options, cancellationToken);
+    }
 
-            return _database.AggregateAsync(pipeline, options, cancellationToken);
-        }
+    public IAsyncCursor<TResult> Aggregate<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.Aggregate(session, pipeline, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.AggregateAsync(session, pipeline, options, cancellationToken);
         }
 
-        public void AggregateToCollection<TResult>(
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database.AggregateToCollection(session, pipeline, options, cancellationToken);
-                return;
-            }
+        return _database.AggregateAsync(pipeline, options, cancellationToken);
+    }
 
-            _database.AggregateToCollection(pipeline, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.AggregateAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public void AggregateToCollection<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public void AggregateToCollection<TResult>(
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             _database.AggregateToCollection(session, pipeline, options, cancellationToken);
+            return;
         }
 
-        public Task AggregateToCollectionAsync<TResult>(
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database
-                    .AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
-            }
+        _database.AggregateToCollection(pipeline, options, cancellationToken);
+    }
 
-            return _database.AggregateToCollectionAsync(pipeline, options, cancellationToken);
-        }
+    public void AggregateToCollection<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _database.AggregateToCollection(session, pipeline, options, cancellationToken);
+    }
 
-        public Task AggregateToCollectionAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<NoPipelineInput, TResult> pipeline,
-            AggregateOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task AggregateToCollectionAsync<TResult>(
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database
                 .AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
         }
 
-        public void CreateCollection(
-            string name,
-            CreateCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database.CreateCollection(session, name, options, cancellationToken);
-                return;
-            }
+        return _database.AggregateToCollectionAsync(pipeline, options, cancellationToken);
+    }
 
-            _database.CreateCollection(name, options, cancellationToken);
-        }
+    public Task AggregateToCollectionAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<NoPipelineInput, TResult> pipeline,
+        AggregateOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database
+            .AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public void CreateCollection(
-            IClientSessionHandle session,
-            string name,
-            CreateCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public void CreateCollection(
+        string name,
+        CreateCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             _database.CreateCollection(session, name, options, cancellationToken);
+            return;
         }
 
-        public Task CreateCollectionAsync(
-            string name,
-            CreateCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.CreateCollectionAsync(session, name, options, cancellationToken);
-            }
+        _database.CreateCollection(name, options, cancellationToken);
+    }
 
-            return _database.CreateCollectionAsync(name, options, cancellationToken);
-        }
+    public void CreateCollection(
+        IClientSessionHandle session,
+        string name,
+        CreateCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _database.CreateCollection(session, name, options, cancellationToken);
+    }
 
-        public Task CreateCollectionAsync(
-            IClientSessionHandle session,
-            string name,
-            CreateCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task CreateCollectionAsync(
+        string name,
+        CreateCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.CreateCollectionAsync(session, name, options, cancellationToken);
         }
 
-        public void CreateView<TDocument, TResult>(
-            string viewName,
-            string viewOn,
-            PipelineDefinition<TDocument, TResult> pipeline,
-            CreateViewOptions<TDocument>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database
-                    .CreateView(session, viewName, viewOn, pipeline, options, cancellationToken);
-                return;
-            }
-
-            _database.CreateView(viewName, viewOn, pipeline, options, cancellationToken);
-        }
+        return _database.CreateCollectionAsync(name, options, cancellationToken);
+    }
+
+    public Task CreateCollectionAsync(
+        IClientSessionHandle session,
+        string name,
+        CreateCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.CreateCollectionAsync(session, name, options, cancellationToken);
+    }
 
-        public void CreateView<TDocument, TResult>(
-            IClientSessionHandle session,
-            string viewName,
-            string viewOn,
-            PipelineDefinition<TDocument, TResult> pipeline,
-            CreateViewOptions<TDocument>? options = null,
-            CancellationToken cancellationToken = default)
+    public void CreateView<TDocument, TResult>(
+        string viewName,
+        string viewOn,
+        PipelineDefinition<TDocument, TResult> pipeline,
+        CreateViewOptions<TDocument>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _database.CreateView(session, viewName, viewOn, pipeline, options, cancellationToken);
+            _database
+                .CreateView(session, viewName, viewOn, pipeline, options, cancellationToken);
+            return;
         }
 
-        public Task CreateViewAsync<TDocument, TResult>(
-            string viewName,
-            string viewOn,
-            PipelineDefinition<TDocument, TResult> pipeline,
-            CreateViewOptions<TDocument>? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.CreateViewAsync(
-                    session,
-                    viewName,
-                    viewOn,
-                    pipeline,
-                    options,
-                    cancellationToken);
-            }
+        _database.CreateView(viewName, viewOn, pipeline, options, cancellationToken);
+    }
 
-            return _database
-                .CreateViewAsync(viewName, viewOn, pipeline, options, cancellationToken);
-        }
+    public void CreateView<TDocument, TResult>(
+        IClientSessionHandle session,
+        string viewName,
+        string viewOn,
+        PipelineDefinition<TDocument, TResult> pipeline,
+        CreateViewOptions<TDocument>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _database.CreateView(session, viewName, viewOn, pipeline, options, cancellationToken);
+    }
 
-        public Task CreateViewAsync<TDocument, TResult>(
-            IClientSessionHandle session,
-            string viewName,
-            string viewOn,
-            PipelineDefinition<TDocument, TResult> pipeline,
-            CreateViewOptions<TDocument>? options = null,
-            CancellationToken cancellationToken = default)
+    public Task CreateViewAsync<TDocument, TResult>(
+        string viewName,
+        string viewOn,
+        PipelineDefinition<TDocument, TResult> pipeline,
+        CreateViewOptions<TDocument>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            return _database
-                .CreateViewAsync(session, viewName, viewOn, pipeline, options, cancellationToken);
+            return _database.CreateViewAsync(
+                session,
+                viewName,
+                viewOn,
+                pipeline,
+                options,
+                cancellationToken);
         }
 
-        public void DropCollection(
-            string name,
-            DropCollectionOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database.DropCollection(session, name, options, cancellationToken);
-                return;
-            }
+        return _database
+            .CreateViewAsync(viewName, viewOn, pipeline, options, cancellationToken);
+    }
 
-            _database.DropCollection(name, options, cancellationToken);
-        }
+    public Task CreateViewAsync<TDocument, TResult>(
+        IClientSessionHandle session,
+        string viewName,
+        string viewOn,
+        PipelineDefinition<TDocument, TResult> pipeline,
+        CreateViewOptions<TDocument>? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database
+            .CreateViewAsync(session, viewName, viewOn, pipeline, options, cancellationToken);
+    }
 
-        public void DropCollection(
-            IClientSessionHandle session,
-            string name,
-            DropCollectionOptions options,
-            CancellationToken cancellationToken = default)
+    public void DropCollection(
+        string name,
+        DropCollectionOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
-            _database.DropCollectionAsync(session, name, options, cancellationToken);
+            _database.DropCollection(session, name, options, cancellationToken);
+            return;
         }
 
-        public Task DropCollectionAsync(
-            string name,
-            DropCollectionOptions options,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.DropCollectionAsync(session, name, options, cancellationToken);
-            }
+        _database.DropCollection(name, options, cancellationToken);
+    }
 
-            return _database.DropCollectionAsync(name, options, cancellationToken);
-        }
+    public void DropCollection(
+        IClientSessionHandle session,
+        string name,
+        DropCollectionOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        _database.DropCollectionAsync(session, name, options, cancellationToken);
+    }
 
-        public Task DropCollectionAsync(
-            IClientSessionHandle session,
-            string name,
-            DropCollectionOptions options,
-            CancellationToken cancellationToken = default)
+    public Task DropCollectionAsync(
+        string name,
+        DropCollectionOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.DropCollectionAsync(session, name, options, cancellationToken);
         }
 
-        public void DropCollection(string name, CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database.DropCollection(session, name, cancellationToken);
-                return;
-            }
+        return _database.DropCollectionAsync(name, options, cancellationToken);
+    }
 
-            _database.DropCollection(name, cancellationToken);
-        }
+    public Task DropCollectionAsync(
+        IClientSessionHandle session,
+        string name,
+        DropCollectionOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.DropCollectionAsync(session, name, options, cancellationToken);
+    }
 
-        public void DropCollection(
-            IClientSessionHandle session,
-            string name,
-            CancellationToken cancellationToken = default)
+    public void DropCollection(string name, CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             _database.DropCollection(session, name, cancellationToken);
+            return;
         }
 
-        public Task DropCollectionAsync(
-            string name,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.DropCollectionAsync(session, name, cancellationToken);
-            }
+        _database.DropCollection(name, cancellationToken);
+    }
 
-            return _database.DropCollectionAsync(name, cancellationToken);
-        }
+    public void DropCollection(
+        IClientSessionHandle session,
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        _database.DropCollection(session, name, cancellationToken);
+    }
 
-        public Task DropCollectionAsync(
-            IClientSessionHandle session,
-            string name,
-            CancellationToken cancellationToken = default)
+    public Task DropCollectionAsync(
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.DropCollectionAsync(session, name, cancellationToken);
         }
 
-        public IMongoCollection<TDocument> GetCollection<TDocument>(
-            string name,
-            MongoCollectionSettings? settings = null)
-        {
-            return _database.GetCollection<TDocument>(name, settings).AsTransactionCollection();
-        }
+        return _database.DropCollectionAsync(name, cancellationToken);
+    }
 
-        public IAsyncCursor<string> ListCollectionNames(
-            ListCollectionNamesOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.ListCollectionNames(session, options, cancellationToken);
-            }
+    public Task DropCollectionAsync(
+        IClientSessionHandle session,
+        string name,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.DropCollectionAsync(session, name, cancellationToken);
+    }
 
-            return _database.ListCollectionNames(options, cancellationToken);
-        }
+    public IMongoCollection<TDocument> GetCollection<TDocument>(
+        string name,
+        MongoCollectionSettings? settings = null)
+    {
+        return _database.GetCollection<TDocument>(name, settings).AsTransactionCollection();
+    }
 
-        public IAsyncCursor<string> ListCollectionNames(
-            IClientSessionHandle session,
-            ListCollectionNamesOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<string> ListCollectionNames(
+        ListCollectionNamesOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.ListCollectionNames(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListCollectionNamesAsync(
-            ListCollectionNamesOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.ListCollectionNamesAsync(session, options, cancellationToken);
-            }
+        return _database.ListCollectionNames(options, cancellationToken);
+    }
 
-            return _database.ListCollectionNamesAsync(options, cancellationToken);
-        }
+    public IAsyncCursor<string> ListCollectionNames(
+        IClientSessionHandle session,
+        ListCollectionNamesOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.ListCollectionNames(session, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<string>> ListCollectionNamesAsync(
-            IClientSessionHandle session,
-            ListCollectionNamesOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<string>> ListCollectionNamesAsync(
+        ListCollectionNamesOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.ListCollectionNamesAsync(session, options, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListCollections(
-            ListCollectionsOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.ListCollections(session, options, cancellationToken);
-            }
+        return _database.ListCollectionNamesAsync(options, cancellationToken);
+    }
 
-            return _database.ListCollections(options, cancellationToken);
-        }
+    public Task<IAsyncCursor<string>> ListCollectionNamesAsync(
+        IClientSessionHandle session,
+        ListCollectionNamesOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.ListCollectionNamesAsync(session, options, cancellationToken);
+    }
 
-        public IAsyncCursor<BsonDocument> ListCollections(
-            IClientSessionHandle session,
-            ListCollectionsOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IAsyncCursor<BsonDocument> ListCollections(
+        ListCollectionsOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.ListCollections(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(
-            ListCollectionsOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.ListCollectionsAsync(session, options, cancellationToken);
-            }
+        return _database.ListCollections(options, cancellationToken);
+    }
 
-            return _database.ListCollectionsAsync(options, cancellationToken);
-        }
+    public IAsyncCursor<BsonDocument> ListCollections(
+        IClientSessionHandle session,
+        ListCollectionsOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.ListCollections(session, options, cancellationToken);
+    }
 
-        public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(
-            IClientSessionHandle session,
-            ListCollectionsOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(
+        ListCollectionsOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.ListCollectionsAsync(session, options, cancellationToken);
         }
 
-        public void RenameCollection(
-            string oldName,
-            string newName,
-            RenameCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                _database.RenameCollection(session, oldName, newName, options, cancellationToken);
-                return;
-            }
+        return _database.ListCollectionsAsync(options, cancellationToken);
+    }
 
-            _database.RenameCollection(oldName, newName, options, cancellationToken);
-        }
+    public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(
+        IClientSessionHandle session,
+        ListCollectionsOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.ListCollectionsAsync(session, options, cancellationToken);
+    }
 
-        public void RenameCollection(
-            IClientSessionHandle session,
-            string oldName,
-            string newName,
-            RenameCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public void RenameCollection(
+        string oldName,
+        string newName,
+        RenameCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             _database.RenameCollection(session, oldName, newName, options, cancellationToken);
+            return;
         }
 
-        public Task RenameCollectionAsync(
-            string oldName,
-            string newName,
-            RenameCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database
-                    .RenameCollectionAsync(session, oldName, newName, options, cancellationToken);
-            }
+        _database.RenameCollection(oldName, newName, options, cancellationToken);
+    }
 
-            return _database.RenameCollectionAsync(oldName, newName, options, cancellationToken);
-        }
+    public void RenameCollection(
+        IClientSessionHandle session,
+        string oldName,
+        string newName,
+        RenameCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        _database.RenameCollection(session, oldName, newName, options, cancellationToken);
+    }
 
-        public Task RenameCollectionAsync(
-            IClientSessionHandle session,
-            string oldName,
-            string newName,
-            RenameCollectionOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task RenameCollectionAsync(
+        string oldName,
+        string newName,
+        RenameCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database
                 .RenameCollectionAsync(session, oldName, newName, options, cancellationToken);
         }
 
-        public TResult RunCommand<TResult>(
-            Command<TResult> command,
-            ReadPreference? readPreference = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.RunCommand(session, command, readPreference, cancellationToken);
-            }
+        return _database.RenameCollectionAsync(oldName, newName, options, cancellationToken);
+    }
 
-            return _database.RunCommand(command, readPreference, cancellationToken);
-        }
+    public Task RenameCollectionAsync(
+        IClientSessionHandle session,
+        string oldName,
+        string newName,
+        RenameCollectionOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database
+            .RenameCollectionAsync(session, oldName, newName, options, cancellationToken);
+    }
 
-        public TResult RunCommand<TResult>(
-            IClientSessionHandle session,
-            Command<TResult> command,
-            ReadPreference? readPreference = null,
-            CancellationToken cancellationToken = default)
+    public TResult RunCommand<TResult>(
+        Command<TResult> command,
+        ReadPreference? readPreference = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.RunCommand(session, command, readPreference, cancellationToken);
         }
 
-        public Task<TResult> RunCommandAsync<TResult>(
-            Command<TResult> command,
-            ReadPreference? readPreference = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _database.RunCommandAsync(command, readPreference, cancellationToken);
-        }
+        return _database.RunCommand(command, readPreference, cancellationToken);
+    }
 
-        public Task<TResult> RunCommandAsync<TResult>(
-            IClientSessionHandle session,
-            Command<TResult> command,
-            ReadPreference? readPreference = null,
-            CancellationToken cancellationToken = default)
-        {
-            return _database.RunCommandAsync(session, command, readPreference, cancellationToken);
-        }
+    public TResult RunCommand<TResult>(
+        IClientSessionHandle session,
+        Command<TResult> command,
+        ReadPreference? readPreference = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.RunCommand(session, command, readPreference, cancellationToken);
+    }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.Watch(session, pipeline, options, cancellationToken);
-            }
+    public Task<TResult> RunCommandAsync<TResult>(
+        Command<TResult> command,
+        ReadPreference? readPreference = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.RunCommandAsync(command, readPreference, cancellationToken);
+    }
 
-            return _database.Watch(pipeline, options, cancellationToken);
-        }
+    public Task<TResult> RunCommandAsync<TResult>(
+        IClientSessionHandle session,
+        Command<TResult> command,
+        ReadPreference? readPreference = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.RunCommandAsync(session, command, readPreference, cancellationToken);
+    }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.Watch(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (TryGetSession(out IClientSessionHandle? session))
-            {
-                return _database.WatchAsync(session, pipeline, options, cancellationToken);
-            }
+        return _database.Watch(pipeline, options, cancellationToken);
+    }
 
-            return _database.WatchAsync(pipeline, options, cancellationToken);
-        }
+    public IChangeStreamCursor<TResult> Watch<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.Watch(session, pipeline, options, cancellationToken);
+    }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
-            IClientSessionHandle session,
-            PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions? options = null,
-            CancellationToken cancellationToken = default)
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (TryGetSession(out IClientSessionHandle? session))
         {
             return _database.WatchAsync(session, pipeline, options, cancellationToken);
         }
 
-        public IMongoDatabase WithReadConcern(ReadConcern readConcern)
-        {
-            return _database.WithReadConcern(readConcern).AsTransactionDatabase();
-        }
+        return _database.WatchAsync(pipeline, options, cancellationToken);
+    }
 
-        public IMongoDatabase WithReadPreference(ReadPreference readPreference)
-        {
-            return _database.WithReadPreference(readPreference).AsTransactionDatabase();
-        }
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
+        IClientSessionHandle session,
+        PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
+        ChangeStreamOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return _database.WatchAsync(session, pipeline, options, cancellationToken);
+    }
 
-        public IMongoDatabase WithWriteConcern(WriteConcern writeConcern)
-        {
-            return _database.WithWriteConcern(writeConcern).AsTransactionDatabase();
-        }
+    public IMongoDatabase WithReadConcern(ReadConcern readConcern)
+    {
+        return _database.WithReadConcern(readConcern).AsTransactionDatabase();
+    }
 
-        public IMongoClient Client => _database.Client;
+    public IMongoDatabase WithReadPreference(ReadPreference readPreference)
+    {
+        return _database.WithReadPreference(readPreference).AsTransactionDatabase();
+    }
 
-        public DatabaseNamespace DatabaseNamespace => _database.DatabaseNamespace;
+    public IMongoDatabase WithWriteConcern(WriteConcern writeConcern)
+    {
+        return _database.WithWriteConcern(writeConcern).AsTransactionDatabase();
+    }
 
-        public MongoDatabaseSettings Settings => _database.Settings;
+    public IMongoClient Client => _database.Client;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool TryGetSession(out IClientSessionHandle sessionHandle) =>
-            TransactionStore.TryGetSession(_database.Client, out sessionHandle);
-    }
+    public DatabaseNamespace DatabaseNamespace => _database.DatabaseNamespace;
+
+    public MongoDatabaseSettings Settings => _database.Settings;
+
+    private bool TryGetSession(out IClientSessionHandle sessionHandle)
+    {
+        if (_clientSessionHandle is { } clientSessionHandle)
+        {
+            sessionHandle = clientSessionHandle;
+            return true;
+        }
+
+        return TransactionStore.TryGetSession(
+            _database.Client, out sessionHandle);
+    }        
 }
diff --git a/src/Transactions/MongoTransactionFilteredCollection.cs b/src/Transactions/MongoTransactionFilteredCollection.cs
index 9ab00dc..2cdb798 100644
--- a/src/Transactions/MongoTransactionFilteredCollection.cs
+++ b/src/Transactions/MongoTransactionFilteredCollection.cs
@@ -1,19 +1,27 @@
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public class MongoTransactionFilteredCollection<T>
+    : MongoTransactionCollection<T>
+    , IFilteredMongoCollection<T>
 {
-    public class MongoTransactionFilteredCollection<T>
-        : MongoTransactionCollection<T>
-        , IFilteredMongoCollection<T>
-    {
-        private readonly IFilteredMongoCollection<T> _filteredCollection;
+    private readonly IFilteredMongoCollection<T> _filteredCollection;
 
-        public MongoTransactionFilteredCollection(IFilteredMongoCollection<T> filteredCollection)
-            : base(filteredCollection)
-        {
-            _filteredCollection = filteredCollection;
-        }
+    public MongoTransactionFilteredCollection(
+        IFilteredMongoCollection<T> filteredCollection)
+        : base(filteredCollection)
+    {
+        _filteredCollection = filteredCollection;
+    }
 
-        public FilterDefinition<T> Filter => _filteredCollection.Filter;
+    public MongoTransactionFilteredCollection(
+        IFilteredMongoCollection<T> filteredCollection,
+        IClientSessionHandle clientSessionHandle)
+        : base(filteredCollection, clientSessionHandle)
+    {
+        _filteredCollection = filteredCollection;
     }
+
+    public FilterDefinition<T> Filter => _filteredCollection.Filter;
 }
diff --git a/src/Transactions/TransactionClientExtensions.cs b/src/Transactions/TransactionClientExtensions.cs
index 9127c2c..cf54ab5 100644
--- a/src/Transactions/TransactionClientExtensions.cs
+++ b/src/Transactions/TransactionClientExtensions.cs
@@ -1,12 +1,19 @@
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public static class TransactionClientExtensions
 {
-    public static class TransactionClientExtensions
+    public static IMongoClient AsTransactionClient(
+        this IMongoClient collection)
+    {
+        return new MongoTransactionClient(collection);
+    }
+
+    public static IMongoClient AsTransactionClient(
+        this IMongoClient collection,
+        IClientSessionHandle clientSessionHandle)
     {
-        public static IMongoClient AsTransactionClient(this IMongoClient collection)
-        {
-            return new MongoTransactionClient(collection);
-        }
+        return new MongoTransactionClient(collection, clientSessionHandle);
     }
 }
diff --git a/src/Transactions/TransactionCollectionExtensions.cs b/src/Transactions/TransactionCollectionExtensions.cs
index a7f5663..bc4ca2c 100644
--- a/src/Transactions/TransactionCollectionExtensions.cs
+++ b/src/Transactions/TransactionCollectionExtensions.cs
@@ -1,19 +1,32 @@
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public static class TransactionCollectionExtensions
 {
-    public static class TransactionCollectionExtensions
+    public static IMongoCollection<T> AsTransactionCollection<T>(
+        this IMongoCollection<T> collection)
     {
-        public static IMongoCollection<T> AsTransactionCollection<T>(
-            this IMongoCollection<T> collection)
-        {
-            return new MongoTransactionCollection<T>(collection);
-        }
+        return new MongoTransactionCollection<T>(collection);
+    }
+
+    public static IMongoCollection<T> AsTransactionCollection<T>(
+        this IMongoCollection<T> collection,
+        IClientSessionHandle clientSessionHandle)
+    {
+        return new MongoTransactionCollection<T>(collection, clientSessionHandle);
+    }
 
-        public static IFilteredMongoCollection<T> AsTransactionCollection<T>(
-            this IFilteredMongoCollection<T> collection)
-        {
-            return new MongoTransactionFilteredCollection<T>(collection);
-        }
+    public static IFilteredMongoCollection<T> AsTransactionCollection<T>(
+        this IFilteredMongoCollection<T> collection)
+    {
+        return new MongoTransactionFilteredCollection<T>(collection);
+    }
+
+    public static IFilteredMongoCollection<T> AsTransactionCollection<T>(
+        this IFilteredMongoCollection<T> collection,
+        IClientSessionHandle clientSessionHandle)
+    {
+        return new MongoTransactionFilteredCollection<T>(collection, clientSessionHandle);
     }
 }
diff --git a/src/Transactions/TransactionDatabaseExtensions.cs b/src/Transactions/TransactionDatabaseExtensions.cs
index a279fc2..9122ca4 100644
--- a/src/Transactions/TransactionDatabaseExtensions.cs
+++ b/src/Transactions/TransactionDatabaseExtensions.cs
@@ -1,12 +1,19 @@
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+public static class TransactionDatabaseExtensions
 {
-    public static class TransactionDatabaseExtensions
+    public static IMongoDatabase AsTransactionDatabase(
+        this IMongoDatabase collection)
+    {
+        return new MongoTransactionDatabase(collection);
+    }
+
+    public static IMongoDatabase AsTransactionDatabase(
+        this IMongoDatabase collection,
+        IClientSessionHandle clientSessionHandle)
     {
-        public static IMongoDatabase AsTransactionDatabase(this IMongoDatabase collection)
-        {
-            return new MongoTransactionDatabase(collection);
-        }
+        return new MongoTransactionDatabase(collection, clientSessionHandle);
     }
 }
diff --git a/src/Transactions/TransactionStore.cs b/src/Transactions/TransactionStore.cs
index 1c2e419..d4cfd67 100644
--- a/src/Transactions/TransactionStore.cs
+++ b/src/Transactions/TransactionStore.cs
@@ -2,55 +2,54 @@
 using System.Transactions;
 using MongoDB.Driver;
 
-namespace MongoDB.Extensions.Transactions
+namespace MongoDB.Extensions.Transactions;
+
+internal static class TransactionStore
 {
-    internal static class TransactionStore
-    {
-        private static readonly ConcurrentDictionary<string, IClientSessionHandle>
-            Sessions = new();
+    private static readonly ConcurrentDictionary<string, IClientSessionHandle>
+        Sessions = new();
 
-        public static bool TryGetSession(
-            IMongoClient client,
-            out IClientSessionHandle sessionHandle)
+    public static bool TryGetSession(
+        IMongoClient client,
+        out IClientSessionHandle sessionHandle)
+    {
+        if (Transaction.Current?.TransactionInformation.LocalIdentifier is { } id)
         {
-            if (Transaction.Current?.TransactionInformation.LocalIdentifier is { } id)
-            {
-                sessionHandle = GetOrCreateTransaction(client, id);
-                return true;
-            }
-
-            sessionHandle = null!;
-            return false;
+            sessionHandle = GetOrCreateTransaction(client, id);
+            return true;
         }
 
-        private static IClientSessionHandle GetOrCreateTransaction(
-            IMongoClient mongoClient,
-            string id)
-        {
-            return Sessions.GetOrAdd(id, CreateAndRegister);
+        sessionHandle = null!;
+        return false;
+    }
 
-            IClientSessionHandle CreateAndRegister(string idToRegister)
+    private static IClientSessionHandle GetOrCreateTransaction(
+        IMongoClient mongoClient,
+        string id)
+    {
+        return Sessions.GetOrAdd(id, CreateAndRegister);
+
+        IClientSessionHandle CreateAndRegister(string idToRegister)
+        {
+            if (Transaction.Current is null)
             {
-                if (Transaction.Current is null)
-                {
-                    throw new TransactionException(
-                        "Cannot open a transaction without a valid scope");
-                }
+                throw new TransactionException(
+                    "Cannot open a transaction without a valid scope");
+            }
 
-                IClientSessionHandle? session = mongoClient.StartSession();
-                session.StartTransaction();
-                MongoDbEnlistmentScope enlistment = new(session, Unregister);
+            IClientSessionHandle? session = mongoClient.StartSession();
+            session.StartTransaction();
+            MongoDbEnlistmentScope enlistment = new(session, Unregister);
 
-                Transaction.Current.EnlistVolatile(enlistment, EnlistmentOptions.None);
+            Transaction.Current.EnlistVolatile(enlistment, EnlistmentOptions.None);
 
-                return session;
+            return session;
 
-                void Unregister()
+            void Unregister()
+            {
+                if (Sessions.TryRemove(idToRegister, out session))
                 {
-                    if (Sessions.TryRemove(idToRegister, out session))
-                    {
-                        session.Dispose();
-                    }
+                    session.Dispose();
                 }
             }
         }