diff --git a/src/MongoDB.Driver/AggregateHelper.cs b/src/MongoDB.Driver/AggregateHelper.cs
new file mode 100644
index 00000000000..c0b1313411d
--- /dev/null
+++ b/src/MongoDB.Driver/AggregateHelper.cs
@@ -0,0 +1,96 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Linq;
+using MongoDB.Bson;
+
+namespace MongoDB.Driver
+{
+    internal static class AggregateHelper
+    {
+        public static RenderedPipelineDefinition<TResult> RenderAggregatePipeline<TDocument, TResult>(PipelineDefinition<TDocument, TResult> pipeline, RenderArgs<TDocument> renderArgs, out bool isAggregateToCollection)
+        {
+            var renderedPipeline = pipeline.Render(renderArgs);
+
+            var lastStage = renderedPipeline.Documents.LastOrDefault();
+            var lastStageName = lastStage?.GetElement(0).Name;
+            isAggregateToCollection = lastStage != null && (lastStageName == "$out" || lastStageName == "$merge");
+
+            return renderedPipeline;
+        }
+
+        public static CollectionNamespace GetOutCollection(BsonDocument outStage, DatabaseNamespace defaultDatabaseNamespace)
+        {
+            var stageName = outStage.GetElement(0).Name;
+            switch (stageName)
+            {
+                case "$out":
+                    {
+                        var outValue = outStage[0];
+                        DatabaseNamespace outputDatabaseNamespace;
+                        string outputCollectionName;
+                        if (outValue.IsString)
+                        {
+                            outputDatabaseNamespace = defaultDatabaseNamespace;
+                            outputCollectionName = outValue.AsString;
+                        }
+                        else
+                        {
+                            outputDatabaseNamespace = new DatabaseNamespace(outValue["db"].AsString);
+                            outputCollectionName = outValue["coll"].AsString;
+                        }
+                        return new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
+                    }
+                case "$merge":
+                    {
+                        var mergeArguments = outStage[0];
+                        DatabaseNamespace outputDatabaseNamespace;
+                        string outputCollectionName;
+                        if (mergeArguments.IsString)
+                        {
+                            outputDatabaseNamespace = defaultDatabaseNamespace;
+                            outputCollectionName = mergeArguments.AsString;
+                        }
+                        else
+                        {
+                            var into = mergeArguments.AsBsonDocument["into"];
+                            if (into.IsString)
+                            {
+                                outputDatabaseNamespace = defaultDatabaseNamespace;
+                                outputCollectionName = into.AsString;
+                            }
+                            else
+                            {
+                                if (into.AsBsonDocument.Contains("db"))
+                                {
+                                    outputDatabaseNamespace = new DatabaseNamespace(into["db"].AsString);
+                                }
+                                else
+                                {
+                                    outputDatabaseNamespace = defaultDatabaseNamespace;
+                                }
+                                outputCollectionName = into["coll"].AsString;
+                            }
+                        }
+                        return new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
+                    }
+                default:
+                    throw new ArgumentException($"Unexpected stage name: {stageName}.");
+            }
+        }
+    }
+}
+
diff --git a/src/MongoDB.Driver/IOperationExecutor.cs b/src/MongoDB.Driver/IOperationExecutor.cs
index 1af86d6ff62..bad44c4effe 100644
--- a/src/MongoDB.Driver/IOperationExecutor.cs
+++ b/src/MongoDB.Driver/IOperationExecutor.cs
@@ -13,23 +13,40 @@
 * limitations under the License.
 */
 
-using System;
 using System.Threading;
 using System.Threading.Tasks;
-using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Operations;
 
 namespace MongoDB.Driver
 {
     internal interface IOperationExecutor
     {
-        TResult ExecuteReadOperation<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken);
-        Task<TResult> ExecuteReadOperationAsync<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken);
+        TResult ExecuteReadOperation<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions options,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default);
 
-        TResult ExecuteWriteOperation<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken);
-        Task<TResult> ExecuteWriteOperationAsync<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken);
+        Task<TResult> ExecuteReadOperationAsync<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions options,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default);
+
+        TResult ExecuteWriteOperation<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions options,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default);
+
+        Task<TResult> ExecuteWriteOperationAsync<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions options,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default);
 
         IClientSessionHandle StartImplicitSession(CancellationToken cancellationToken);
+
         Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken cancellationToken);
     }
 }
diff --git a/src/MongoDB.Driver/MongoClient.cs b/src/MongoDB.Driver/MongoClient.cs
index 0fa1b4eb8d2..1aec659d044 100644
--- a/src/MongoDB.Driver/MongoClient.cs
+++ b/src/MongoDB.Driver/MongoClient.cs
@@ -23,7 +23,6 @@
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
-using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Logging;
 using MongoDB.Driver.Core.Misc;
@@ -45,6 +44,8 @@ public sealed class MongoClient : IMongoClient
         private readonly IOperationExecutor _operationExecutor;
         private readonly MongoClientSettings _settings;
         private readonly ILogger<LogCategories.Client> _logger;
+        private readonly ReadOperationOptions _readOperationOptions;
+        private readonly WriteOperationOptions _writeOperationOptions;
 
         // constructors
         /// <summary>
@@ -66,6 +67,9 @@ public MongoClient(MongoClientSettings settings)
 
             _cluster = _settings.ClusterSource.Get(_settings.ToClusterKey());
             _operationExecutor = new OperationExecutor(this);
+            _readOperationOptions = new ReadOperationOptions(DefaultReadPreference: _settings.ReadPreference);
+            _writeOperationOptions = new WriteOperationOptions();
+
             if (settings.AutoEncryptionOptions != null)
             {
                 _libMongoCryptController =
@@ -117,8 +121,6 @@ internal MongoClient(IOperationExecutor operationExecutor, MongoClientSettings s
         // internal methods
         internal void ConfigureAutoEncryptionMessageEncoderSettings(MessageEncoderSettings messageEncoderSettings)
         {
-            ThrowIfDisposed();
-
             var autoEncryptionOptions = _settings.AutoEncryptionOptions;
             if (autoEncryptionOptions != null)
             {
@@ -133,33 +135,33 @@ internal void ConfigureAutoEncryptionMessageEncoderSettings(MessageEncoderSettin
         // public methods
         /// <inheritdoc/>
         public ClientBulkWriteResult BulkWrite(IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options = null, CancellationToken cancellationToken = default)
-            => UsingImplicitSession(session => BulkWrite(session, models, options, cancellationToken), cancellationToken);
+            => OperationExecutor.ExecuteWriteOperation<ClientBulkWriteResult>(
+                CreateClientBulkWriteOperation(models, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public ClientBulkWriteResult BulkWrite(IClientSessionHandle session, IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options = null, CancellationToken cancellationToken = default)
-        {
-            var operation = CreateClientBulkWriteOperation(models, options);
-            return ExecuteWriteOperation<ClientBulkWriteResult>(session, operation, cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperation<ClientBulkWriteResult>(
+                CreateClientBulkWriteOperation(models, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public Task<ClientBulkWriteResult> BulkWriteAsync(IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options = null, CancellationToken cancellationToken = default)
-            => UsingImplicitSession(session => BulkWriteAsync(session, models, options, cancellationToken), cancellationToken);
+            => OperationExecutor.ExecuteWriteOperationAsync<ClientBulkWriteResult>(
+                CreateClientBulkWriteOperation(models, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public Task<ClientBulkWriteResult> BulkWriteAsync(IClientSessionHandle session, IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options = null, CancellationToken cancellationToken = default)
-        {
-            var operation = CreateClientBulkWriteOperation(models, options);
-            return ExecuteWriteOperationAsync<ClientBulkWriteResult>(session, operation, cancellationToken);
-        }
-
-        /// <inheritdoc/>
-        public void DropDatabase(string name, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            UsingImplicitSession(session => DropDatabase(session, name, cancellationToken), cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperationAsync<ClientBulkWriteResult>(
+                CreateClientBulkWriteOperation(models, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public void Dispose()
@@ -191,40 +193,34 @@ public void Dispose(bool disposing)
         }
 
         /// <inheritdoc/>
-        public void DropDatabase(IClientSessionHandle session, string name, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            ThrowIfDisposed();
-
-            var messageEncoderSettings = GetMessageEncoderSettings();
-            var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings)
-            {
-                WriteConcern = _settings.WriteConcern
-            };
-            ExecuteWriteOperation(session, operation, cancellationToken);
-        }
+        public void DropDatabase(string name, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateDropDatabaseOperation(name),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
-        public Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSessionAsync(session => DropDatabaseAsync(session, name, cancellationToken), cancellationToken);
-        }
+        public void DropDatabase(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateDropDatabaseOperation(name),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
-        public Task DropDatabaseAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
+        public Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateDropDatabaseOperation(name),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
-            Ensure.IsNotNull(session, nameof(session));
-            var messageEncoderSettings = GetMessageEncoderSettings();
-            var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings)
-            {
-                WriteConcern = _settings.WriteConcern
-            };
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
+        /// <inheritdoc/>
+        public Task DropDatabaseAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateDropDatabaseOperation(name),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings = null)
@@ -241,205 +237,143 @@ public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings =
         }
 
         /// <inheritdoc />
-        public IAsyncCursor<string> ListDatabaseNames(
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabaseNames(options: null, cancellationToken);
-        }
+        public IAsyncCursor<string> ListDatabaseNames(CancellationToken cancellationToken = default)
+            => ListDatabaseNames(options: null, cancellationToken);
 
         /// <inheritdoc />
         public IAsyncCursor<string> ListDatabaseNames(
             ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
+            CancellationToken cancellationToken = default)
         {
-            ThrowIfDisposed();
-
-            return UsingImplicitSession(session => ListDatabaseNames(session, options, cancellationToken), cancellationToken);
+            var listDatabasesOptions = CreateListDatabasesOptionsFromListDatabaseNamesOptions(options);
+            var databases = ListDatabases(listDatabasesOptions, cancellationToken);
+            return CreateDatabaseNamesCursor(databases);
         }
 
         /// <inheritdoc />
         public IAsyncCursor<string> ListDatabaseNames(
             IClientSessionHandle session,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabaseNames(session, options: null, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => ListDatabaseNames(session, options: null, cancellationToken);
 
         /// <inheritdoc />
         public IAsyncCursor<string> ListDatabaseNames(
             IClientSessionHandle session,
             ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
+            CancellationToken cancellationToken = default)
         {
-            ThrowIfDisposed();
-
             var listDatabasesOptions = CreateListDatabasesOptionsFromListDatabaseNamesOptions(options);
             var databases = ListDatabases(session, listDatabasesOptions, cancellationToken);
-
             return CreateDatabaseNamesCursor(databases);
         }
 
         /// <inheritdoc />
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabaseNamesAsync(options: null, cancellationToken);
-        }
+        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(CancellationToken cancellationToken = default)
+            => ListDatabaseNamesAsync(options: null, cancellationToken);
 
         /// <inheritdoc />
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
+        public async Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
             ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
+            CancellationToken cancellationToken = default)
         {
-            ThrowIfDisposed();
-
-            return UsingImplicitSessionAsync(session => ListDatabaseNamesAsync(session, options, cancellationToken), cancellationToken);
+            var listDatabasesOptions = CreateListDatabasesOptionsFromListDatabaseNamesOptions(options);
+            var databases = await ListDatabasesAsync(listDatabasesOptions, cancellationToken).ConfigureAwait(false);
+            return CreateDatabaseNamesCursor(databases);
         }
 
         /// <inheritdoc />
         public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
             IClientSessionHandle session,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabaseNamesAsync(session, options: null, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => ListDatabaseNamesAsync(session, options: null, cancellationToken);
 
         /// <inheritdoc />
         public async Task<IAsyncCursor<string>> ListDatabaseNamesAsync(
             IClientSessionHandle session,
             ListDatabaseNamesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
+            CancellationToken cancellationToken = default)
         {
-            ThrowIfDisposed();
-
             var listDatabasesOptions = CreateListDatabasesOptionsFromListDatabaseNamesOptions(options);
             var databases = await ListDatabasesAsync(session, listDatabasesOptions, cancellationToken).ConfigureAwait(false);
-
             return CreateDatabaseNamesCursor(databases);
         }
 
         /// <inheritdoc/>
-        public IAsyncCursor<BsonDocument> ListDatabases(
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSession(session => ListDatabases(session, cancellationToken), cancellationToken);
-        }
+        public IAsyncCursor<BsonDocument> ListDatabases(CancellationToken cancellationToken)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListDatabaseOperation(null),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public IAsyncCursor<BsonDocument> ListDatabases(
             ListDatabasesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSession(session => ListDatabases(session, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListDatabaseOperation(options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public IAsyncCursor<BsonDocument> ListDatabases(
             IClientSessionHandle session,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabases(session, null, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListDatabaseOperation(null),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public IAsyncCursor<BsonDocument> ListDatabases(
             IClientSessionHandle session,
             ListDatabasesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            Ensure.IsNotNull(session, nameof(session));
-            options = options ?? new ListDatabasesOptions();
-            var messageEncoderSettings = GetMessageEncoderSettings();
-            var translationOptions = _settings.TranslationOptions;
-            var operation = CreateListDatabaseOperation(options, messageEncoderSettings, translationOptions);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListDatabaseOperation(options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSessionAsync(session => ListDatabasesAsync(session, null, cancellationToken), cancellationToken);
-        }
+        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListDatabaseOperation(null),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
             ListDatabasesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSessionAsync(session => ListDatabasesAsync(session, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListDatabaseOperation(options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
             IClientSessionHandle session,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return ListDatabasesAsync(session, null, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListDatabaseOperation(null),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(
             IClientSessionHandle session,
             ListDatabasesOptions options,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            ThrowIfDisposed();
-
-            options = options ?? new ListDatabasesOptions();
-            var messageEncoderSettings = GetMessageEncoderSettings();
-            var translationOptions = _settings.TranslationOptions;
-            var operation = CreateListDatabaseOperation(options, messageEncoderSettings, translationOptions);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        /// <summary>
-        /// Starts an implicit session.
-        /// </summary>
-        /// <returns>A session.</returns>
-        internal IClientSessionHandle StartImplicitSession(CancellationToken cancellationToken)
-        {
-            ThrowIfDisposed();
-
-            return StartImplicitSession();
-        }
-
-        /// <summary>
-        /// Starts an implicit session.
-        /// </summary>
-        /// <returns>A Task whose result is a session.</returns>
-        internal Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken cancellationToken)
-        {
-            ThrowIfDisposed();
-
-            return Task.FromResult(StartImplicitSession());
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListDatabaseOperation(options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
-        public IClientSessionHandle StartSession(ClientSessionOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public IClientSessionHandle StartSession(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
         {
             ThrowIfDisposed();
 
@@ -447,7 +381,7 @@ internal Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken
         }
 
         /// <inheritdoc/>
-        public Task<IClientSessionHandle> StartSessionAsync(ClientSessionOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public Task<IClientSessionHandle> StartSessionAsync(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
         {
             ThrowIfDisposed();
 
@@ -458,56 +392,45 @@ internal Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken
         public IChangeStreamCursor<TResult> Watch<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSession(session => Watch(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public IChangeStreamCursor<TResult> Watch<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            ThrowIfDisposed();
-
-            var translationOptions = _settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            ThrowIfDisposed();
-
-            return UsingImplicitSessionAsync(session => WatchAsync(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         /// <inheritdoc/>
         public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-
-            ThrowIfDisposed();
-
-            var translationOptions = _settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         /// <inheritdoc/>
         public IMongoClient WithReadConcern(ReadConcern readConcern)
@@ -546,7 +469,7 @@ public IMongoClient WithWriteConcern(WriteConcern writeConcern)
         }
 
         // private methods
-        private ClientBulkWriteOperation CreateClientBulkWriteOperation(IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options = null)
+        private ClientBulkWriteOperation CreateClientBulkWriteOperation(IReadOnlyList<BulkWriteModel> models, ClientBulkWriteOptions options)
         {
             if (_settings.AutoEncryptionOptions != null)
             {
@@ -578,17 +501,22 @@ private ClientBulkWriteOperation CreateClientBulkWriteOperation(IReadOnlyList<Bu
         }
 
         private IAsyncCursor<string> CreateDatabaseNamesCursor(IAsyncCursor<BsonDocument> cursor)
-        {
-            return new BatchTransformingAsyncCursor<BsonDocument, string>(
+            => new BatchTransformingAsyncCursor<BsonDocument, string>(
                 cursor,
                 databases => databases.Select(database => database["name"].AsString));
-        }
 
-        private ListDatabasesOperation CreateListDatabaseOperation(
-            ListDatabasesOptions options,
-            MessageEncoderSettings messageEncoderSettings,
-            ExpressionTranslationOptions translationOptions)
+        private DropDatabaseOperation CreateDropDatabaseOperation(string name)
+            => new(new DatabaseNamespace(name), GetMessageEncoderSettings())
+            {
+                WriteConcern = _settings.WriteConcern
+            };
+
+        private ListDatabasesOperation CreateListDatabaseOperation(ListDatabasesOptions options)
         {
+            options ??= new ListDatabasesOptions();
+            var messageEncoderSettings = GetMessageEncoderSettings();
+            var translationOptions = _settings.TranslationOptions;
+
             return new ListDatabasesOperation(messageEncoderSettings)
             {
                 AuthorizedDatabases = options.AuthorizedDatabases,
@@ -612,69 +540,16 @@ private ListDatabasesOptions CreateListDatabasesOptionsFromListDatabaseNamesOpti
             return listDatabasesOptions;
         }
 
-        private IReadBindingHandle CreateReadBinding(IClientSessionHandle session)
-        {
-            var readPreference = _settings.ReadPreference;
-            if (session.IsInTransaction && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
-            {
-                throw new InvalidOperationException("Read preference in a transaction must be primary.");
-            }
-
-            var binding = new ReadPreferenceBinding(_cluster, readPreference, session.WrappedCoreSession.Fork());
-            return new ReadBindingHandle(binding);
-        }
-
-        private IReadWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session)
-        {
-            var binding = new WritableServerBinding(_cluster, session.WrappedCoreSession.Fork());
-            return new ReadWriteBindingHandle(binding);
-        }
-
         private ChangeStreamOperation<TResult> CreateChangeStreamOperation<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions options,
-            ExpressionTranslationOptions translationOptions)
-        {
-            return ChangeStreamHelper.CreateChangeStreamOperation(
-                pipeline,
+            ChangeStreamOptions options)
+            => ChangeStreamHelper.CreateChangeStreamOperation(
+                Ensure.IsNotNull(pipeline, nameof(pipeline)),
                 options,
                 _settings.ReadConcern,
                 GetMessageEncoderSettings(),
                 _settings.RetryReads,
-                translationOptions);
-        }
-
-        private TResult ExecuteReadOperation<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadBinding(session))
-            {
-                return _operationExecutor.ExecuteReadOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private async Task<TResult> ExecuteReadOperationAsync<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadBinding(session))
-            {
-                return await _operationExecutor.ExecuteReadOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        private TResult ExecuteWriteOperation<TResult>(IClientSessionHandle session, IWriteOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return _operationExecutor.ExecuteWriteOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private async Task<TResult> ExecuteWriteOperationAsync<TResult>(IClientSessionHandle session, IWriteOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return await _operationExecutor.ExecuteWriteOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
+                _settings.TranslationOptions);
 
         private MessageEncoderSettings GetMessageEncoderSettings()
         {
@@ -696,13 +571,6 @@ private RenderArgs<BsonDocument> GetRenderArgs()
             return new RenderArgs<BsonDocument>(BsonDocumentSerializer.Instance, serializerRegistry, translationOptions: translationOptions);
         }
 
-        private IClientSessionHandle StartImplicitSession()
-        {
-            var options = new ClientSessionOptions { CausalConsistency = false, Snapshot = false };
-            ICoreSessionHandle coreSession = _cluster.StartSession(options.ToCore(isImplicit: true));
-            return new ClientSessionHandle(this, options, coreSession);
-        }
-
         private IClientSessionHandle StartSession(ClientSessionOptions options)
         {
             if (options != null && options.Snapshot && options.CausalConsistency == true)
@@ -718,37 +586,5 @@ private IClientSessionHandle StartSession(ClientSessionOptions options)
 
         private void ThrowIfDisposed() => ThrowIfDisposed(string.Empty);
         private T ThrowIfDisposed<T>(T value) => _disposed ? throw new ObjectDisposedException(GetType().Name) : value;
-
-        private void UsingImplicitSession(Action<IClientSessionHandle> func, CancellationToken cancellationToken)
-        {
-            using (var session = StartImplicitSession(cancellationToken))
-            {
-                func(session);
-            }
-        }
-
-        private TResult UsingImplicitSession<TResult>(Func<IClientSessionHandle, TResult> func, CancellationToken cancellationToken)
-        {
-            using (var session = StartImplicitSession(cancellationToken))
-            {
-                return func(session);
-            }
-        }
-
-        private async Task UsingImplicitSessionAsync(Func<IClientSessionHandle, Task> funcAsync, CancellationToken cancellationToken)
-        {
-            using (var session = await StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
-            {
-                await funcAsync(session).ConfigureAwait(false);
-            }
-        }
-
-        private async Task<TResult> UsingImplicitSessionAsync<TResult>(Func<IClientSessionHandle, Task<TResult>> funcAsync, CancellationToken cancellationToken)
-        {
-            using (var session = await StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return await funcAsync(session).ConfigureAwait(false);
-            }
-        }
     }
 }
diff --git a/src/MongoDB.Driver/MongoCollectionImpl.cs b/src/MongoDB.Driver/MongoCollectionImpl.cs
index 51f03dc0a04..47d61cfc812 100644
--- a/src/MongoDB.Driver/MongoCollectionImpl.cs
+++ b/src/MongoDB.Driver/MongoCollectionImpl.cs
@@ -21,8 +21,6 @@
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
-using MongoDB.Driver.Core;
-using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Core.Operations;
@@ -41,6 +39,8 @@ internal sealed class MongoCollectionImpl<TDocument> : MongoCollectionBase<TDocu
         private readonly IOperationExecutor _operationExecutor;
         private readonly IBsonSerializer<TDocument> _documentSerializer;
         private readonly MongoCollectionSettings _settings;
+        private readonly ReadOperationOptions _readOperationOptions;
+        private readonly WriteOperationOptions _writeOperationOptions;
 
         // constructors
         public MongoCollectionImpl(IMongoDatabase database, CollectionNamespace collectionNamespace, MongoCollectionSettings settings, IClusterInternal cluster, IOperationExecutor operationExecutor)
@@ -58,6 +58,8 @@ private MongoCollectionImpl(IMongoDatabase database, CollectionNamespace collect
             _documentSerializer = Ensure.IsNotNull(documentSerializer, nameof(documentSerializer));
 
             _messageEncoderSettings = GetMessageEncoderSettings();
+            _readOperationOptions = new ReadOperationOptions(DefaultReadPreference: _settings.ReadPreference);
+            _writeOperationOptions = new WriteOperationOptions();
         }
 
         // properties
@@ -83,6 +85,8 @@ public override IMongoIndexManager<TDocument> Indexes
             get { return new MongoIndexManager(this); }
         }
 
+        private IOperationExecutor OperationExecutor => _operationExecutor;
+
         public override IMongoSearchIndexManager SearchIndexes
         {
             get { return new MongoSearchIndexManager(this); }
@@ -94,160 +98,117 @@ public override MongoCollectionSettings Settings
         }
 
         // public methods
-        public override IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             return UsingImplicitSession(session => Aggregate(session, pipeline, options, cancellationToken), cancellationToken);
         }
 
-        public override IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new AggregateOptions();
+            options ??= new AggregateOptions();
 
             var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var renderedPipeline = pipeline.Render(renderArgs);
-
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage != null && (lastStageName == "$out" || lastStageName == "$merge"))
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (isAggregateToCollection)
             {
                 var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                ExecuteWriteOperation(session, aggregateOperation, cancellationToken);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateAggregateToCollectionFindOperation(lastStage, renderedPipeline.OutputSerializer, options);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return deferredCursor;
+                OperationExecutor.ExecuteWriteOperation(aggregateOperation, _writeOperationOptions, session, cancellationToken);
+                return CreateAggregateToCollectionResultCursor(session, renderedPipeline, options);
             }
             else
             {
                 var aggregateOperation = CreateAggregateOperation(renderedPipeline, options);
-                return ExecuteReadOperation(session, aggregateOperation, cancellationToken);
+                return OperationExecutor.ExecuteReadOperation(aggregateOperation, _readOperationOptions, session, cancellationToken);
             }
         }
 
-        public override Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             return UsingImplicitSessionAsync(session => AggregateAsync(session, pipeline, options, cancellationToken), cancellationToken);
         }
 
-        public override async Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new AggregateOptions();
+            options ??= new AggregateOptions();
 
             var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var renderedPipeline = pipeline.Render(renderArgs);
-
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage != null && (lastStageName == "$out" || lastStageName == "$merge"))
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (isAggregateToCollection)
             {
                 var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                await ExecuteWriteOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateAggregateToCollectionFindOperation(lastStage, renderedPipeline.OutputSerializer, options);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return await Task.FromResult<IAsyncCursor<TResult>>(deferredCursor).ConfigureAwait(false);
+                await OperationExecutor.ExecuteWriteOperationAsync(aggregateOperation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
+                return CreateAggregateToCollectionResultCursor(session, renderedPipeline, options);
             }
             else
             {
                 var aggregateOperation = CreateAggregateOperation(renderedPipeline, options);
-                return await ExecuteReadOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
+                return await OperationExecutor.ExecuteReadOperationAsync(aggregateOperation, _readOperationOptions, session, cancellationToken).ConfigureAwait(false);
             }
         }
 
-        public override void AggregateToCollection<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override void AggregateToCollection<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             UsingImplicitSession(session => AggregateToCollection(session, pipeline, options, cancellationToken), cancellationToken);
         }
 
-        public override void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new AggregateOptions();
+            options ??= new AggregateOptions();
 
             var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var renderedPipeline = pipeline.Render(renderArgs);
-
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage == null || (lastStageName != "$out" && lastStageName != "$merge"))
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (renderedPipeline.Documents.Count == 0 || !isAggregateToCollection)
             {
                 throw new InvalidOperationException("AggregateToCollection requires that the last stage be $out or $merge.");
             }
 
             var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-            ExecuteWriteOperation(session, aggregateOperation, cancellationToken);
+            OperationExecutor.ExecuteWriteOperation(aggregateOperation, _writeOperationOptions, session, cancellationToken);
         }
 
-        public override Task AggregateToCollectionAsync<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override Task AggregateToCollectionAsync<TResult>(PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             return UsingImplicitSessionAsync(session => AggregateToCollectionAsync(session, pipeline, options, cancellationToken), cancellationToken);
         }
 
-        public override async Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new AggregateOptions();
+            options ??= new AggregateOptions();
 
             var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var renderedPipeline = pipeline.Render(renderArgs);
-
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage == null || (lastStageName != "$out" && lastStageName != "$merge"))
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (renderedPipeline.Documents.Count == 0 || !isAggregateToCollection)
             {
                 throw new InvalidOperationException("AggregateToCollectionAsync requires that the last stage be $out or $merge.");
             }
 
             var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-            await ExecuteWriteOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
+            await OperationExecutor.ExecuteWriteOperationAsync(aggregateOperation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
         }
 
-        public override BulkWriteResult<TDocument> BulkWrite(IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override BulkWriteResult<TDocument> BulkWrite(IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSession(session => BulkWrite(session, requests, options, cancellationToken), cancellationToken);
+            using var session = OperationExecutor.StartImplicitSession(cancellationToken);
+            return BulkWrite(session, requests, options, cancellationToken);
         }
 
-        public override BulkWriteResult<TDocument> BulkWrite(IClientSessionHandle session, IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override BulkWriteResult<TDocument> BulkWrite(IClientSessionHandle session, IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull((object)requests, nameof(requests));
-
             var requestsArray = requests.ToArray();
-            if (requestsArray.Length == 0)
-            {
-                throw new ArgumentException("Must contain at least 1 request.", nameof(requests));
-            }
-
-            foreach (var request in requestsArray)
-            {
-                request.ThrowIfNotValid();
-            }
-
-            options = options ?? new BulkWriteOptions();
 
-            var renderArgs = GetRenderArgs();
-            var operation = CreateBulkWriteOperation(session, requestsArray, options, renderArgs);
+            var operation = CreateBulkWriteOperation(session, requestsArray, options);
             try
             {
-                var result = ExecuteWriteOperation(session, operation, cancellationToken);
+                var result = OperationExecutor.ExecuteWriteOperation(operation, _writeOperationOptions, session, cancellationToken);
                 return BulkWriteResult<TDocument>.FromCore(result, requestsArray);
             }
             catch (MongoBulkWriteOperationException ex)
@@ -256,34 +217,21 @@ public override MongoCollectionSettings Settings
             }
         }
 
-        public override Task<BulkWriteResult<TDocument>> BulkWriteAsync(IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task<BulkWriteResult<TDocument>> BulkWriteAsync(IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSessionAsync(session => BulkWriteAsync(session, requests, options, cancellationToken), cancellationToken);
+            using var session = await OperationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+            return await BulkWriteAsync(session, requests, options, cancellationToken).ConfigureAwait(false);
         }
 
-        public override async Task<BulkWriteResult<TDocument>> BulkWriteAsync(IClientSessionHandle session, IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task<BulkWriteResult<TDocument>> BulkWriteAsync(IClientSessionHandle session, IEnumerable<WriteModel<TDocument>> requests, BulkWriteOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull((object)requests, nameof(requests));
-
             var requestsArray = requests.ToArray();
-            if (requestsArray.Length == 0)
-            {
-                throw new ArgumentException("Must contain at least 1 request.", nameof(requests));
-            }
 
-            foreach (var request in requestsArray)
-            {
-                request.ThrowIfNotValid();
-            }
-
-            options = options ?? new BulkWriteOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateBulkWriteOperation(session, requestsArray, options, renderArgs);
+            var operation = CreateBulkWriteOperation(session, requestsArray, options);
             try
             {
-                var result = await ExecuteWriteOperationAsync(session, operation, cancellationToken).ConfigureAwait(false);
+                var result = await OperationExecutor.ExecuteWriteOperationAsync(operation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
                 return BulkWriteResult<TDocument>.FromCore(result, requestsArray);
             }
             catch (MongoBulkWriteOperationException ex)
@@ -293,314 +241,242 @@ public override MongoCollectionSettings Settings
         }
 
         [Obsolete("Use CountDocuments or EstimatedDocumentCount instead.")]
-        public override long Count(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => Count(session, filter, options, cancellationToken), cancellationToken);
-        }
+        public override long Count(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateCountOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         [Obsolete("Use CountDocuments or EstimatedDocumentCount instead.")]
-        public override long Count(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new CountOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateCountOperation(filter, options, renderArgs);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
+        public override long Count(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateCountOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         [Obsolete("Use CountDocumentsAsync or EstimatedDocumentCountAsync instead.")]
-        public override Task<long> CountAsync(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => CountAsync(session, filter, options, cancellationToken), cancellationToken);
-        }
+        public override Task<long> CountAsync(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateCountOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         [Obsolete("Use CountDocumentsAsync or EstimatedDocumentCountAsync instead.")]
-        public override Task<long> CountAsync(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new CountOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateCountOperation(filter, options, renderArgs);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override long CountDocuments(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => CountDocuments(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override long CountDocuments(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new CountOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateCountDocumentsOperation(filter, options, renderArgs);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<long> CountDocumentsAsync(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => CountDocumentsAsync(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<long> CountDocumentsAsync(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new CountOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateCountDocumentsOperation(filter, options, renderArgs);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override IAsyncCursor<TField> Distinct<TField>(FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => Distinct(session, field, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override IAsyncCursor<TField> Distinct<TField>(IClientSessionHandle session, FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(field, nameof(field));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new DistinctOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateDistinctOperation(field, filter, options, renderArgs);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TField>> DistinctAsync<TField>(FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => DistinctAsync(session, field, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TField>> DistinctAsync<TField>(IClientSessionHandle session, FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(field, nameof(field));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new DistinctOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateDistinctOperation(field, filter, options, renderArgs);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override IAsyncCursor<TItem> DistinctMany<TItem>(FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => DistinctMany(session, field, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override IAsyncCursor<TItem> DistinctMany<TItem>(IClientSessionHandle session, FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(field, nameof(field));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new DistinctOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateDistinctManyOperation(field, filter, options, renderArgs);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TItem>> DistinctManyAsync<TItem>(FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => DistinctManyAsync(session, field, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TItem>> DistinctManyAsync<TItem>(IClientSessionHandle session, FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(field, nameof(field));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new DistinctOptions();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateDistinctManyOperation(field, filter, options, renderArgs);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override long EstimatedDocumentCount(EstimatedDocumentCountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session =>
-            {
-                var operation = CreateEstimatedDocumentCountOperation(options);
-                return ExecuteReadOperation(session, operation, cancellationToken);
-            });
-        }
-
-        public override Task<long> EstimatedDocumentCountAsync(EstimatedDocumentCountOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session =>
-            {
-                var operation = CreateEstimatedDocumentCountOperation(options);
-                return ExecuteReadOperationAsync(session, operation, cancellationToken);
-            });
-        }
-
-        public override IAsyncCursor<TProjection> FindSync<TProjection>(FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => FindSync(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override IAsyncCursor<TProjection> FindSync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new FindOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var operation = CreateFindOperation<TProjection>(filter, options, renderArgs);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => FindAsync(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new FindOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs(options.TranslationOptions);
-            var operation = CreateFindOperation<TProjection>(filter, options, renderArgs);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override TProjection FindOneAndDelete<TProjection>(FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => FindOneAndDelete(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override TProjection FindOneAndDelete<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new FindOneAndDeleteOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndDeleteOperation<TProjection>(filter, options, renderArgs);
-            return ExecuteWriteOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndDeleteAsync<TProjection>(FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => FindOneAndDeleteAsync(session, filter, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndDeleteAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            options = options ?? new FindOneAndDeleteOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndDeleteOperation<TProjection>(filter, options, renderArgs);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override TProjection FindOneAndReplace<TProjection>(FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => FindOneAndReplace(session, filter, replacement, options, cancellationToken), cancellationToken);
-        }
-
-        public override TProjection FindOneAndReplace<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            var replacementObject = Ensure.IsNotNull((object)replacement, nameof(replacement)); // only box once if it's a struct
-            options = options ?? new FindOneAndReplaceOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndReplaceOperation(filter, replacementObject, options, renderArgs);
-            return ExecuteWriteOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndReplaceAsync<TProjection>(FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => FindOneAndReplaceAsync(session, filter, replacement, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndReplaceAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            var replacementObject = Ensure.IsNotNull((object)replacement, nameof(replacement)); // only box once if it's a struct
-            options = options ?? new FindOneAndReplaceOptions<TDocument, TProjection>();
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndReplaceOperation(filter, replacementObject, options, renderArgs);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
-
-        public override TProjection FindOneAndUpdate<TProjection>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => FindOneAndUpdate(session, filter, update, options, cancellationToken), cancellationToken);
-        }
-
-        public override TProjection FindOneAndUpdate<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            Ensure.IsNotNull(update, nameof(update));
-            options = options ?? new FindOneAndUpdateOptions<TDocument, TProjection>();
-
-            if (update is PipelineUpdateDefinition<TDocument> && (options.ArrayFilters != null && options.ArrayFilters.Any()))
-            {
-                throw new NotSupportedException("An arrayfilter is not supported in the pipeline-style update.");
-            }
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndUpdateOperation(filter, update, options, renderArgs);
-            return ExecuteWriteOperation(session, operation, cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndUpdateAsync<TProjection>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => FindOneAndUpdateAsync(session, filter, update, options, cancellationToken), cancellationToken);
-        }
-
-        public override Task<TProjection> FindOneAndUpdateAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(filter, nameof(filter));
-            Ensure.IsNotNull(update, nameof(update));
-            options = options ?? new FindOneAndUpdateOptions<TDocument, TProjection>();
-
-            if (update is PipelineUpdateDefinition<TDocument> && (options.ArrayFilters != null && options.ArrayFilters.Any()))
-            {
-                throw new NotSupportedException("An arrayfilter is not supported in the pipeline-style update.");
-            }
-
-            var renderArgs = GetRenderArgs();
-            var operation = CreateFindOneAndUpdateOperation(filter, update, options, renderArgs);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
+        public override Task<long> CountAsync(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateCountOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override long CountDocuments(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateCountDocumentsOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override long CountDocuments(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateCountDocumentsOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<long> CountDocumentsAsync(FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateCountDocumentsOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<long> CountDocumentsAsync(IClientSessionHandle session, FilterDefinition<TDocument> filter, CountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateCountDocumentsOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override IAsyncCursor<TField> Distinct<TField>(FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateDistinctOperation(field, filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override IAsyncCursor<TField> Distinct<TField>(IClientSessionHandle session, FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateDistinctOperation(field, filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<IAsyncCursor<TField>> DistinctAsync<TField>(FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateDistinctOperation(field, filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<IAsyncCursor<TField>> DistinctAsync<TField>(IClientSessionHandle session, FieldDefinition<TDocument, TField> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateDistinctOperation(field, filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override IAsyncCursor<TItem> DistinctMany<TItem>(FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateDistinctManyOperation(field, filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override IAsyncCursor<TItem> DistinctMany<TItem>(IClientSessionHandle session, FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateDistinctManyOperation(field, filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<IAsyncCursor<TItem>> DistinctManyAsync<TItem>(FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateDistinctManyOperation(field, filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<IAsyncCursor<TItem>> DistinctManyAsync<TItem>(IClientSessionHandle session, FieldDefinition<TDocument, IEnumerable<TItem>> field, FilterDefinition<TDocument> filter, DistinctOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateDistinctManyOperation(field, filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override long EstimatedDocumentCount(EstimatedDocumentCountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateEstimatedDocumentCountOperation(options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<long> EstimatedDocumentCountAsync(EstimatedDocumentCountOptions options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateEstimatedDocumentCountOperation(options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override IAsyncCursor<TProjection> FindSync<TProjection>(FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateFindOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override IAsyncCursor<TProjection> FindSync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateFindOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateFindOperation(filter, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateFindOperation(filter, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override TProjection FindOneAndDelete<TProjection>(FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndDeleteOperation(filter, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override TProjection FindOneAndDelete<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndDeleteOperation(filter, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<TProjection> FindOneAndDeleteAsync<TProjection>(FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndDeleteOperation(filter, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<TProjection> FindOneAndDeleteAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, FindOneAndDeleteOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndDeleteOperation(filter, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override TProjection FindOneAndReplace<TProjection>(FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndReplaceOperation(filter, replacement, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override TProjection FindOneAndReplace<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndReplaceOperation(filter, replacement, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<TProjection> FindOneAndReplaceAsync<TProjection>(FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndReplaceOperation(filter, replacement, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<TProjection> FindOneAndReplaceAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, TDocument replacement, FindOneAndReplaceOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndReplaceOperation(filter, replacement, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override TProjection FindOneAndUpdate<TProjection>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndUpdateOperation(filter, update, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override TProjection FindOneAndUpdate<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateFindOneAndUpdateOperation(filter, update, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public override Task<TProjection> FindOneAndUpdateAsync<TProjection>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndUpdateOperation(filter, update, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public override Task<TProjection> FindOneAndUpdateAsync<TProjection>(IClientSessionHandle session, FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TProjection> options, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateFindOneAndUpdateOperation(filter, update, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         [Obsolete("Use Aggregation pipeline instead.")]
-        public override IAsyncCursor<TResult> MapReduce<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public override IAsyncCursor<TResult> MapReduce<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default)
         {
             return UsingImplicitSession(session => MapReduce(session, map, reduce, options, cancellationToken), cancellationToken);
         }
 
         [Obsolete("Use Aggregation pipeline instead.")]
-        public override IAsyncCursor<TResult> MapReduce<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public override IAsyncCursor<TResult> MapReduce<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(map, nameof(map));
             Ensure.IsNotNull(reduce, nameof(reduce));
-            options = options ?? new MapReduceOptions<TDocument, TResult>();
+            options ??= new MapReduceOptions<TDocument, TResult>();
 
             var outputOptions = options.OutputOptions ?? MapReduceOutputOptions.Inline;
             var resultSerializer = ResolveResultSerializer<TResult>(options.ResultSerializer);
@@ -609,38 +485,29 @@ public override MongoCollectionSettings Settings
             if (outputOptions == MapReduceOutputOptions.Inline)
             {
                 var operation = CreateMapReduceOperation(map, reduce, options, resultSerializer, renderArgs);
-                return ExecuteReadOperation(session, operation, cancellationToken);
+                return OperationExecutor.ExecuteReadOperation(operation, _readOperationOptions, session, cancellationToken);
             }
             else
             {
                 var mapReduceOperation = CreateMapReduceOutputToCollectionOperation(map, reduce, options, outputOptions, renderArgs);
-                ExecuteWriteOperation(session, mapReduceOperation, cancellationToken);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateMapReduceOutputToCollectionFindOperation<TResult>(options, mapReduceOperation.OutputCollectionNamespace, resultSerializer);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return deferredCursor;
+                OperationExecutor.ExecuteWriteOperation(mapReduceOperation, _writeOperationOptions, session, cancellationToken);
+                return CreateMapReduceOutputToCollectionResultCursor(session, options, mapReduceOperation.OutputCollectionNamespace, resultSerializer);
             }
         }
 
         [Obsolete("Use Aggregation pipeline instead.")]
-        public override Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public override Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default)
         {
             return UsingImplicitSessionAsync(session => MapReduceAsync(session, map, reduce, options, cancellationToken), cancellationToken);
         }
 
         [Obsolete("Use Aggregation pipeline instead.")]
-        public override async Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public override async Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<TDocument, TResult> options = null, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
             Ensure.IsNotNull(map, nameof(map));
             Ensure.IsNotNull(reduce, nameof(reduce));
-            options = options ?? new MapReduceOptions<TDocument, TResult>();
+            options ??= new MapReduceOptions<TDocument, TResult>();
 
             var outputOptions = options.OutputOptions ?? MapReduceOutputOptions.Inline;
             var resultSerializer = ResolveResultSerializer<TResult>(options.ResultSerializer);
@@ -649,22 +516,13 @@ public override MongoCollectionSettings Settings
             if (outputOptions == MapReduceOutputOptions.Inline)
             {
                 var operation = CreateMapReduceOperation(map, reduce, options, resultSerializer, renderArgs);
-                return await ExecuteReadOperationAsync(session, operation, cancellationToken).ConfigureAwait(false);
+                return await OperationExecutor.ExecuteReadOperationAsync(operation, _readOperationOptions, session, cancellationToken).ConfigureAwait(false);
             }
             else
             {
                 var mapReduceOperation = CreateMapReduceOutputToCollectionOperation(map, reduce, options, outputOptions, renderArgs);
-                await ExecuteWriteOperationAsync(session, mapReduceOperation, cancellationToken).ConfigureAwait(false);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateMapReduceOutputToCollectionFindOperation<TResult>(options, mapReduceOperation.OutputCollectionNamespace, resultSerializer);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return await Task.FromResult(deferredCursor).ConfigureAwait(false);
+                await OperationExecutor.ExecuteWriteOperationAsync(mapReduceOperation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
+                return CreateMapReduceOutputToCollectionResultCursor(session, options, mapReduceOperation.OutputCollectionNamespace, resultSerializer);
             }
         }
 
@@ -685,44 +543,42 @@ public override IFilteredMongoCollection<TDerivedDocument> OfType<TDerivedDocume
         public override IChangeStreamCursor<TResult> Watch<TResult>(
             PipelineDefinition<ChangeStreamDocument<TDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => Watch(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         public override IChangeStreamCursor<TResult> Watch<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<TDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            var translationOptions = _database.Client.Settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public override Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             PipelineDefinition<ChangeStreamDocument<TDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => WatchAsync(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         public override Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<TDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            var translationOptions = _database.Client.Settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public override IMongoCollection<TDocument> WithReadConcern(ReadConcern readConcern)
         {
@@ -850,72 +706,11 @@ private AggregateOperation<TResult> CreateAggregateOperation<TResult>(RenderedPi
             };
         }
 
-        private FindOperation<TResult> CreateAggregateToCollectionFindOperation<TResult>(BsonDocument outStage, IBsonSerializer<TResult> resultSerializer, AggregateOptions options)
+        private IAsyncCursor<TResult> CreateAggregateToCollectionResultCursor<TResult>(IClientSessionHandle session, RenderedPipelineDefinition<TResult> pipeline, AggregateOptions options)
         {
-            CollectionNamespace outputCollectionNamespace;
-            var stageName = outStage.GetElement(0).Name;
-            switch (stageName)
-            {
-                case "$out":
-                    {
-                        var outValue = outStage[0];
-                        DatabaseNamespace outputDatabaseNamespace;
-                        string outputCollectionName;
-                        if (outValue.IsString)
-                        {
-                            outputDatabaseNamespace = _collectionNamespace.DatabaseNamespace;
-                            outputCollectionName = outValue.AsString;
-                        }
-                        else
-                        {
-                            outputDatabaseNamespace = new DatabaseNamespace(outValue["db"].AsString);
-                            outputCollectionName = outValue["coll"].AsString;
-                        }
-                        outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
-                    }
-                    break;
-                case "$merge":
-                    {
-                        var mergeArguments = outStage[0];
-                        DatabaseNamespace outputDatabaseNamespace;
-                        string outputCollectionName;
-                        if (mergeArguments.IsString)
-                        {
-                            outputDatabaseNamespace = _collectionNamespace.DatabaseNamespace;
-                            outputCollectionName = mergeArguments.AsString;
-                        }
-                        else
-                        {
-                            var into = mergeArguments.AsBsonDocument["into"];
-                            if (into.IsString)
-                            {
-                                outputDatabaseNamespace = _collectionNamespace.DatabaseNamespace;
-                                outputCollectionName = into.AsString;
-                            }
-                            else
-                            {
-                                if (into.AsBsonDocument.Contains("db"))
-                                {
-                                    outputDatabaseNamespace = new DatabaseNamespace(into["db"].AsString);
-                                }
-                                else
-                                {
-                                    outputDatabaseNamespace = _collectionNamespace.DatabaseNamespace;
-                                }
-                                outputCollectionName = into["coll"].AsString;
-                            }
-                        }
-                        outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
-                    }
-                    break;
-                default:
-                    throw new ArgumentException($"Unexpected stage name: {stageName}.");
-            }
+            var outputCollectionNamespace = AggregateHelper.GetOutCollection(pipeline.Documents.Last(), _collectionNamespace.DatabaseNamespace);
 
-            return new FindOperation<TResult>(
-                outputCollectionNamespace,
-                resultSerializer,
-                _messageEncoderSettings)
+            var findOperation = new FindOperation<TResult>(outputCollectionNamespace, pipeline.OutputSerializer, _messageEncoderSettings)
             {
                 BatchSize = options.BatchSize,
                 Collation = options.Collation,
@@ -923,6 +718,16 @@ private FindOperation<TResult> CreateAggregateToCollectionFindOperation<TResult>
                 ReadConcern = _settings.ReadConcern,
                 RetryRequested = _database.Client.Settings.RetryReads
             };
+
+            // we want to delay execution of the find because the user may
+            // not want to iterate the results at all...
+            var forkedSession = session.Fork();
+            var readOperationOptions = _readOperationOptions with { ExplicitReadPreference = ReadPreference.Primary };
+            var deferredCursor = new DeferredAsyncCursor<TResult>(
+                () => forkedSession.Dispose(),
+                ct => OperationExecutor.ExecuteReadOperation(findOperation, readOperationOptions, forkedSession, ct),
+                ct => OperationExecutor.ExecuteReadOperationAsync(findOperation, readOperationOptions, forkedSession, ct));
+            return deferredCursor;
         }
 
         private AggregateToCollectionOperation CreateAggregateToCollectionOperation<TResult>(RenderedPipelineDefinition<TResult> renderedPipeline, AggregateOptions options)
@@ -947,15 +752,28 @@ private AggregateToCollectionOperation CreateAggregateToCollectionOperation<TRes
 
         private BulkMixedWriteOperation CreateBulkWriteOperation(
             IClientSessionHandle session,
-            IEnumerable<WriteModel<TDocument>> requests,
-            BulkWriteOptions options,
-            RenderArgs<TDocument> renderArgs)
+            IReadOnlyList<WriteModel<TDocument>> requests,
+            BulkWriteOptions options)
         {
+            Ensure.IsNotNull((object)requests, nameof(requests));
+            if (requests.Count == 0)
+            {
+                throw new ArgumentException("Must contain at least 1 request.", nameof(requests));
+            }
+
+            options ??= new BulkWriteOptions();
+            var renderArgs = GetRenderArgs();
             var effectiveWriteConcern = session.IsInTransaction ? WriteConcern.Acknowledged : _settings.WriteConcern;
 
+            var writeModels = requests.Select((model, index) =>
+            {
+                model.ThrowIfNotValid();
+                return ConvertWriteModelToWriteRequest(model, index, renderArgs);
+            }).ToArray();
+
             return new BulkMixedWriteOperation(
                 _collectionNamespace,
-                requests.Select((model, index) => ConvertWriteModelToWriteRequest(model, index, renderArgs)),
+                writeModels,
                 _messageEncoderSettings)
             {
                 BypassDocumentValidation = options.BypassDocumentValidation,
@@ -969,9 +787,11 @@ private BulkMixedWriteOperation CreateBulkWriteOperation(
 
         private ChangeStreamOperation<TResult> CreateChangeStreamOperation<TResult>(
             PipelineDefinition<ChangeStreamDocument<TDocument>, TResult> pipeline,
-            ChangeStreamOptions options,
-            ExpressionTranslationOptions translationOptions)
+            ChangeStreamOptions options)
         {
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            var translationOptions = _database.Client.Settings.TranslationOptions;
+
             return ChangeStreamHelper.CreateChangeStreamOperation(
                 this,
                 pipeline,
@@ -984,9 +804,12 @@ private ChangeStreamOperation<TResult> CreateChangeStreamOperation<TResult>(
 
         private CountDocumentsOperation CreateCountDocumentsOperation(
             FilterDefinition<TDocument> filter,
-            CountOptions options,
-            RenderArgs<TDocument> renderArgs)
+            CountOptions options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new CountOptions();
+            var renderArgs = GetRenderArgs();
+
             return new CountDocumentsOperation(_collectionNamespace, _messageEncoderSettings)
             {
                 Collation = options.Collation,
@@ -1003,9 +826,12 @@ private CountDocumentsOperation CreateCountDocumentsOperation(
 
         private CountOperation CreateCountOperation(
             FilterDefinition<TDocument> filter,
-            CountOptions options,
-            RenderArgs<TDocument> renderArgs)
+            CountOptions options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new CountOptions();
+            var renderArgs = GetRenderArgs();
+
             return new CountOperation(_collectionNamespace, _messageEncoderSettings)
             {
                 Collation = options.Collation,
@@ -1023,9 +849,12 @@ private CountOperation CreateCountOperation(
         private DistinctOperation<TField> CreateDistinctOperation<TField>(
             FieldDefinition<TDocument, TField> field,
             FilterDefinition<TDocument> filter,
-            DistinctOptions options,
-            RenderArgs<TDocument> renderArgs)
+            DistinctOptions options)
         {
+            Ensure.IsNotNull(field, nameof(field));
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new DistinctOptions();
+            var renderArgs = GetRenderArgs();
             var renderedField = field.Render(renderArgs);
             var valueSerializer = GetValueSerializerForDistinct(renderedField, _settings.SerializerRegistry);
 
@@ -1047,9 +876,12 @@ private DistinctOperation<TField> CreateDistinctOperation<TField>(
         private DistinctOperation<TItem> CreateDistinctManyOperation<TItem>(
             FieldDefinition<TDocument, IEnumerable<TItem>> field,
             FilterDefinition<TDocument> filter,
-            DistinctOptions options,
-            RenderArgs<TDocument> renderArgs)
+            DistinctOptions options)
         {
+            Ensure.IsNotNull(field, nameof(field));
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new DistinctOptions();
+            var renderArgs = GetRenderArgs();
             var renderedField = field.Render(renderArgs);
             var itemSerializer = GetItemSerializerForDistinctMany(renderedField, _settings.SerializerRegistry);
 
@@ -1080,9 +912,11 @@ private EstimatedDocumentCountOperation CreateEstimatedDocumentCountOperation(Es
 
         private FindOneAndDeleteOperation<TProjection> CreateFindOneAndDeleteOperation<TProjection>(
             FilterDefinition<TDocument> filter,
-            FindOneAndDeleteOptions<TDocument, TProjection> options,
-            RenderArgs<TDocument> renderArgs)
+            FindOneAndDeleteOptions<TDocument, TProjection> options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new FindOneAndDeleteOptions<TDocument, TProjection>();
+            var renderArgs = GetRenderArgs();
             var projection = options.Projection ?? new ClientSideDeserializationProjectionDefinition<TDocument, TProjection>();
             var renderedProjection = projection.Render(renderArgs with { RenderForFind = true });
 
@@ -1106,17 +940,21 @@ private FindOneAndDeleteOperation<TProjection> CreateFindOneAndDeleteOperation<T
 
         private FindOneAndReplaceOperation<TProjection> CreateFindOneAndReplaceOperation<TProjection>(
             FilterDefinition<TDocument> filter,
-            object replacementObject,
-            FindOneAndReplaceOptions<TDocument, TProjection> options,
-            RenderArgs<TDocument> renderArgs)
+            object replacement,
+            FindOneAndReplaceOptions<TDocument, TProjection> options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            Ensure.IsNotNull(replacement, nameof(replacement));
+            options ??= new FindOneAndReplaceOptions<TDocument, TProjection>();
+
+            var renderArgs = GetRenderArgs();
             var projection = options.Projection ?? new ClientSideDeserializationProjectionDefinition<TDocument, TProjection>();
             var renderedProjection = projection.Render(renderArgs with { RenderForFind = true });
 
             return new FindOneAndReplaceOperation<TProjection>(
                 _collectionNamespace,
                 filter.Render(renderArgs),
-                new BsonDocumentWrapper(replacementObject, _documentSerializer),
+                new BsonDocumentWrapper(replacement, _documentSerializer),
                 new FindAndModifyValueDeserializer<TProjection>(renderedProjection.ProjectionSerializer),
                 _messageEncoderSettings)
             {
@@ -1138,9 +976,18 @@ private FindOneAndReplaceOperation<TProjection> CreateFindOneAndReplaceOperation
         private FindOneAndUpdateOperation<TProjection> CreateFindOneAndUpdateOperation<TProjection>(
             FilterDefinition<TDocument> filter,
             UpdateDefinition<TDocument> update,
-            FindOneAndUpdateOptions<TDocument, TProjection> options,
-            RenderArgs<TDocument> renderArgs)
+            FindOneAndUpdateOptions<TDocument, TProjection> options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            Ensure.IsNotNull(update, nameof(update));
+            options = options ?? new FindOneAndUpdateOptions<TDocument, TProjection>();
+
+            if (update is PipelineUpdateDefinition<TDocument> && (options.ArrayFilters != null && options.ArrayFilters.Any()))
+            {
+                throw new NotSupportedException("An arrayfilter is not supported in the pipeline-style update.");
+            }
+
+            var renderArgs = GetRenderArgs();
             var projection = options.Projection ?? new ClientSideDeserializationProjectionDefinition<TDocument, TProjection>();
             var renderedProjection = projection.Render(renderArgs with { RenderForFind = true });
 
@@ -1169,9 +1016,12 @@ private FindOneAndUpdateOperation<TProjection> CreateFindOneAndUpdateOperation<T
 
         private FindOperation<TProjection> CreateFindOperation<TProjection>(
             FilterDefinition<TDocument> filter,
-            FindOptions<TDocument, TProjection> options,
-            RenderArgs<TDocument> renderArgs)
+            FindOptions<TDocument, TProjection> options)
         {
+            Ensure.IsNotNull(filter, nameof(filter));
+            options ??= new FindOptions<TDocument, TProjection>();
+
+            var renderArgs = GetRenderArgs(options.TranslationOptions);
             var projection = options.Projection ?? new ClientSideDeserializationProjectionDefinition<TDocument, TProjection>();
             var renderedProjection = projection.Render(renderArgs with { RenderForFind = true });
 
@@ -1285,10 +1135,10 @@ private MapReduceOutputToCollectionOperation CreateMapReduceOutputToCollectionOp
         }
 
 #pragma warning disable CS0618 // Type or member is obsolete
-        private FindOperation<TResult> CreateMapReduceOutputToCollectionFindOperation<TResult>(MapReduceOptions<TDocument, TResult> options, CollectionNamespace outputCollectionNamespace, IBsonSerializer<TResult> resultSerializer)
+        private IAsyncCursor<TResult> CreateMapReduceOutputToCollectionResultCursor<TResult>(IClientSessionHandle session, MapReduceOptions<TDocument, TResult> options, CollectionNamespace outputCollectionNamespace, IBsonSerializer<TResult> resultSerializer)
 #pragma warning restore CS0618 // Type or member is obsolete
         {
-            return new FindOperation<TResult>(
+            var findOperation = new FindOperation<TResult>(
                 outputCollectionNamespace,
                 resultSerializer,
                 _messageEncoderSettings)
@@ -1298,21 +1148,16 @@ private FindOperation<TResult> CreateMapReduceOutputToCollectionFindOperation<TR
                 ReadConcern = _settings.ReadConcern,
                 RetryRequested = _database.Client.Settings.RetryReads
             };
-        }
 
-        private IReadBindingHandle CreateReadBinding(IClientSessionHandle session, ReadPreference readPreference)
-        {
-            if (session.IsInTransaction && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
-            {
-                throw new InvalidOperationException("Read preference in a transaction must be primary.");
-            }
-
-            return ChannelPinningHelper.CreateReadBinding(_cluster, session.WrappedCoreSession.Fork(), readPreference);
-        }
-
-        private IWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session)
-        {
-            return ChannelPinningHelper.CreateReadWriteBinding(_cluster, session.WrappedCoreSession.Fork());
+            // we want to delay execution of the find because the user may
+            // not want to iterate the results at all...
+            var forkedSession = session.Fork();
+            var readOperationOptions = _readOperationOptions with { ExplicitReadPreference = ReadPreference.Primary };
+            var deferredCursor = new DeferredAsyncCursor<TResult>(
+                () => forkedSession.Dispose(),
+                ct => OperationExecutor.ExecuteReadOperation(findOperation, readOperationOptions, forkedSession, ct),
+                ct => OperationExecutor.ExecuteReadOperationAsync(findOperation, readOperationOptions, forkedSession, ct));
+            return deferredCursor;
         }
 
         private MessageEncoderSettings GetMessageEncoderSettings()
@@ -1389,50 +1234,6 @@ private RenderArgs<TDocument> GetRenderArgs(ExpressionTranslationOptions transla
             return new RenderArgs<TDocument>(_documentSerializer, _settings.SerializerRegistry, translationOptions: translationOptions);
         }
 
-        private TResult ExecuteReadOperation<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, _settings.ReadPreference);
-            return ExecuteReadOperation(session, operation, effectiveReadPreference, cancellationToken);
-        }
-
-        private TResult ExecuteReadOperation<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, ReadPreference readPreference, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadBinding(session, readPreference))
-            {
-                return _operationExecutor.ExecuteReadOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private Task<TResult> ExecuteReadOperationAsync<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, _settings.ReadPreference);
-            return ExecuteReadOperationAsync(session, operation, effectiveReadPreference, cancellationToken);
-        }
-
-        private async Task<TResult> ExecuteReadOperationAsync<TResult>(IClientSessionHandle session, IReadOperation<TResult> operation, ReadPreference readPreference, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadBinding(session, readPreference))
-            {
-                return await _operationExecutor.ExecuteReadOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        private TResult ExecuteWriteOperation<TResult>(IClientSessionHandle session, IWriteOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return _operationExecutor.ExecuteWriteOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private async Task<TResult> ExecuteWriteOperationAsync<TResult>(IClientSessionHandle session, IWriteOperation<TResult> operation, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return await _operationExecutor.ExecuteWriteOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
         private IEnumerable<BsonDocument> RenderArrayFilters(IEnumerable<ArrayFilterDefinition> arrayFilters)
         {
             if (arrayFilters == null)
@@ -1465,7 +1266,7 @@ private IBsonSerializer<TResult> ResolveResultSerializer<TResult>(IBsonSerialize
             return _settings.SerializerRegistry.GetSerializer<TResult>();
         }
 
-        private void UsingImplicitSession(Action<IClientSessionHandle> func, CancellationToken cancellationToken = default(CancellationToken))
+        private void UsingImplicitSession(Action<IClientSessionHandle> func, CancellationToken cancellationToken = default)
         {
             using (var session = _operationExecutor.StartImplicitSession(cancellationToken))
             {
@@ -1473,7 +1274,7 @@ private IBsonSerializer<TResult> ResolveResultSerializer<TResult>(IBsonSerialize
             }
         }
 
-        private TResult UsingImplicitSession<TResult>(Func<IClientSessionHandle, TResult> func, CancellationToken cancellationToken = default(CancellationToken))
+        private TResult UsingImplicitSession<TResult>(Func<IClientSessionHandle, TResult> func, CancellationToken cancellationToken = default)
         {
             using (var session = _operationExecutor.StartImplicitSession(cancellationToken))
             {
@@ -1481,7 +1282,7 @@ private IBsonSerializer<TResult> ResolveResultSerializer<TResult>(IBsonSerialize
             }
         }
 
-        private async Task UsingImplicitSessionAsync(Func<IClientSessionHandle, Task> funcAsync, CancellationToken cancellationToken = default(CancellationToken))
+        private async Task UsingImplicitSessionAsync(Func<IClientSessionHandle, Task> funcAsync, CancellationToken cancellationToken = default)
         {
             using (var session = await _operationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
             {
@@ -1489,7 +1290,7 @@ private IBsonSerializer<TResult> ResolveResultSerializer<TResult>(IBsonSerialize
             }
         }
 
-        private async Task<TResult> UsingImplicitSessionAsync<TResult>(Func<IClientSessionHandle, Task<TResult>> funcAsync, CancellationToken cancellationToken = default(CancellationToken))
+        private async Task<TResult> UsingImplicitSessionAsync<TResult>(Func<IClientSessionHandle, Task<TResult>> funcAsync, CancellationToken cancellationToken = default)
         {
             using (var session = await _operationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
             {
@@ -1526,231 +1327,192 @@ public override MongoCollectionSettings Settings
             }
 
             // public methods
-            public override IEnumerable<string> CreateMany(IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return CreateMany(models, null, cancellationToken);
-            }
+            public override IEnumerable<string> CreateMany(IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default)
+                => CreateMany(models, null, cancellationToken);
 
             public override IEnumerable<string> CreateMany(
                 IEnumerable<CreateIndexModel<TDocument>> models,
                 CreateManyIndexesOptions options,
-                CancellationToken cancellationToken = default(CancellationToken))
+                CancellationToken cancellationToken = default)
             {
-                return _collection.UsingImplicitSession(session => CreateMany(session, models, options, cancellationToken), cancellationToken);
+                var operation = CreateCreateIndexesOperation(models, options);
+                _collection.OperationExecutor.ExecuteWriteOperation(operation, _collection._writeOperationOptions, null, cancellationToken);
+                return operation.Requests.Select(x => x.GetIndexName());
             }
 
-            public override IEnumerable<string> CreateMany(IClientSessionHandle session, IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return CreateMany(session, models, null, cancellationToken);
-            }
+            public override IEnumerable<string> CreateMany(IClientSessionHandle session, IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default)
+                => CreateMany(session, models, null, cancellationToken);
 
             public override IEnumerable<string> CreateMany(
                 IClientSessionHandle session,
                 IEnumerable<CreateIndexModel<TDocument>> models,
                 CreateManyIndexesOptions options,
-                CancellationToken cancellationToken = default(CancellationToken))
+                CancellationToken cancellationToken = default)
             {
                 Ensure.IsNotNull(session, nameof(session));
-                Ensure.IsNotNull(models, nameof(models));
 
-                var renderArgs = _collection.GetRenderArgs();
-                var requests = CreateCreateIndexRequests(models, renderArgs);
-                var operation = CreateCreateIndexesOperation(requests, options);
-                _collection.ExecuteWriteOperation(session, operation, cancellationToken);
-
-                return requests.Select(x => x.GetIndexName());
+                var operation = CreateCreateIndexesOperation(models, options);
+                _collection.OperationExecutor.ExecuteWriteOperation(operation, _collection._writeOperationOptions, session, cancellationToken);
+                return operation.Requests.Select(x => x.GetIndexName());
             }
 
-            public override Task<IEnumerable<string>> CreateManyAsync(IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return CreateManyAsync(models, null, cancellationToken);
-            }
+            public override Task<IEnumerable<string>> CreateManyAsync(IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default)
+                => CreateManyAsync(models, null, cancellationToken);
 
-            public override Task<IEnumerable<string>> CreateManyAsync(
+            public override async Task<IEnumerable<string>> CreateManyAsync(
                 IEnumerable<CreateIndexModel<TDocument>> models,
                 CreateManyIndexesOptions options,
-                CancellationToken cancellationToken = default(CancellationToken))
+                CancellationToken cancellationToken = default)
             {
-                return _collection.UsingImplicitSessionAsync(session => CreateManyAsync(session, models, options, cancellationToken), cancellationToken);
+                var operation = CreateCreateIndexesOperation(models, options);
+                await _collection.OperationExecutor.ExecuteWriteOperationAsync(operation, _collection._writeOperationOptions, null, cancellationToken).ConfigureAwait(false);
+                return operation.Requests.Select(x => x.GetIndexName());
             }
 
-            public override Task<IEnumerable<string>> CreateManyAsync(IClientSessionHandle session, IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return CreateManyAsync(session, models, null, cancellationToken);
-            }
+            public override Task<IEnumerable<string>> CreateManyAsync(IClientSessionHandle session, IEnumerable<CreateIndexModel<TDocument>> models, CancellationToken cancellationToken = default)
+                => CreateManyAsync(session, models, null, cancellationToken);
 
             public override async Task<IEnumerable<string>> CreateManyAsync(
                 IClientSessionHandle session,
                 IEnumerable<CreateIndexModel<TDocument>> models,
                 CreateManyIndexesOptions options,
-                CancellationToken cancellationToken = default(CancellationToken))
+                CancellationToken cancellationToken = default)
             {
                 Ensure.IsNotNull(session, nameof(session));
-                Ensure.IsNotNull(models, nameof(models));
 
-                var renderArgs = _collection.GetRenderArgs();
-                var requests = CreateCreateIndexRequests(models, renderArgs);
-                var operation = CreateCreateIndexesOperation(requests, options);
-                await _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken).ConfigureAwait(false);
-
-                return requests.Select(x => x.GetIndexName());
+                var operation = CreateCreateIndexesOperation(models, options);
+                await _collection.OperationExecutor.ExecuteWriteOperationAsync(operation, _collection._writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
+                return operation.Requests.Select(x => x.GetIndexName());
             }
 
             public override void DropAll(CancellationToken cancellationToken)
-            {
-                _collection.UsingImplicitSession(session => DropAll(session, cancellationToken), cancellationToken);
-            }
+                => DropAll(options: null, cancellationToken);
 
-            public override void DropAll(DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                _collection.UsingImplicitSession(session => DropAll(session, options, cancellationToken), cancellationToken);
-            }
+            public override void DropAll(DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    CreateDropAllOperation(options),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
-            public override void DropAll(IClientSessionHandle session, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                DropAll(session, null, cancellationToken);
-            }
+            public override void DropAll(IClientSessionHandle session, CancellationToken cancellationToken = default)
+                => DropAll(session, null, cancellationToken);
 
-            public override void DropAll(IClientSessionHandle session, DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                var operation = CreateDropAllOperation(options);
-                _collection.ExecuteWriteOperation(session, operation, cancellationToken);
-            }
+            public override void DropAll(IClientSessionHandle session, DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    CreateDropAllOperation(options),
+                    _collection._writeOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
             public override Task DropAllAsync(CancellationToken cancellationToken)
-            {
-                return _collection.UsingImplicitSessionAsync(session => DropAllAsync(session, cancellationToken), cancellationToken);
-            }
+                => DropAllAsync(options: null, cancellationToken);
 
-            public override Task DropAllAsync(DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return _collection.UsingImplicitSessionAsync(session => DropAllAsync(session, options, cancellationToken), cancellationToken);
-            }
+            public override Task DropAllAsync(DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    CreateDropAllOperation(options),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
-            public override Task DropAllAsync(IClientSessionHandle session, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return DropAllAsync(session, null, cancellationToken);
-            }
+            public override Task DropAllAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
+                => DropAllAsync(session, null, cancellationToken);
 
-            public override Task DropAllAsync(IClientSessionHandle session, DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                var operation = CreateDropAllOperation(options);
-                return _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken);
-            }
+            public override Task DropAllAsync(IClientSessionHandle session, DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    CreateDropAllOperation(options),
+                    _collection._writeOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
-            public override void DropOne(string name, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                _collection.UsingImplicitSession(session => DropOne(session, name, cancellationToken), cancellationToken);
-            }
+            public override void DropOne(string name, CancellationToken cancellationToken = default)
+                => DropOne(name, null, cancellationToken);
 
-            public override void DropOne(string name, DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                _collection.UsingImplicitSession(session => DropOne(session, name, options, cancellationToken), cancellationToken);
-            }
+            public override void DropOne(string name, DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    CreateDropOneOperation(name, options),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
-            public override void DropOne(IClientSessionHandle session, string name, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                DropOne(session, name, null, cancellationToken);
-            }
+            public override void DropOne(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+                => DropOne(session, name, null, cancellationToken);
 
             public override void DropOne(
                 IClientSessionHandle session,
                 string name,
                 DropIndexOptions options,
                 CancellationToken cancellationToken)
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                Ensure.IsNotNullOrEmpty(name, nameof(name));
-                if (name == "*")
-                {
-                    throw new ArgumentException("Cannot specify '*' for the index name. Use DropAllAsync to drop all indexes.", "name");
-                }
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    CreateDropOneOperation(name, options),
+                    _collection._writeOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
-                var operation = CreateDropOneOperation(name, options);
-                _collection.ExecuteWriteOperation(session, operation, cancellationToken);
-            }
-
-            public override Task DropOneAsync(string name, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return _collection.UsingImplicitSessionAsync(session => DropOneAsync(session, name, cancellationToken), cancellationToken);
-            }
+            public override Task DropOneAsync(string name, CancellationToken cancellationToken = default)
+                => DropOneAsync(name, null, cancellationToken);
 
-            public override Task DropOneAsync(string name, DropIndexOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return _collection.UsingImplicitSessionAsync(session => DropOneAsync(session, name, options, cancellationToken), cancellationToken);
-            }
+            public override Task DropOneAsync(string name, DropIndexOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    CreateDropOneOperation(name, options),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
-            public override Task DropOneAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return DropOneAsync(session, name, null, cancellationToken);
-            }
+            public override Task DropOneAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+                => DropOneAsync(session, name, null, cancellationToken);
 
             public override Task DropOneAsync(
                 IClientSessionHandle session,
                 string name,
                 DropIndexOptions options,
                 CancellationToken cancellationToken)
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                Ensure.IsNotNullOrEmpty(name, nameof(name));
-                if (name == "*")
-                {
-                    throw new ArgumentException("Cannot specify '*' for the index name. Use DropAllAsync to drop all indexes.", "name");
-                }
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    CreateDropOneOperation(name, options),
+                    _collection._writeOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
-                var operation = CreateDropOneOperation(name, options);
-                return _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken);
-            }
+            public override IAsyncCursor<BsonDocument> List(CancellationToken cancellationToken = default)
+                => List(options: null, cancellationToken);
 
-            public override IAsyncCursor<BsonDocument> List(CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return List(options: null, cancellationToken);
-            }
-
-            public override IAsyncCursor<BsonDocument> List(ListIndexesOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return _collection.UsingImplicitSession(session => List(session, options, cancellationToken), cancellationToken);
-            }
+            public override IAsyncCursor<BsonDocument> List(ListIndexesOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteReadOperation(
+                    CreateListIndexesOperation(options),
+                    _collection._readOperationOptions,
+                    cancellationToken: cancellationToken);
 
             public override IAsyncCursor<BsonDocument> List(IClientSessionHandle session, CancellationToken cancellationToken = default)
-            {
-                return List(session, options: null, cancellationToken);
-            }
+                => List(session, options: null, cancellationToken);
 
-            public override IAsyncCursor<BsonDocument> List(IClientSessionHandle session, ListIndexesOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                var operation = CreateListIndexesOperation(options);
-                return _collection.ExecuteReadOperation(session, operation, ReadPreference.Primary, cancellationToken);
-            }
+            public override IAsyncCursor<BsonDocument> List(IClientSessionHandle session, ListIndexesOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteReadOperation(
+                    CreateListIndexesOperation(options),
+                    _collection._readOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
-            public override Task<IAsyncCursor<BsonDocument>> ListAsync(CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return ListAsync(options: null, cancellationToken);
-            }
+            public override Task<IAsyncCursor<BsonDocument>> ListAsync(CancellationToken cancellationToken = default)
+                => ListAsync(options: null, cancellationToken);
 
-            public override Task<IAsyncCursor<BsonDocument>> ListAsync(ListIndexesOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                return _collection.UsingImplicitSessionAsync(session => ListAsync(session, options, cancellationToken), cancellationToken);
-            }
+            public override Task<IAsyncCursor<BsonDocument>> ListAsync(ListIndexesOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteReadOperationAsync(
+                    CreateListIndexesOperation(options),
+                    _collection._readOperationOptions,
+                    cancellationToken: cancellationToken);
 
             public override Task<IAsyncCursor<BsonDocument>> ListAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
-            {
-                return ListAsync(session, options: null, cancellationToken);
-            }
+                => ListAsync(session, options: null, cancellationToken);
 
-            public override Task<IAsyncCursor<BsonDocument>> ListAsync(IClientSessionHandle session, ListIndexesOptions options, CancellationToken cancellationToken = default(CancellationToken))
-            {
-                Ensure.IsNotNull(session, nameof(session));
-                var operation = CreateListIndexesOperation(options);
-                return _collection.ExecuteReadOperationAsync(session, operation, ReadPreference.Primary, cancellationToken);
-            }
+            public override Task<IAsyncCursor<BsonDocument>> ListAsync(IClientSessionHandle session, ListIndexesOptions options, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteReadOperationAsync(
+                    CreateListIndexesOperation(options),
+                    _collection._readOperationOptions,
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
 
             // private methods
-            private CreateIndexesOperation CreateCreateIndexesOperation(IEnumerable<CreateIndexRequest> requests, CreateManyIndexesOptions options)
+            private CreateIndexesOperation CreateCreateIndexesOperation(IEnumerable<CreateIndexModel<TDocument>> models, CreateManyIndexesOptions options)
             {
+                Ensure.IsNotNull((object)models, nameof(models));
+                var requests = CreateCreateIndexRequests(models);
+
                 return new CreateIndexesOperation(_collection._collectionNamespace, requests, _collection._messageEncoderSettings)
                 {
                     Comment = options?.Comment,
@@ -1760,8 +1522,9 @@ private CreateIndexesOperation CreateCreateIndexesOperation(IEnumerable<CreateIn
                 };
             }
 
-            private IEnumerable<CreateIndexRequest> CreateCreateIndexRequests(IEnumerable<CreateIndexModel<TDocument>> models, RenderArgs<TDocument> renderArgs)
+            private IEnumerable<CreateIndexRequest> CreateCreateIndexRequests(IEnumerable<CreateIndexModel<TDocument>> models)
             {
+                var renderArgs = _collection.GetRenderArgs();
                 return models.Select(m =>
                 {
                     var options = m.Options ?? new CreateIndexOptions<TDocument>();
@@ -1809,6 +1572,12 @@ private DropIndexOperation CreateDropAllOperation(DropIndexOptions options)
 
             private DropIndexOperation CreateDropOneOperation(string name, DropIndexOptions options)
             {
+                Ensure.IsNotNullOrEmpty(name, nameof(name));
+                if (name == "*")
+                {
+                    throw new ArgumentException("Cannot specify '*' for the index name. Use DropAllAsync to drop all indexes.", "name");
+                }
+
                 return new DropIndexOperation(_collection._collectionNamespace, name, _collection._messageEncoderSettings)
                 {
                     Comment = options?.Comment,
@@ -1842,19 +1611,15 @@ public MongoSearchIndexManager(MongoCollectionImpl<TDocument> collection)
             public IEnumerable<string> CreateMany(IEnumerable<CreateSearchIndexModel> models, CancellationToken cancellationToken = default)
             {
                 var operation = CreateCreateIndexesOperation(models);
-                var result = _collection.UsingImplicitSession(session => _collection.ExecuteWriteOperation(session, operation, cancellationToken), cancellationToken);
-                var indexNames = GetIndexNames(result);
-
-                return indexNames;
+                var result = _collection.OperationExecutor.ExecuteWriteOperation(operation, _collection._writeOperationOptions, null, cancellationToken);
+                return GetIndexNames(result);
             }
 
             public async Task<IEnumerable<string>> CreateManyAsync(IEnumerable<CreateSearchIndexModel> models, CancellationToken cancellationToken = default)
             {
                 var operation = CreateCreateIndexesOperation(models);
-                var result = await _collection.UsingImplicitSessionAsync(session => _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken), cancellationToken).ConfigureAwait(false);
-                var indexNames = GetIndexNames(result);
-
-                return indexNames;
+                var result = await _collection.OperationExecutor.ExecuteWriteOperationAsync(operation, _collection._writeOperationOptions, null, cancellationToken).ConfigureAwait(false);
+                return GetIndexNames(result);
             }
 
             public string CreateOne(BsonDocument definition, string name = null, CancellationToken cancellationToken = default) =>
@@ -1876,16 +1641,16 @@ public async Task<string> CreateOneAsync(CreateSearchIndexModel model, Cancellat
             }
 
             public void DropOne(string indexName, CancellationToken cancellationToken = default)
-            {
-                var operation = new DropSearchIndexOperation(_collection.CollectionNamespace, indexName, _collection._messageEncoderSettings);
-                _collection.UsingImplicitSession(session => _collection.ExecuteWriteOperation(session, operation, cancellationToken), cancellationToken);
-            }
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    new DropSearchIndexOperation(_collection.CollectionNamespace, indexName, _collection._messageEncoderSettings),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
             public Task DropOneAsync(string indexName, CancellationToken cancellationToken = default)
-            {
-                var operation = new DropSearchIndexOperation(_collection.CollectionNamespace, indexName, _collection._messageEncoderSettings);
-                return _collection.UsingImplicitSessionAsync(session => _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken), cancellationToken);
-            }
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    new DropSearchIndexOperation(_collection.CollectionNamespace, indexName, _collection._messageEncoderSettings),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
             public IAsyncCursor<BsonDocument> List(string indexName, AggregateOptions aggregateOptions = null, CancellationToken cancellationToken = default)
             {
@@ -1898,18 +1663,16 @@ public Task<IAsyncCursor<BsonDocument>> ListAsync(string indexName, AggregateOpt
             }
 
             public void Update(string indexName, BsonDocument definition, CancellationToken cancellationToken = default)
-            {
-                var operation = new UpdateSearchIndexOperation(_collection.CollectionNamespace, indexName, definition, _collection._messageEncoderSettings);
-
-                _collection.UsingImplicitSession(session => _collection.ExecuteWriteOperation(session, operation, cancellationToken), cancellationToken);
-            }
-
-            public async Task UpdateAsync(string indexName, BsonDocument definition, CancellationToken cancellationToken = default)
-            {
-                var operation = new UpdateSearchIndexOperation(_collection.CollectionNamespace, indexName, definition, _collection._messageEncoderSettings);
-
-                await _collection.UsingImplicitSessionAsync(session => _collection.ExecuteWriteOperationAsync(session, operation, cancellationToken), cancellationToken).ConfigureAwait(false);
-            }
+                => _collection.OperationExecutor.ExecuteWriteOperation(
+                    new UpdateSearchIndexOperation(_collection.CollectionNamespace, indexName, definition, _collection._messageEncoderSettings),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
+
+            public Task UpdateAsync(string indexName, BsonDocument definition, CancellationToken cancellationToken = default)
+                => _collection.OperationExecutor.ExecuteWriteOperationAsync(
+                    new UpdateSearchIndexOperation(_collection.CollectionNamespace, indexName, definition, _collection._messageEncoderSettings),
+                    _collection._writeOperationOptions,
+                    cancellationToken: cancellationToken);
 
             // private methods
             private PipelineDefinition<TDocument, BsonDocument> CreateListIndexesStage(string indexName)
diff --git a/src/MongoDB.Driver/MongoDatabase.cs b/src/MongoDB.Driver/MongoDatabase.cs
index a57eec55d94..e4694f28f16 100644
--- a/src/MongoDB.Driver/MongoDatabase.cs
+++ b/src/MongoDB.Driver/MongoDatabase.cs
@@ -23,8 +23,6 @@
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
-using MongoDB.Driver.Core;
-using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Core.Operations;
@@ -42,6 +40,9 @@ internal sealed class MongoDatabase : IMongoDatabase
         private readonly IOperationExecutor _operationExecutor;
         private readonly MongoDatabaseSettings _settings;
 
+        private readonly ReadOperationOptions _readOperationOptions;
+        private readonly WriteOperationOptions _writeOperationOptions;
+
         // constructors
         public MongoDatabase(IMongoClient client, DatabaseNamespace databaseNamespace, MongoDatabaseSettings settings, IClusterInternal cluster, IOperationExecutor operationExecutor)
         {
@@ -50,139 +51,122 @@ public MongoDatabase(IMongoClient client, DatabaseNamespace databaseNamespace, M
             _settings = Ensure.IsNotNull(settings, nameof(settings)).Freeze();
             _cluster = Ensure.IsNotNull(cluster, nameof(cluster));
             _operationExecutor = Ensure.IsNotNull(operationExecutor, nameof(operationExecutor));
+
+            _readOperationOptions = new ReadOperationOptions(DefaultReadPreference: _settings.ReadPreference);
+            _writeOperationOptions = new WriteOperationOptions();
         }
 
         // public properties
         public IMongoClient Client => _client;
         public DatabaseNamespace DatabaseNamespace => _databaseNamespace;
+        private IOperationExecutor OperationExecutor => _operationExecutor;
         public MongoDatabaseSettings Settings => _settings;
 
         // public methods
-        public IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSession(session => Aggregate(session, pipeline, options, cancellationToken), cancellationToken);
+            using var session = OperationExecutor.StartImplicitSession(cancellationToken);
+            return Aggregate(session, pipeline, options, cancellationToken);
         }
 
-        public IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options?.TranslationOptions);
-            var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(renderArgs);
-            options = options ?? new AggregateOptions();
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            options ??= new AggregateOptions();
 
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage != null && (lastStageName == "$out" || lastStageName == "$merge"))
+            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options.TranslationOptions);
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (isAggregateToCollection)
             {
                 var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                ExecuteWriteOperation(session, aggregateOperation, cancellationToken);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateAggregateToCollectionFindOperation(lastStage, renderedPipeline.OutputSerializer, options);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return deferredCursor;
+                OperationExecutor.ExecuteWriteOperation(aggregateOperation, _writeOperationOptions, session, cancellationToken);
+                return CreateAggregateToCollectionResultCursor(session, renderedPipeline, options);
             }
             else
             {
                 var aggregateOperation = CreateAggregateOperation(renderedPipeline, options);
-                return ExecuteReadOperation(session, aggregateOperation, cancellationToken);
+                return OperationExecutor.ExecuteReadOperation(aggregateOperation, _readOperationOptions, session, cancellationToken);
             }
         }
 
-        public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSessionAsync(session => AggregateAsync(session, pipeline, options, cancellationToken), cancellationToken);
+            using var session = await OperationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+            return await AggregateAsync(session, pipeline, options, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options?.TranslationOptions);
-            var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(renderArgs);
-            options = options ?? new AggregateOptions();
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            options ??= new AggregateOptions();
 
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage != null && (lastStageName == "$out" || lastStageName == "$merge"))
+            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options.TranslationOptions);
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (isAggregateToCollection)
             {
                 var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                await ExecuteWriteOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
-
-                // we want to delay execution of the find because the user may
-                // not want to iterate the results at all...
-                var findOperation = CreateAggregateToCollectionFindOperation(lastStage, renderedPipeline.OutputSerializer, options);
-                var forkedSession = session.Fork();
-                var deferredCursor = new DeferredAsyncCursor<TResult>(
-                    () => forkedSession.Dispose(),
-                    ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct),
-                    ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct));
-                return await Task.FromResult<IAsyncCursor<TResult>>(deferredCursor).ConfigureAwait(false);
+                await OperationExecutor.ExecuteWriteOperationAsync(aggregateOperation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
+                return CreateAggregateToCollectionResultCursor(session, renderedPipeline, options);
             }
             else
             {
                 var aggregateOperation = CreateAggregateOperation(renderedPipeline, options);
-                return await ExecuteReadOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
+                return await OperationExecutor.ExecuteReadOperationAsync(aggregateOperation, _readOperationOptions, session, cancellationToken).ConfigureAwait(false);
             }
         }
 
-        public void AggregateToCollection<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public void AggregateToCollection<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
-            UsingImplicitSession(session => AggregateToCollection(session, pipeline, options, cancellationToken), cancellationToken);
+            using var session = OperationExecutor.StartImplicitSession(cancellationToken);
+            AggregateToCollection(session, pipeline, options, cancellationToken);
         }
 
-        public void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options?.TranslationOptions);
-            var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(renderArgs);
-            options = options ?? new AggregateOptions();
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            options ??= new AggregateOptions();
 
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage == null || (lastStageName != "$out" && lastStageName != "$merge"))
+            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options.TranslationOptions);
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (!isAggregateToCollection)
             {
                 throw new InvalidOperationException("AggregateToCollection requires that the last stage be $out or $merge.");
             }
-            else
-            {
-                var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                ExecuteWriteOperation(session, aggregateOperation, cancellationToken);
-            }
+
+            var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
+            OperationExecutor.ExecuteWriteOperation(aggregateOperation, _writeOperationOptions, session, cancellationToken);
         }
 
-        public Task AggregateToCollectionAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task AggregateToCollectionAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSessionAsync(session => AggregateToCollectionAsync(session, pipeline, options, cancellationToken), cancellationToken);
+            using var session = await OperationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+            await AggregateToCollectionAsync(session, pipeline, options, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default)
         {
             Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options?.TranslationOptions);
-            var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(renderArgs);
-            options = options ?? new AggregateOptions();
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            options ??= new AggregateOptions();
 
-            var lastStage = renderedPipeline.Documents.LastOrDefault();
-            var lastStageName = lastStage?.GetElement(0).Name;
-            if (lastStage == null || (lastStageName != "$out" && lastStageName != "$merge"))
+            var renderArgs = GetRenderArgs(NoPipelineInputSerializer.Instance, options.TranslationOptions);
+            var renderedPipeline = AggregateHelper.RenderAggregatePipeline(pipeline, renderArgs, out bool isAggregateToCollection);
+            if (!isAggregateToCollection)
             {
                 throw new InvalidOperationException("AggregateToCollectionAsync requires that the last stage be $out or $merge.");
             }
-            else
-            {
-                var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
-                await ExecuteWriteOperationAsync(session, aggregateOperation, cancellationToken).ConfigureAwait(false);
-            }
+
+            var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options);
+            await OperationExecutor.ExecuteWriteOperationAsync(aggregateOperation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
         }
 
         public void CreateCollection(string name, CreateCollectionOptions options, CancellationToken cancellationToken)
         {
-            UsingImplicitSession(session => CreateCollection(session, name, options, cancellationToken), cancellationToken);
+            using var session = OperationExecutor.StartImplicitSession(cancellationToken);
+            CreateCollection(session, name, options, cancellationToken);
         }
 
         public void CreateCollection(IClientSessionHandle session, string name, CreateCollectionOptions options, CancellationToken cancellationToken)
@@ -203,7 +187,7 @@ public void CreateCollection(IClientSessionHandle session, string name, CreateCo
                 return;
             }
 
-            var genericMethodDefinition = typeof(MongoDatabase).GetTypeInfo().GetMethod("CreateCollectionHelper", BindingFlags.NonPublic | BindingFlags.Instance);
+            var genericMethodDefinition = typeof(MongoDatabase).GetTypeInfo().GetMethod(nameof(CreateCollectionHelper), BindingFlags.NonPublic | BindingFlags.Instance);
             var documentType = options.GetType().GetTypeInfo().GetGenericArguments()[0];
             var methodInfo = genericMethodDefinition.MakeGenericMethod(documentType);
             try
@@ -216,9 +200,10 @@ public void CreateCollection(IClientSessionHandle session, string name, CreateCo
             }
         }
 
-        public Task CreateCollectionAsync(string name, CreateCollectionOptions options, CancellationToken cancellationToken)
+        public async Task CreateCollectionAsync(string name, CreateCollectionOptions options, CancellationToken cancellationToken)
         {
-            return UsingImplicitSessionAsync(session => CreateCollectionAsync(session, name, options, cancellationToken), cancellationToken);
+            using var session = await OperationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+            await CreateCollectionAsync(session, name, options, cancellationToken).ConfigureAwait(false);
         }
 
         public async Task CreateCollectionAsync(IClientSessionHandle session, string name, CreateCollectionOptions options, CancellationToken cancellationToken)
@@ -239,7 +224,7 @@ public async Task CreateCollectionAsync(IClientSessionHandle session, string nam
                 return;
             }
 
-            var genericMethodDefinition = typeof(MongoDatabase).GetTypeInfo().GetMethod("CreateCollectionHelperAsync", BindingFlags.NonPublic | BindingFlags.Instance);
+            var genericMethodDefinition = typeof(MongoDatabase).GetTypeInfo().GetMethod(nameof(CreateCollectionHelperAsync), BindingFlags.NonPublic | BindingFlags.Instance);
             var documentType = options.GetType().GetTypeInfo().GetGenericArguments()[0];
             var methodInfo = genericMethodDefinition.MakeGenericMethod(documentType);
             try
@@ -252,39 +237,31 @@ public async Task CreateCollectionAsync(IClientSessionHandle session, string nam
             }
         }
 
-        public void CreateView<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            UsingImplicitSession(session => CreateView(session, viewName, viewOn, pipeline, options, cancellationToken), cancellationToken);
-        }
-
-        public void CreateView<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(viewName, nameof(viewName));
-            Ensure.IsNotNull(viewOn, nameof(viewOn));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new CreateViewOptions<TDocument>();
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateCreateViewOperation(viewName, viewOn, pipeline, options, translationOptions);
-            ExecuteWriteOperation(session, operation, cancellationToken);
-        }
-
-        public Task CreateViewAsync<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => CreateViewAsync(session, viewName, viewOn, pipeline, options, cancellationToken), cancellationToken);
-        }
-
-        public Task CreateViewAsync<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(viewName, nameof(viewName));
-            Ensure.IsNotNull(viewOn, nameof(viewOn));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            options = options ?? new CreateViewOptions<TDocument>();
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateCreateViewOperation(viewName, viewOn, pipeline, options, translationOptions);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
+        public void CreateView<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateCreateViewOperation(viewName, viewOn, pipeline, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public void CreateView<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateCreateViewOperation(viewName, viewOn, pipeline, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public Task CreateViewAsync<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateCreateViewOperation(viewName, viewOn, pipeline, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
+
+        public Task CreateViewAsync<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateCreateViewOperation(viewName, viewOn, pipeline, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public void DropCollection(string name, CancellationToken cancellationToken)
         {
@@ -293,7 +270,8 @@ public void DropCollection(string name, CancellationToken cancellationToken)
 
         public void DropCollection(string name, DropCollectionOptions options, CancellationToken cancellationToken = default)
         {
-            UsingImplicitSession(session => DropCollection(session, name, options, cancellationToken), cancellationToken);
+            using var session = OperationExecutor.StartImplicitSession(cancellationToken);
+            DropCollection(session, name, options, cancellationToken);
         }
 
         public void DropCollection(IClientSessionHandle session, string name, CancellationToken cancellationToken)
@@ -304,9 +282,8 @@ public void DropCollection(IClientSessionHandle session, string name, Cancellati
         public void DropCollection(IClientSessionHandle session, string name, DropCollectionOptions options, CancellationToken cancellationToken)
         {
             Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNullOrEmpty(name, nameof(name));
             var operation = CreateDropCollectionOperation(name, options, session, cancellationToken);
-            ExecuteWriteOperation(session, operation, cancellationToken);
+            OperationExecutor.ExecuteWriteOperation(operation, _writeOperationOptions, session, cancellationToken);
         }
 
         public Task DropCollectionAsync(string name, CancellationToken cancellationToken)
@@ -314,9 +291,10 @@ public Task DropCollectionAsync(string name, CancellationToken cancellationToken
             return DropCollectionAsync(name, options: null, cancellationToken);
         }
 
-        public Task DropCollectionAsync(string name, DropCollectionOptions options, CancellationToken cancellationToken)
+        public async Task DropCollectionAsync(string name, DropCollectionOptions options, CancellationToken cancellationToken)
         {
-            return UsingImplicitSessionAsync(session => DropCollectionAsync(session, name, options, cancellationToken), cancellationToken);
+            using var session = await OperationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+            await DropCollectionAsync(session, name, options, cancellationToken).ConfigureAwait(false);
         }
 
         public Task DropCollectionAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken)
@@ -327,9 +305,9 @@ public Task DropCollectionAsync(IClientSessionHandle session, string name, Cance
         public async Task DropCollectionAsync(IClientSessionHandle session, string name, DropCollectionOptions options, CancellationToken cancellationToken)
         {
             Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNullOrEmpty(name, nameof(name));
+
             var operation = await CreateDropCollectionOperationAsync(name, options, session, cancellationToken).ConfigureAwait(false);
-            await ExecuteWriteOperationAsync(session, operation, cancellationToken).ConfigureAwait(false);
+            await OperationExecutor.ExecuteWriteOperationAsync(operation, _writeOperationOptions, session, cancellationToken).ConfigureAwait(false);
         }
 
         public IMongoCollection<TDocument> GetCollection<TDocument>(string name, MongoCollectionSettings settings)
@@ -345,167 +323,160 @@ public IMongoCollection<TDocument> GetCollection<TDocument>(string name, MongoCo
             return new MongoCollectionImpl<TDocument>(this, new CollectionNamespace(_databaseNamespace, name), settings, _cluster, _operationExecutor);
         }
 
-        public IAsyncCursor<string> ListCollectionNames(ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public IAsyncCursor<string> ListCollectionNames(ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSession(session => ListCollectionNames(session, options, cancellationToken), cancellationToken);
+            var cursor = OperationExecutor.ExecuteReadOperation(CreateListCollectionNamesOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                null, cancellationToken);
+            return new BatchTransformingAsyncCursor<BsonDocument, string>(cursor, ExtractCollectionNames);
         }
 
-        public IAsyncCursor<string> ListCollectionNames(IClientSessionHandle session, ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public IAsyncCursor<string> ListCollectionNames(IClientSessionHandle session, ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default)
         {
-            Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
-            var operation = CreateListCollectionNamesOperation(options, renderArgs);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, ReadPreference.Primary);
-            var cursor = ExecuteReadOperation(session, operation, effectiveReadPreference, cancellationToken);
+            var cursor = OperationExecutor.ExecuteReadOperation(
+                CreateListCollectionNamesOperation(options),
+                    _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                    Ensure.IsNotNull(session, nameof(session)),
+                    cancellationToken);
             return new BatchTransformingAsyncCursor<BsonDocument, string>(cursor, ExtractCollectionNames);
         }
 
-        public Task<IAsyncCursor<string>> ListCollectionNamesAsync(ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<IAsyncCursor<string>> ListCollectionNamesAsync(ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default)
         {
-            return UsingImplicitSessionAsync(session => ListCollectionNamesAsync(session, options, cancellationToken), cancellationToken);
+            var cursor = await OperationExecutor.ExecuteReadOperationAsync(
+                CreateListCollectionNamesOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                cancellationToken: cancellationToken).ConfigureAwait(false);
+            return new BatchTransformingAsyncCursor<BsonDocument, string>(cursor, ExtractCollectionNames);
         }
 
-        public async Task<IAsyncCursor<string>> ListCollectionNamesAsync(IClientSessionHandle session, ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<IAsyncCursor<string>> ListCollectionNamesAsync(IClientSessionHandle session, ListCollectionNamesOptions options = null, CancellationToken cancellationToken = default)
         {
-            Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
-            var operation = CreateListCollectionNamesOperation(options, renderArgs);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, ReadPreference.Primary);
-            var cursor = await ExecuteReadOperationAsync(session, operation, effectiveReadPreference, cancellationToken).ConfigureAwait(false);
+            var cursor = await OperationExecutor.ExecuteReadOperationAsync(
+                CreateListCollectionNamesOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken).ConfigureAwait(false);
             return new BatchTransformingAsyncCursor<BsonDocument, string>(cursor, ExtractCollectionNames);
         }
 
         public IAsyncCursor<BsonDocument> ListCollections(ListCollectionsOptions options, CancellationToken cancellationToken)
-        {
-            return UsingImplicitSession(session => ListCollections(session, options, cancellationToken), cancellationToken);
-        }
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListCollectionsOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                cancellationToken: cancellationToken);
 
         public IAsyncCursor<BsonDocument> ListCollections(IClientSessionHandle session, ListCollectionsOptions options, CancellationToken cancellationToken)
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
-            var operation = CreateListCollectionsOperation(options, renderArgs);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, ReadPreference.Primary);
-            return ExecuteReadOperation(session, operation, effectiveReadPreference, cancellationToken);
-        }
+            => OperationExecutor.ExecuteReadOperation(
+                CreateListCollectionsOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(ListCollectionsOptions options, CancellationToken cancellationToken)
-        {
-            return UsingImplicitSessionAsync(session => ListCollectionsAsync(session, options, cancellationToken), cancellationToken);
-        }
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListCollectionsOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                cancellationToken: cancellationToken);
 
         public Task<IAsyncCursor<BsonDocument>> ListCollectionsAsync(IClientSessionHandle session, ListCollectionsOptions options, CancellationToken cancellationToken)
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
-            var operation = CreateListCollectionsOperation(options, renderArgs);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, ReadPreference.Primary);
-            return ExecuteReadOperationAsync(session, operation, effectiveReadPreference, cancellationToken);
-        }
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateListCollectionsOperation(options),
+                _readOperationOptions with { DefaultReadPreference = ReadPreference.Primary },
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public void RenameCollection(string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
-        {
-            UsingImplicitSession(session => RenameCollection(session, oldName, newName, options, cancellationToken), cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateRenameCollectionOperation(oldName, newName, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
         public void RenameCollection(IClientSessionHandle session, string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNullOrEmpty(oldName, nameof(oldName));
-            Ensure.IsNotNullOrEmpty(newName, nameof(newName));
-            options = options ?? new RenameCollectionOptions();
-
-            var operation = CreateRenameCollectionOperation(oldName, newName, options);
-            ExecuteWriteOperation(session, operation, cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperation(
+                CreateRenameCollectionOperation(oldName, newName, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public Task RenameCollectionAsync(string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
-        {
-            return UsingImplicitSessionAsync(session => RenameCollectionAsync(session, oldName, newName, options, cancellationToken), cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateRenameCollectionOperation(oldName, newName, options),
+                _writeOperationOptions,
+                cancellationToken: cancellationToken);
 
         public Task RenameCollectionAsync(IClientSessionHandle session, string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNullOrEmpty(oldName, nameof(oldName));
-            Ensure.IsNotNullOrEmpty(newName, nameof(newName));
-            options = options ?? new RenameCollectionOptions();
-
-            var operation = CreateRenameCollectionOperation(oldName, newName, options);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
-
-        public TResult RunCommand<TResult>(Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => RunCommand(session, command, readPreference, cancellationToken), cancellationToken);
-        }
-
-        public TResult RunCommand<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(command, nameof(command));
-
-            var operation = CreateRunCommandOperation(command);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, readPreference, ReadPreference.Primary);
-            return ExecuteReadOperation(session, operation, effectiveReadPreference, cancellationToken);
-        }
-
-        public Task<TResult> RunCommandAsync<TResult>(Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => RunCommandAsync(session, command, readPreference, cancellationToken), cancellationToken);
-        }
-
-        public Task<TResult> RunCommandAsync<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(command, nameof(command));
-
-            var operation = CreateRunCommandOperation(command);
-            var effectiveReadPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, readPreference, ReadPreference.Primary);
-            return ExecuteReadOperationAsync(session, operation, effectiveReadPreference, cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperationAsync(
+                CreateRenameCollectionOperation(oldName, newName, options),
+                _writeOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public TResult RunCommand<TResult>(Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateRunCommandOperation(command),
+                _readOperationOptions with { ExplicitReadPreference = readPreference, DefaultReadPreference = ReadPreference.Primary},
+                cancellationToken: cancellationToken);
+
+        public TResult RunCommand<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateRunCommandOperation(command),
+                _readOperationOptions with { ExplicitReadPreference = readPreference, DefaultReadPreference = ReadPreference.Primary},
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
+
+        public Task<TResult> RunCommandAsync<TResult>(Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateRunCommandOperation(command),
+                _readOperationOptions with { ExplicitReadPreference = readPreference, DefaultReadPreference = ReadPreference.Primary},
+                cancellationToken: cancellationToken);
+
+        public Task<TResult> RunCommandAsync<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateRunCommandOperation(command),
+                _readOperationOptions with { ExplicitReadPreference = readPreference, DefaultReadPreference = ReadPreference.Primary},
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public IChangeStreamCursor<TResult> Watch<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSession(session => Watch(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         public IChangeStreamCursor<TResult> Watch<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperation(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperation(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return UsingImplicitSessionAsync(session => WatchAsync(session, pipeline, options, cancellationToken), cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                cancellationToken: cancellationToken);
 
         public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(
             IClientSessionHandle session,
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
             ChangeStreamOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Ensure.IsNotNull(session, nameof(session));
-            Ensure.IsNotNull(pipeline, nameof(pipeline));
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateChangeStreamOperation(pipeline, options, translationOptions);
-            return ExecuteReadOperationAsync(session, operation, cancellationToken);
-        }
+            CancellationToken cancellationToken = default)
+            => OperationExecutor.ExecuteReadOperationAsync(
+                CreateChangeStreamOperation(pipeline, options),
+                _readOperationOptions,
+                Ensure.IsNotNull(session, nameof(session)),
+                cancellationToken);
 
         public IMongoDatabase WithReadConcern(ReadConcern readConcern)
         {
@@ -532,6 +503,7 @@ public IMongoDatabase WithWriteConcern(WriteConcern writeConcern)
         }
 
         // private methods
+
         private AggregateOperation<TResult> CreateAggregateOperation<TResult>(RenderedPipelineDefinition<TResult> renderedPipeline, AggregateOptions options)
         {
             var messageEncoderSettings = GetMessageEncoderSettings();
@@ -557,59 +529,16 @@ private AggregateOperation<TResult> CreateAggregateOperation<TResult>(RenderedPi
             };
         }
 
-        private FindOperation<TResult> CreateAggregateToCollectionFindOperation<TResult>(BsonDocument outStage, IBsonSerializer<TResult> resultSerializer, AggregateOptions options)
+        private IAsyncCursor<TResult> CreateAggregateToCollectionResultCursor<TResult>(IClientSessionHandle session, RenderedPipelineDefinition<TResult> pipeline, AggregateOptions options)
         {
-            CollectionNamespace outputCollectionNamespace;
-            var stageName = outStage.GetElement(0).Name;
-            switch (stageName)
-            {
-                case "$out":
-                    {
-                        var outValue = outStage[0];
-                        DatabaseNamespace outputDatabaseNamespace;
-                        string outputCollectionName;
-                        if (outValue.IsString)
-                        {
-                            outputDatabaseNamespace = _databaseNamespace;
-                            outputCollectionName = outValue.AsString;
-                        }
-                        else
-                        {
-                            outputDatabaseNamespace = new DatabaseNamespace(outValue["db"].AsString);
-                            outputCollectionName = outValue["coll"].AsString;
-                        }
-                        outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
-                    }
-                    break;
-                case "$merge":
-                    {
-                        var mergeArguments = outStage[0].AsBsonDocument;
-                        DatabaseNamespace outputDatabaseNamespace;
-                        string outputCollectionName;
-                        var into = mergeArguments["into"];
-                        if (into.IsString)
-                        {
-                            outputDatabaseNamespace = _databaseNamespace;
-                            outputCollectionName = into.AsString;
-                        }
-                        else
-                        {
-                            outputDatabaseNamespace = new DatabaseNamespace(into["db"].AsString);
-                            outputCollectionName = into["coll"].AsString;
-                        }
-                        outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName);
-                    }
-                    break;
-                default:
-                    throw new ArgumentException($"Unexpected stage name: {stageName}.");
-            }
+            var outputCollectionNamespace = AggregateHelper.GetOutCollection(pipeline.Documents.Last(), _databaseNamespace);
 
             // because auto encryption is not supported for non-collection commands.
             // So, an error will be thrown in the previous CreateAggregateToCollectionOperation step.
             // However, since we've added encryption configuration for CreateAggregateToCollectionOperation operation,
             // it's not superfluous to also add it here
             var messageEncoderSettings = GetMessageEncoderSettings();
-            return new FindOperation<TResult>(outputCollectionNamespace, resultSerializer, messageEncoderSettings)
+            var findOperation = new FindOperation<TResult>(outputCollectionNamespace, pipeline.OutputSerializer, messageEncoderSettings)
             {
                 BatchSize = options.BatchSize,
                 Collation = options.Collation,
@@ -617,6 +546,16 @@ private FindOperation<TResult> CreateAggregateToCollectionFindOperation<TResult>
                 ReadConcern = _settings.ReadConcern,
                 RetryRequested = _client.Settings.RetryReads
             };
+
+            // we want to delay execution of the find because the user may
+            // not want to iterate the results at all...
+            var forkedSession = session.Fork();
+            var readOperationOptions = _readOperationOptions with { ExplicitReadPreference = ReadPreference.Primary };
+            var deferredCursor = new DeferredAsyncCursor<TResult>(
+                () => forkedSession.Dispose(),
+                ct => OperationExecutor.ExecuteReadOperation(findOperation, readOperationOptions, forkedSession, ct),
+                ct => OperationExecutor.ExecuteReadOperationAsync(findOperation, readOperationOptions, forkedSession, ct));
+            return deferredCursor;
         }
 
         private AggregateToCollectionOperation CreateAggregateToCollectionOperation<TResult>(RenderedPipelineDefinition<TResult> renderedPipeline, AggregateOptions options)
@@ -641,25 +580,19 @@ private AggregateToCollectionOperation CreateAggregateToCollectionOperation<TRes
         }
 
         private void CreateCollectionHelper<TDocument>(IClientSessionHandle session, string name, CreateCollectionOptions<TDocument> options, CancellationToken cancellationToken)
-        {
-            options = options ?? new CreateCollectionOptions<TDocument>();
-
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateCreateCollectionOperation(name, options, translationOptions);
-            ExecuteWriteOperation(session, operation, cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperation(CreateCreateCollectionOperation(name, options),
+                _writeOperationOptions,
+                session, cancellationToken);
 
         private Task CreateCollectionHelperAsync<TDocument>(IClientSessionHandle session, string name, CreateCollectionOptions<TDocument> options, CancellationToken cancellationToken)
-        {
-            options = options ?? new CreateCollectionOptions<TDocument>();
-
-            var translationOptions = _client.Settings.TranslationOptions;
-            var operation = CreateCreateCollectionOperation(name, options, translationOptions);
-            return ExecuteWriteOperationAsync(session, operation, cancellationToken);
-        }
+            => OperationExecutor.ExecuteWriteOperationAsync(CreateCreateCollectionOperation(name, options),
+                _writeOperationOptions,
+                session, cancellationToken);
 
-        private IWriteOperation<BsonDocument> CreateCreateCollectionOperation<TDocument>(string name, CreateCollectionOptions<TDocument> options, ExpressionTranslationOptions translationOptions)
+        private IWriteOperation<BsonDocument> CreateCreateCollectionOperation<TDocument>(string name, CreateCollectionOptions<TDocument> options)
         {
+            options ??= new CreateCollectionOptions<TDocument>();
+            var translationOptions = _client.Settings.TranslationOptions;
             var serializerRegistry = options.SerializerRegistry ?? BsonSerializer.SerializerRegistry;
             var documentSerializer = options.DocumentSerializer ?? serializerRegistry.GetSerializer<TDocument>();
 
@@ -700,9 +633,14 @@ private CreateViewOperation CreateCreateViewOperation<TDocument, TResult>(
             string viewName,
             string viewOn,
             PipelineDefinition<TDocument, TResult> pipeline,
-            CreateViewOptions<TDocument> options,
-            ExpressionTranslationOptions translationOptions)
+            CreateViewOptions<TDocument> options)
         {
+            Ensure.IsNotNull(viewName, nameof(viewName));
+            Ensure.IsNotNull(viewOn, nameof(viewOn));
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            options ??= new CreateViewOptions<TDocument>();
+
+            var translationOptions = _client.Settings.TranslationOptions;
             var serializerRegistry = options.SerializerRegistry ?? BsonSerializer.SerializerRegistry;
             var documentSerializer = options.DocumentSerializer ?? serializerRegistry.GetSerializer<TDocument>();
             var pipelineDocuments = pipeline.Render(new (documentSerializer, serializerRegistry, translationOptions: translationOptions)).Documents;
@@ -715,9 +653,9 @@ private CreateViewOperation CreateCreateViewOperation<TDocument, TResult>(
 
         private IWriteOperation<BsonDocument> CreateDropCollectionOperation(string name, DropCollectionOptions options, IClientSessionHandle session, CancellationToken cancellationToken)
         {
+            Ensure.IsNotNullOrEmpty(name, nameof(name));
             var collectionNamespace = new CollectionNamespace(_databaseNamespace, name);
-
-            options = options ?? new DropCollectionOptions();
+            options ??= new DropCollectionOptions();
 
             var encryptedFieldsMap = _client.Settings?.AutoEncryptionOptions?.EncryptedFieldsMap;
             if (!EncryptedCollectionHelper.TryGetEffectiveEncryptedFields(collectionNamespace, options.EncryptedFields, encryptedFieldsMap, out var effectiveEncryptedFields))
@@ -747,6 +685,7 @@ private IWriteOperation<BsonDocument> CreateDropCollectionOperation(string name,
 
         private async Task<IWriteOperation<BsonDocument>> CreateDropCollectionOperationAsync(string name, DropCollectionOptions options, IClientSessionHandle session, CancellationToken cancellationToken)
         {
+            Ensure.IsNotNullOrEmpty(name, nameof(name));
             var collectionNamespace = new CollectionNamespace(_databaseNamespace, name);
 
             options = options ?? new DropCollectionOptions();
@@ -778,9 +717,10 @@ private async Task<IWriteOperation<BsonDocument>> CreateDropCollectionOperationA
                 });
         }
 
-        private ListCollectionsOperation CreateListCollectionNamesOperation(ListCollectionNamesOptions options, RenderArgs<BsonDocument> renderArgs)
+        private ListCollectionsOperation CreateListCollectionNamesOperation(ListCollectionNamesOptions options)
         {
             var messageEncoderSettings = GetMessageEncoderSettings();
+            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
             return new ListCollectionsOperation(_databaseNamespace, messageEncoderSettings)
             {
                 AuthorizedCollections = options?.AuthorizedCollections,
@@ -791,8 +731,9 @@ private ListCollectionsOperation CreateListCollectionNamesOperation(ListCollecti
             };
         }
 
-        private ListCollectionsOperation CreateListCollectionsOperation(ListCollectionsOptions options, RenderArgs<BsonDocument> renderArgs)
+        private ListCollectionsOperation CreateListCollectionsOperation(ListCollectionsOptions options)
         {
+            var renderArgs = GetRenderArgs(BsonDocumentSerializer.Instance);
             var messageEncoderSettings = GetMessageEncoderSettings();
             return new ListCollectionsOperation(_databaseNamespace, messageEncoderSettings)
             {
@@ -803,23 +744,12 @@ private ListCollectionsOperation CreateListCollectionsOperation(ListCollectionsO
             };
         }
 
-        private IReadBinding CreateReadBinding(IClientSessionHandle session, ReadPreference readPreference)
-        {
-            if (session.IsInTransaction && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
-            {
-                throw new InvalidOperationException("Read preference in a transaction must be primary.");
-            }
-
-            return ChannelPinningHelper.CreateReadBinding(_cluster, session.WrappedCoreSession.Fork(), readPreference);
-        }
-
-        private IWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session)
-        {
-            return ChannelPinningHelper.CreateReadWriteBinding(_cluster, session.WrappedCoreSession.Fork());
-        }
-
         private RenameCollectionOperation CreateRenameCollectionOperation(string oldName, string newName, RenameCollectionOptions options)
         {
+            Ensure.IsNotNullOrEmpty(oldName, nameof(oldName));
+            Ensure.IsNotNullOrEmpty(newName, nameof(newName));
+            options ??= new RenameCollectionOptions();
+
             var messageEncoderSettings = GetMessageEncoderSettings();
             return new RenameCollectionOperation(
                 new CollectionNamespace(_databaseNamespace, oldName),
@@ -833,6 +763,7 @@ private RenameCollectionOperation CreateRenameCollectionOperation(string oldName
 
         private ReadCommandOperation<TResult> CreateRunCommandOperation<TResult>(Command<TResult> command)
         {
+            Ensure.IsNotNull(command, nameof(command));
             var renderedCommand = command.Render(_settings.SerializerRegistry);
             var messageEncoderSettings = GetMessageEncoderSettings();
             return new ReadCommandOperation<TResult>(_databaseNamespace, renderedCommand.Document, renderedCommand.ResultSerializer, messageEncoderSettings)
@@ -843,9 +774,11 @@ private ReadCommandOperation<TResult> CreateRunCommandOperation<TResult>(Command
 
         private ChangeStreamOperation<TResult> CreateChangeStreamOperation<TResult>(
             PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline,
-            ChangeStreamOptions options,
-            ExpressionTranslationOptions translationOptions)
+            ChangeStreamOptions options)
         {
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            var translationOptions = _client.Settings.TranslationOptions;
+
             return ChangeStreamHelper.CreateChangeStreamOperation(
                 this,
                 pipeline,
@@ -861,50 +794,6 @@ private IEnumerable<string> ExtractCollectionNames(IEnumerable<BsonDocument> col
             return collections.Select(collection => collection["name"].AsString);
         }
 
-        private T ExecuteReadOperation<T>(IClientSessionHandle session, IReadOperation<T> operation, CancellationToken cancellationToken)
-        {
-            var readPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, _settings.ReadPreference);
-            return ExecuteReadOperation(session, operation, readPreference, cancellationToken);
-        }
-
-        private T ExecuteReadOperation<T>(IClientSessionHandle session, IReadOperation<T> operation, ReadPreference readPreference, CancellationToken cancellationToken)
-        {
-            using (var binding = CreateReadBinding(session, readPreference))
-            {
-                return _operationExecutor.ExecuteReadOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private Task<T> ExecuteReadOperationAsync<T>(IClientSessionHandle session, IReadOperation<T> operation, CancellationToken cancellationToken)
-        {
-            var readPreference = ReadPreferenceResolver.GetEffectiveReadPreference(session, null, _settings.ReadPreference);
-            return ExecuteReadOperationAsync(session, operation, readPreference, cancellationToken);
-        }
-
-        private async Task<T> ExecuteReadOperationAsync<T>(IClientSessionHandle session, IReadOperation<T> operation, ReadPreference readPreference, CancellationToken cancellationToken)
-        {
-            using (var binding = CreateReadBinding(session, readPreference))
-            {
-                return await _operationExecutor.ExecuteReadOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        private T ExecuteWriteOperation<T>(IClientSessionHandle session, IWriteOperation<T> operation, CancellationToken cancellationToken)
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return _operationExecutor.ExecuteWriteOperation(binding, operation, cancellationToken);
-            }
-        }
-
-        private async Task<T> ExecuteWriteOperationAsync<T>(IClientSessionHandle session, IWriteOperation<T> operation, CancellationToken cancellationToken)
-        {
-            using (var binding = CreateReadWriteBinding(session))
-            {
-                return await _operationExecutor.ExecuteWriteOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
         private MessageEncoderSettings GetMessageEncoderSettings()
         {
             var messageEncoderSettings = new MessageEncoderSettings
@@ -932,37 +821,5 @@ private RenderArgs<TDocument> GetRenderArgs<TDocument>(IBsonSerializer<TDocument
             translationOptions = translationOptions.AddMissingOptionsFrom(_client.Settings.TranslationOptions);
             return new RenderArgs<TDocument>(documentSerializer, _settings.SerializerRegistry, translationOptions: translationOptions);
         }
-
-        private void UsingImplicitSession(Action<IClientSessionHandle> func, CancellationToken cancellationToken)
-        {
-            using (var session = _operationExecutor.StartImplicitSession(cancellationToken))
-            {
-                func(session);
-            }
-        }
-
-        private TResult UsingImplicitSession<TResult>(Func<IClientSessionHandle, TResult> func, CancellationToken cancellationToken)
-        {
-            using (var session = _operationExecutor.StartImplicitSession(cancellationToken))
-            {
-                return func(session);
-            }
-        }
-
-        private async Task UsingImplicitSessionAsync(Func<IClientSessionHandle, Task> funcAsync, CancellationToken cancellationToken)
-        {
-            using (var session = await _operationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
-            {
-                await funcAsync(session).ConfigureAwait(false);
-            }
-        }
-
-        private async Task<TResult> UsingImplicitSessionAsync<TResult>(Func<IClientSessionHandle, Task<TResult>> funcAsync, CancellationToken cancellationToken)
-        {
-            using (var session = await _operationExecutor.StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return await funcAsync(session).ConfigureAwait(false);
-            }
-        }
     }
 }
diff --git a/src/MongoDB.Driver/OperationExecutor.cs b/src/MongoDB.Driver/OperationExecutor.cs
index cc521cdf762..898963fc73f 100644
--- a/src/MongoDB.Driver/OperationExecutor.cs
+++ b/src/MongoDB.Driver/OperationExecutor.cs
@@ -13,8 +13,10 @@
 * limitations under the License.
 */
 
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using MongoDB.Driver.Core;
 using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Operations;
 
@@ -22,41 +24,135 @@ namespace MongoDB.Driver
 {
     internal sealed class OperationExecutor : IOperationExecutor
     {
-        private readonly MongoClient _client;
+        private readonly IMongoClient _client;
 
-        public OperationExecutor(MongoClient client)
+        public OperationExecutor(IMongoClient client)
         {
             _client = client;
         }
 
-        public TResult ExecuteReadOperation<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken)
+        public TResult ExecuteReadOperation<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions options,
+            IClientSessionHandle session,
+            CancellationToken cancellationToken)
         {
-            return operation.Execute(binding, cancellationToken);
+            bool isOwnSession = session == null;
+            session ??= StartImplicitSession(cancellationToken);
+
+            try
+            {
+                var readPreference = options.GetEffectiveReadPreference(session);
+                using var binding = CreateReadBinding(session, readPreference);
+                return operation.Execute(binding, cancellationToken);
+            }
+            finally
+            {
+                if (isOwnSession)
+                {
+                    session.Dispose();
+                }
+            }
         }
 
-        public async Task<TResult> ExecuteReadOperationAsync<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken)
+        public async Task<TResult> ExecuteReadOperationAsync<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions options,
+            IClientSessionHandle session,
+            CancellationToken cancellationToken)
         {
-            return await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
+            bool isOwnSession = session == null;
+            session ??= await StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                var readPreference = options.GetEffectiveReadPreference(session);
+                using var binding = CreateReadBinding(session, readPreference);
+                return await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                if (isOwnSession)
+                {
+                    session.Dispose();
+                }
+            }
         }
 
-        public TResult ExecuteWriteOperation<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken)
+        public TResult ExecuteWriteOperation<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions options,
+            IClientSessionHandle session,
+            CancellationToken cancellationToken)
         {
-            return operation.Execute(binding, cancellationToken);
+            bool isOwnSession = session == null;
+            session ??= StartImplicitSession(cancellationToken);
+
+            try
+            {
+                using var binding = CreateReadWriteBinding(session);
+                return operation.Execute(binding, cancellationToken);
+            }
+            finally
+            {
+                if (isOwnSession)
+                {
+                    session.Dispose();
+                }
+            }
         }
 
-        public async Task<TResult> ExecuteWriteOperationAsync<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken)
+        public async Task<TResult> ExecuteWriteOperationAsync<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions options,
+            IClientSessionHandle session,
+            CancellationToken cancellationToken)
         {
-            return await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
+            bool isOwnSession = session == null;
+            session ??= await StartImplicitSessionAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                using var binding = CreateReadWriteBinding(session);
+                return await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                if (isOwnSession)
+                {
+                    session.Dispose();
+                }
+            }
         }
 
         public IClientSessionHandle StartImplicitSession(CancellationToken cancellationToken)
+            => StartImplicitSession();
+
+        public Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken cancellationToken)
+            => Task.FromResult(StartImplicitSession());
+
+        private IReadBindingHandle CreateReadBinding(IClientSessionHandle session, ReadPreference readPreference)
         {
-            return _client.StartImplicitSession(cancellationToken);
+            if (session.IsInTransaction && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
+            {
+                throw new InvalidOperationException("Read preference in a transaction must be primary.");
+            }
+
+            // TODO: CreateReadBinding from MongoClient did not used ChannelPinningHelper, double-check if it's OK to start using it
+            return ChannelPinningHelper.CreateReadBinding(_client.GetClusterInternal(), session.WrappedCoreSession.Fork(), readPreference);
         }
 
-        public Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken cancellationToken)
+        private IReadWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session)
+        {
+            // TODO: CreateReadWriteBinding from MongoClient did not used ChannelPinningHelper, double-check if it's OK to start using it
+            return ChannelPinningHelper.CreateReadWriteBinding(_client.GetClusterInternal(), session.WrappedCoreSession.Fork());
+        }
+
+        private IClientSessionHandle StartImplicitSession()
         {
-            return _client.StartImplicitSessionAsync(cancellationToken);
+            var options = new ClientSessionOptions { CausalConsistency = false, Snapshot = false };
+            ICoreSessionHandle coreSession = _client.GetClusterInternal().StartSession(options.ToCore(isImplicit: true));
+            return new ClientSessionHandle(_client, options, coreSession);
         }
     }
 }
diff --git a/src/MongoDB.Driver/ReadOperationOptions.cs b/src/MongoDB.Driver/ReadOperationOptions.cs
new file mode 100644
index 00000000000..ebb7fb9fe37
--- /dev/null
+++ b/src/MongoDB.Driver/ReadOperationOptions.cs
@@ -0,0 +1,42 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Driver
+{
+    internal record class ReadOperationOptions(ReadPreference ExplicitReadPreference = null, ReadPreference DefaultReadPreference = null);
+
+    internal static class ReadOperationOptionsExtensions
+    {
+        public static ReadPreference GetEffectiveReadPreference(this ReadOperationOptions options, IClientSessionHandle session)
+        {
+            if (options.ExplicitReadPreference != null)
+            {
+                return options.ExplicitReadPreference;
+            }
+
+            if (session.IsInTransaction)
+            {
+                var transactionReadPreference = session.WrappedCoreSession.CurrentTransaction.TransactionOptions.ReadPreference;
+                if (transactionReadPreference != null)
+                {
+                    return transactionReadPreference;
+                }
+            }
+
+            return options.DefaultReadPreference ?? ReadPreference.Primary;
+        }
+    }
+}
+
diff --git a/src/MongoDB.Driver/ReadPreferenceResolver.cs b/src/MongoDB.Driver/ReadPreferenceResolver.cs
deleted file mode 100644
index 6fbc9ed27f8..00000000000
--- a/src/MongoDB.Driver/ReadPreferenceResolver.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright 2018-present MongoDB Inc.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-namespace MongoDB.Driver
-{
-    internal static class ReadPreferenceResolver
-    {
-        public static ReadPreference GetEffectiveReadPreference(
-            IClientSessionHandle session,
-            ReadPreference explicitReadPreference,
-            ReadPreference defaultReadPreference)
-        {
-            if (explicitReadPreference != null)
-            {
-                return explicitReadPreference;
-            }
-
-            if (session.IsInTransaction)
-            {
-                var transactionReadPreference = session.WrappedCoreSession.CurrentTransaction.TransactionOptions.ReadPreference;
-                if (transactionReadPreference != null)
-                {
-                    return transactionReadPreference;
-                }
-            }
-
-            return defaultReadPreference ?? ReadPreference.Primary;
-        }
-    }
-}
diff --git a/src/MongoDB.Driver/WriteOperationOptions.cs b/src/MongoDB.Driver/WriteOperationOptions.cs
new file mode 100644
index 00000000000..29c8d1118df
--- /dev/null
+++ b/src/MongoDB.Driver/WriteOperationOptions.cs
@@ -0,0 +1,20 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Driver
+{
+    internal record class WriteOperationOptions();
+}
+
diff --git a/tests/MongoDB.Driver.Tests/MockOperationExecutor.cs b/tests/MongoDB.Driver.Tests/MockOperationExecutor.cs
index 6c9c18b6410..ad4df2bc3e8 100644
--- a/tests/MongoDB.Driver.Tests/MockOperationExecutor.cs
+++ b/tests/MongoDB.Driver.Tests/MockOperationExecutor.cs
@@ -58,15 +58,19 @@ public void EnqueueException<TResult>(Exception exception)
             _results.Enqueue(exception);
         }
 
-        public TResult ExecuteReadOperation<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken)
+        public TResult ExecuteReadOperation<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions readOperationOptions,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default)
         {
             _calls.Enqueue(new ReadCall<TResult>
             {
-                Binding = binding,
                 Operation = operation,
                 CancellationToken = cancellationToken,
-                SessionId = binding.Session.Id,
-                UsedImplicitSession = binding.Session.IsImplicit
+                Options = readOperationOptions,
+                SessionId = session?.WrappedCoreSession.Id,
+                UsedImplicitSession = session == null || session.IsImplicit
             });
 
             if (_results.Count > 0)
@@ -85,11 +89,15 @@ public TResult ExecuteReadOperation<TResult>(IReadBinding binding, IReadOperatio
             return default(TResult);
         }
 
-        public Task<TResult> ExecuteReadOperationAsync<TResult>(IReadBinding binding, IReadOperation<TResult> operation, CancellationToken cancellationToken)
+        public Task<TResult> ExecuteReadOperationAsync<TResult>(
+            IReadOperation<TResult> operation,
+            ReadOperationOptions readOperationOptions,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default)
         {
             try
             {
-                var result = ExecuteReadOperation<TResult>(binding, operation, cancellationToken);
+                var result = ExecuteReadOperation(operation, readOperationOptions, session, cancellationToken);
                 return Task.FromResult(result);
             }
             catch (Exception ex)
@@ -100,15 +108,19 @@ public Task<TResult> ExecuteReadOperationAsync<TResult>(IReadBinding binding, IR
             }
         }
 
-        public TResult ExecuteWriteOperation<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken)
+        public TResult ExecuteWriteOperation<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions writeOperationOptions,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default)
         {
             _calls.Enqueue(new WriteCall<TResult>
             {
-                Binding = binding,
                 Operation = operation,
                 CancellationToken = cancellationToken,
-                SessionId = binding.Session.Id,
-                UsedImplicitSession = binding.Session.IsImplicit
+                Options = writeOperationOptions,
+                SessionId = session?.WrappedCoreSession.Id,
+                UsedImplicitSession = session == null || session.IsImplicit
             });
 
             if (_results.Count > 0)
@@ -127,11 +139,15 @@ public TResult ExecuteWriteOperation<TResult>(IWriteBinding binding, IWriteOpera
             return default(TResult);
         }
 
-        public Task<TResult> ExecuteWriteOperationAsync<TResult>(IWriteBinding binding, IWriteOperation<TResult> operation, CancellationToken cancellationToken)
+        public Task<TResult> ExecuteWriteOperationAsync<TResult>(
+            IWriteOperation<TResult> operation,
+            WriteOperationOptions writeOperationOptions,
+            IClientSessionHandle session = null,
+            CancellationToken cancellationToken = default)
         {
             try
             {
-                var result = ExecuteWriteOperation<TResult>(binding, operation, cancellationToken);
+                var result = ExecuteWriteOperation(operation, writeOperationOptions, session, cancellationToken);
                 return Task.FromResult(result);
             }
             catch (Exception ex)
@@ -193,18 +209,18 @@ public Task<IClientSessionHandle> StartImplicitSessionAsync(CancellationToken ca
 
         public class ReadCall<TResult>
         {
-            public IReadBinding Binding { get; set; }
             public IReadOperation<TResult> Operation { get; set; }
             public CancellationToken CancellationToken { get; set; }
+            public ReadOperationOptions Options { get; set; }
             public BsonDocument SessionId { get; set; }
             public bool UsedImplicitSession { get; set; }
         }
 
         public class WriteCall<TResult>
         {
-            public IWriteBinding Binding { get; set; }
             public IWriteOperation<TResult> Operation { get; set; }
             public CancellationToken CancellationToken { get; set; }
+            public WriteOperationOptions Options { get; set; }
             public BsonDocument SessionId { get; set; }
             public bool UsedImplicitSession { get; set; }
         }
diff --git a/tests/MongoDB.Driver.Tests/MongoClientTests.cs b/tests/MongoDB.Driver.Tests/MongoClientTests.cs
index d1f06516a2f..6fbb42a8127 100644
--- a/tests/MongoDB.Driver.Tests/MongoClientTests.cs
+++ b/tests/MongoDB.Driver.Tests/MongoClientTests.cs
@@ -118,9 +118,6 @@ public void Disposed_client_should_throw_on_member_access()
 
             var exception = Record.Exception(() => client.Cluster);
             exception.Should().BeOfType<ObjectDisposedException>();
-
-            exception = Record.Exception(() => client.StartImplicitSession(default));
-            exception.Should().BeOfType<ObjectDisposedException>();
         }
 
         [Theory]
diff --git a/tests/MongoDB.Driver.Tests/MongoDatabasTests.cs b/tests/MongoDB.Driver.Tests/MongoDatabaseTests.cs
similarity index 98%
rename from tests/MongoDB.Driver.Tests/MongoDatabasTests.cs
rename to tests/MongoDB.Driver.Tests/MongoDatabaseTests.cs
index 9b35886d6b9..1a10811ef6b 100644
--- a/tests/MongoDB.Driver.Tests/MongoDatabasTests.cs
+++ b/tests/MongoDB.Driver.Tests/MongoDatabaseTests.cs
@@ -1095,8 +1095,8 @@ public void RunCommand_should_default_to_ReadPreference_primary(
             var call = _operationExecutor.GetReadCall<BsonDocument>();
             VerifySessionAndCancellationToken(call, session, cancellationToken);
 
-            var binding = call.Binding.Should().BeOfType<ReadBindingHandle>().Subject;
-            binding.ReadPreference.Should().Be(ReadPreference.Primary);
+            call.Options.ExplicitReadPreference.Should().BeNull();
+            call.Options.DefaultReadPreference.Should().Be(ReadPreference.Primary);
 
             var op = call.Operation.Should().BeOfType<ReadCommandOperation<BsonDocument>>().Subject;
             op.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
@@ -1142,8 +1142,8 @@ public void RunCommand_should_use_the_provided_ReadPreference(
             var call = _operationExecutor.GetReadCall<BsonDocument>();
             VerifySessionAndCancellationToken(call, session, cancellationToken);
 
-            var binding = call.Binding.Should().BeOfType<ReadBindingHandle>().Subject;
-            binding.ReadPreference.Should().Be(readPreference);
+            call.Options.ExplicitReadPreference.Should().Be(readPreference);
+            call.Options.DefaultReadPreference.Should().Be(ReadPreference.Primary);
 
             var op = call.Operation.Should().BeOfType<ReadCommandOperation<BsonDocument>>().Subject;
             op.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
@@ -1188,8 +1188,8 @@ public void RunCommand_should_run_a_non_read_command(
             var call = _operationExecutor.GetReadCall<BsonDocument>();
             VerifySessionAndCancellationToken(call, session, cancellationToken);
 
-            var binding = call.Binding.Should().BeOfType<ReadBindingHandle>().Subject;
-            binding.ReadPreference.Should().Be(ReadPreference.Primary);
+            call.Options.ExplicitReadPreference.Should().BeNull();
+            call.Options.DefaultReadPreference.Should().Be(ReadPreference.Primary);
 
             var op = call.Operation.Should().BeOfType<ReadCommandOperation<BsonDocument>>().Subject;
             op.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
@@ -1234,8 +1234,8 @@ public void RunCommand_should_run_a_json_command(
             var call = _operationExecutor.GetReadCall<BsonDocument>();
             VerifySessionAndCancellationToken(call, session, cancellationToken);
 
-            var binding = call.Binding.Should().BeOfType<ReadBindingHandle>().Subject;
-            binding.ReadPreference.Should().Be(ReadPreference.Primary);
+            call.Options.ExplicitReadPreference.Should().BeNull();
+            call.Options.DefaultReadPreference.Should().Be(ReadPreference.Primary);
 
             var op = call.Operation.Should().BeOfType<ReadCommandOperation<BsonDocument>>().Subject;
             op.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
@@ -1280,8 +1280,8 @@ public void RunCommand_should_run_a_serialized_command(
             var call = _operationExecutor.GetReadCall<BsonDocument>();
             VerifySessionAndCancellationToken(call, session, cancellationToken);
 
-            var binding = call.Binding.Should().BeOfType<ReadBindingHandle>().Subject;
-            binding.ReadPreference.Should().Be(ReadPreference.Primary);
+            call.Options.ExplicitReadPreference.Should().BeNull();
+            call.Options.DefaultReadPreference.Should().Be(ReadPreference.Primary);
 
             var op = call.Operation.Should().BeOfType<ReadCommandOperation<BsonDocument>>().Subject;
             op.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
diff --git a/tests/MongoDB.Driver.Tests/OperationExecutorTests.cs b/tests/MongoDB.Driver.Tests/OperationExecutorTests.cs
new file mode 100644
index 00000000000..60fadc85f1e
--- /dev/null
+++ b/tests/MongoDB.Driver.Tests/OperationExecutorTests.cs
@@ -0,0 +1,117 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MongoDB.Driver.Core.Bindings;
+using MongoDB.Driver.Core.Clusters;
+using MongoDB.Driver.Core.Operations;
+using MongoDB.TestHelpers.XunitExtensions;
+using Moq;
+using Xunit;
+
+namespace MongoDB.Driver.Tests
+{
+    public class OperationExecutorTests
+    {
+        [Theory]
+        [ParameterAttributeData]
+        public async Task StartImplicitSessionTests([Values(true, false)]bool isAsync)
+        {
+            var subject = CreateSubject(out var clusterMock, out _);
+            if (isAsync)
+            {
+                await subject.StartImplicitSessionAsync(CancellationToken.None);
+            }
+            else
+            {
+                subject.StartImplicitSession(CancellationToken.None);
+            }
+
+            clusterMock.Verify(c => c.StartSession(It.Is<CoreSessionOptions>(v => v.IsImplicit && v.IsCausallyConsistent == false && v.IsSnapshot == false)));
+        }
+
+        [Theory]
+        [MemberData(nameof(ImplicitSessionTestCases))]
+        public async Task ExecuteReadOperationShouldStartAndDisposeImplicitSessionIfNeeded(bool shouldCreateSession, bool isAsync, IClientSessionHandle session)
+        {
+            var subject = CreateSubject(out var clusterMock, out var implicitSessionMock);
+            var readOperation = Mock.Of<IReadOperation<object>>();
+            var readOperationOptions = new ReadOperationOptions();
+
+            _ = isAsync ?
+                await subject.ExecuteReadOperationAsync(readOperation, readOperationOptions, session, CancellationToken.None) :
+                subject.ExecuteReadOperation(readOperation, readOperationOptions, session, CancellationToken.None);
+
+            var times = shouldCreateSession ? Times.Once() : Times.Never();
+            clusterMock.Verify(c => c.StartSession(It.Is<CoreSessionOptions>(v => v.IsImplicit && v.IsCausallyConsistent == false && v.IsSnapshot == false)), times);
+            implicitSessionMock.Verify(s => s.Dispose(), times);
+        }
+
+        [Theory]
+        [MemberData(nameof(ImplicitSessionTestCases))]
+        public async Task ExecuteWriteOperationShouldStartAndDisposeImplicitSessionIfNeeded(bool shouldCreateSession, bool isAsync, IClientSessionHandle session)
+        {
+            var subject = CreateSubject(out var clusterMock, out var implicitSessionMock);
+            var writeOperation = Mock.Of<IWriteOperation<object>>();
+            var writeOperationOptions = new WriteOperationOptions();
+
+            _ = isAsync ?
+                await subject.ExecuteWriteOperationAsync(writeOperation, writeOperationOptions, session, CancellationToken.None) :
+                subject.ExecuteWriteOperation(writeOperation, writeOperationOptions, session, CancellationToken.None);
+
+            var times = shouldCreateSession ? Times.Once() : Times.Never();
+            clusterMock.Verify(c => c.StartSession(It.Is<CoreSessionOptions>(v => v.IsImplicit && v.IsCausallyConsistent == false && v.IsSnapshot == false)), times);
+            implicitSessionMock.Verify(s => s.Dispose(), times);
+        }
+
+        private static IEnumerable<object[]> ImplicitSessionTestCases()
+        {
+            yield return [ true, false, null ];
+            yield return [ true, true, null ];
+
+            var implicitSession = new Mock<IClientSessionHandle>();
+            implicitSession.SetupGet(s => s.IsImplicit).Returns(true);
+            implicitSession.SetupGet(s => s.WrappedCoreSession).Returns(CreateCoreSessionMock(true).Object);
+            yield return [ false, false, implicitSession.Object ];
+            yield return [ false, true, implicitSession.Object ];
+
+            var regularSession = new Mock<IClientSessionHandle>();
+            regularSession.SetupGet(s => s.WrappedCoreSession).Returns(CreateCoreSessionMock(false).Object);
+            yield return [ false, false, regularSession.Object ];
+            yield return [ false, true, regularSession.Object ];
+        }
+
+        private OperationExecutor CreateSubject(out Mock<IClusterInternal> clusterMock, out Mock<ICoreSessionHandle> implicitSessionMock)
+        {
+            implicitSessionMock = CreateCoreSessionMock(true);
+            clusterMock = new Mock<IClusterInternal>();
+            clusterMock.Setup(c => c.StartSession(It.IsAny<CoreSessionOptions>())).Returns(implicitSessionMock.Object);
+            var clientMock = new Mock<IMongoClient>();
+            clientMock.SetupGet(c => c.Cluster).Returns(clusterMock.Object);
+            return new OperationExecutor(clientMock.Object);
+        }
+
+        private static Mock<ICoreSessionHandle> CreateCoreSessionMock(bool isImplicit)
+        {
+            var sessionMock = new Mock<ICoreSessionHandle>();
+            sessionMock.SetupGet(s => s.IsImplicit).Returns(isImplicit);
+            sessionMock.Setup(s => s.Fork()).Returns(() => CreateCoreSessionMock(isImplicit).Object);
+            return sessionMock;
+        }
+    }
+}
+
diff --git a/tests/MongoDB.Driver.Tests/ReadOperationOptionsTests.cs b/tests/MongoDB.Driver.Tests/ReadOperationOptionsTests.cs
new file mode 100644
index 00000000000..585b2e442ff
--- /dev/null
+++ b/tests/MongoDB.Driver.Tests/ReadOperationOptionsTests.cs
@@ -0,0 +1,70 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using FluentAssertions;
+using MongoDB.Driver.Core.Bindings;
+using Moq;
+using Xunit;
+
+namespace MongoDB.Driver.Tests
+{
+    public class ReadOperationOptionsTests
+    {
+        [Theory]
+        [MemberData(nameof(GetEffectiveReadPreferenceTestCases))]
+        public void GetEffectiveReadPreferenceTests(
+            ReadPreference expectedReadPreference,
+            ReadPreference explicitReadPreference,
+            ReadPreference defaultReadPreference,
+            IClientSessionHandle session)
+        {
+            var readOperationOptions = new ReadOperationOptions(explicitReadPreference, defaultReadPreference);
+            var result = readOperationOptions.GetEffectiveReadPreference(session);
+
+            result.Should().Be(expectedReadPreference);
+        }
+
+        public static IEnumerable<object[]> GetEffectiveReadPreferenceTestCases()
+        {
+            var noTransactionSession = CreateSessionMock(null);
+            var inTransactionSession = CreateSessionMock(new TransactionOptions(readPreference: ReadPreference.Nearest));
+            var inTransactionNoPreferenceSession = CreateSessionMock(new TransactionOptions());
+
+            yield return [ReadPreference.Primary, null, null, noTransactionSession];
+            yield return [ReadPreference.Secondary, ReadPreference.Secondary, ReadPreference.SecondaryPreferred, noTransactionSession];
+            yield return [ReadPreference.Secondary, ReadPreference.Secondary, ReadPreference.SecondaryPreferred, inTransactionSession];
+            yield return [ReadPreference.SecondaryPreferred, null, ReadPreference.SecondaryPreferred, noTransactionSession];
+            yield return [ReadPreference.Nearest, null, ReadPreference.SecondaryPreferred, inTransactionSession];
+            yield return [ReadPreference.Primary, null, null, inTransactionNoPreferenceSession];
+            yield return [ReadPreference.SecondaryPreferred, null, ReadPreference.SecondaryPreferred, inTransactionNoPreferenceSession];
+        }
+
+        private static IClientSessionHandle CreateSessionMock(TransactionOptions transactionOptions)
+        {
+            var sessionMock = new Mock<IClientSessionHandle>();
+            if (transactionOptions != null)
+            {
+                sessionMock.SetupGet(s => s.IsInTransaction).Returns(true);
+                var coreSessionMock = new Mock<ICoreSessionHandle>();
+                coreSessionMock.SetupGet(s => s.CurrentTransaction).Returns(new CoreTransaction(0, transactionOptions));
+                sessionMock.SetupGet(s => s.WrappedCoreSession).Returns(coreSessionMock.Object);
+            }
+
+            return sessionMock.Object;
+        }
+    }
+}
+