PR

sanych-sun · sanych-sun · commit d50c0df786ff · 2025-06-18T10:45:27.000-07:00
diff --git a/src/MongoDB.Driver/Core/Connections/BinaryConnection.cs b/src/MongoDB.Driver/Core/Connections/BinaryConnection.cs
@@ -587,17 +587,17 @@ public void SendMessage(RequestMessage message, MessageEncoderSettings messageEn
             Ensure.IsNotNull(message, nameof(message));
             ThrowIfCancelledOrDisposedOrNotOpen(cancellationToken);
 
-            var helper = new SendMessagesHelper(this, message, messageEncoderSettings);
+            var helper = new SendMessageHelper(this, message, messageEncoderSettings);
             try
             {
                 helper.EncodingMessage();
-                using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessages))
+                using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessage))
                 {
                     helper.SendingMessage(uncompressedBuffer);
                     int sentLength;
-                    if (ShouldBeCompressed(sentMessages))
+                    if (ShouldBeCompressed(sentMessage))
                     {
-                        using (var compressedBuffer = CompressMessage(sentMessages, uncompressedBuffer, messageEncoderSettings))
+                        using (var compressedBuffer = CompressMessage(sentMessage, uncompressedBuffer, messageEncoderSettings))
                         {
                             SendBuffer(compressedBuffer, cancellationToken);
                             sentLength = compressedBuffer.Length;
@@ -608,12 +608,12 @@ public void SendMessage(RequestMessage message, MessageEncoderSettings messageEn
                         SendBuffer(uncompressedBuffer, cancellationToken);
                         sentLength = uncompressedBuffer.Length;
                     }
-                    helper.SentMessages(sentLength);
+                    helper.SentMessage(sentLength);
                 }
             }
             catch (Exception ex)
             {
-                helper.FailedSendingMessages(ex);
+                helper.FailedSendingMessage(ex);
                 ThrowOperationCanceledExceptionIfRequired(ex);
                 throw;
             }
@@ -624,17 +624,17 @@ public async Task SendMessageAsync(RequestMessage message, MessageEncoderSetting
             Ensure.IsNotNull(message, nameof(message));
             ThrowIfCancelledOrDisposedOrNotOpen(cancellationToken);
 
-            var helper = new SendMessagesHelper(this, message, messageEncoderSettings);
+            var helper = new SendMessageHelper(this, message, messageEncoderSettings);
             try
             {
                 helper.EncodingMessage();
-                using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessages))
+                using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessage))
                 {
                     helper.SendingMessage(uncompressedBuffer);
                     int sentLength;
-                    if (ShouldBeCompressed(sentMessages))
+                    if (ShouldBeCompressed(sentMessage))
                     {
-                        using (var compressedBuffer = CompressMessage(sentMessages, uncompressedBuffer, messageEncoderSettings))
+                        using (var compressedBuffer = CompressMessage(sentMessage, uncompressedBuffer, messageEncoderSettings))
                         {
                             await SendBufferAsync(compressedBuffer, cancellationToken).ConfigureAwait(false);
                             sentLength = compressedBuffer.Length;
@@ -645,12 +645,12 @@ public async Task SendMessageAsync(RequestMessage message, MessageEncoderSetting
                         await SendBufferAsync(uncompressedBuffer, cancellationToken).ConfigureAwait(false);
                         sentLength = uncompressedBuffer.Length;
                     }
-                    helper.SentMessages(sentLength);
+                    helper.SentMessage(sentLength);
                 }
             }
             catch (Exception ex)
             {
-                helper.FailedSendingMessages(ex);
+                helper.FailedSendingMessage(ex);
                 ThrowOperationCanceledExceptionIfRequired(ex);
                 throw;
             }
@@ -976,7 +976,7 @@ private Opcode PeekOpcode(BsonStream stream)
             }
         }
 
-        private class SendMessagesHelper
+        private class SendMessageHelper
         {
             private readonly Stopwatch _commandStopwatch;
             private readonly BinaryConnection _connection;
@@ -986,7 +986,7 @@ private class SendMessagesHelper
             private TimeSpan _serializationDuration;
             private Stopwatch _networkStopwatch;
 
-            public SendMessagesHelper(BinaryConnection connection, RequestMessage message, MessageEncoderSettings messageEncoderSettings)
+            public SendMessageHelper(BinaryConnection connection, RequestMessage message, MessageEncoderSettings messageEncoderSettings)
             {
                 _connection = connection;
                 _message = message;
@@ -1032,7 +1032,7 @@ public void EncodingMessage()
                 _connection._eventLogger.LogAndPublish(new ConnectionSendingMessagesEvent(_connection.ConnectionId, _requestIds.Value, EventContext.OperationId));
             }
 
-            public void FailedSendingMessages(Exception ex)
+            public void FailedSendingMessage(Exception ex)
             {
                 if (_connection._commandEventHelper.ShouldCallErrorSending)
                 {
@@ -1052,7 +1052,7 @@ public void SendingMessage(IByteBuffer buffer)
                 _networkStopwatch = Stopwatch.StartNew();
             }
 
-            public void SentMessages(int bufferLength)
+            public void SentMessage(int bufferLength)
             {
                 _networkStopwatch.Stop();
                 var networkDuration = _networkStopwatch.Elapsed;
diff --git a/tests/MongoDB.Driver.Tests/Core/Connections/BinaryConnectionTests.cs b/tests/MongoDB.Driver.Tests/Core/Connections/BinaryConnectionTests.cs
@@ -477,7 +477,7 @@ public void ReceiveMessage_should_complete_when_reply_is_already_on_the_stream(
             using (var stream = new BlockingMemoryStream())
             {
                 var messageToReceive = MessageHelper.BuildReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
-                MessageHelper.WriteResponseToStream(stream, messageToReceive);
+                MessageHelper.WriteResponsesToStream(stream, messageToReceive);
 
                 var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
 
@@ -545,7 +545,7 @@ public void ReceiveMessage_should_complete_when_reply_is_not_already_on_the_stre
                 receiveMessageTask.IsCompleted.Should().BeFalse();
 
                 var messageToReceive = MessageHelper.BuildReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
-                MessageHelper.WriteResponseToStream(stream, messageToReceive);
+                MessageHelper.WriteResponsesToStream(stream, messageToReceive);
 
                 var received = receiveMessageTask.GetAwaiter().GetResult();
 
@@ -601,7 +601,7 @@ public void ReceiveMessage_should_handle_out_of_order_replies(
 
                 var messageToReceive10 = MessageHelper.BuildReply<BsonDocument>(new BsonDocument("_id", 10), BsonDocumentSerializer.Instance, responseTo: 10);
                 var messageToReceive11 = MessageHelper.BuildReply<BsonDocument>(new BsonDocument("_id", 11), BsonDocumentSerializer.Instance, responseTo: 11);
-                MessageHelper.WriteResponseToStream(stream, messageToReceive11, messageToReceive10); // out of order
+                MessageHelper.WriteResponsesToStream(stream, messageToReceive11, messageToReceive10); // out of order
 
                 var received10 = receivedTask10.GetAwaiter().GetResult();
                 var received11 = receivedTask11.GetAwaiter().GetResult();
@@ -829,7 +829,7 @@ public void ReceiveMessage_should_throw_MongoConnectionClosedException_when_conn
 
         [Theory]
         [ParameterAttributeData]
-        public async Task SendMessages_should_throw_an_ArgumentNullException_if_message_is_null(
+        public async Task SendMessage_should_throw_an_ArgumentNullException_if_message_is_null(
             [Values(false, true)]
             bool async)
         {
@@ -842,7 +842,7 @@ await Record.ExceptionAsync(() => _subject.SendMessageAsync(null, _messageEncode
 
         [Theory]
         [ParameterAttributeData]
-        public async Task SendMessages_should_throw_an_ObjectDisposedException_if_the_connection_is_disposed(
+        public async Task SendMessage_should_throw_an_ObjectDisposedException_if_the_connection_is_disposed(
             [Values(false, true)]
             bool async)
         {
@@ -858,7 +858,7 @@ await Record.ExceptionAsync(() => _subject.SendMessageAsync(message, _messageEnc
 
         [Theory]
         [ParameterAttributeData]
-        public async Task SendMessages_should_throw_an_InvalidOperationException_if_the_connection_is_not_open(
+        public async Task SendMessage_should_throw_an_InvalidOperationException_if_the_connection_is_not_open(
             [Values(false, true)]
             bool async)
         {
@@ -873,7 +873,7 @@ await Record.ExceptionAsync(() => _subject.SendMessageAsync(message, _messageEnc
 
         [Theory]
         [ParameterAttributeData]
-        public void SendMessages_should_put_the_message_on_the_stream_and_raise_the_correct_events(
+        public void SendMessage_should_put_the_message_on_the_stream_and_raise_the_correct_events(
             [Values(false, true)]
             bool async)
         {
diff --git a/tests/MongoDB.Driver.Tests/Core/Connections/BinaryConnection_CommandEventTests.cs b/tests/MongoDB.Driver.Tests/Core/Connections/BinaryConnection_CommandEventTests.cs
@@ -489,7 +489,7 @@ private void SendMessage(RequestMessage message)
 
         private void ReceiveMessage(ReplyMessage<BsonDocument> message)
         {
-            MessageHelper.WriteResponseToStream(_stream, message);
+            MessageHelper.WriteResponsesToStream(_stream, message);
             var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
             _subject.ReceiveMessageAsync(message.ResponseTo, encoderSelector, _messageEncoderSettings, CancellationToken.None).Wait();
         }
diff --git a/tests/MongoDB.Driver.Tests/Core/Helpers/MessageHelper.cs b/tests/MongoDB.Driver.Tests/Core/Helpers/MessageHelper.cs
@@ -225,7 +225,7 @@ public static List<BsonDocument> TranslateMessagesToBsonDocuments(byte[] bytes)
             return TranslateMessagesToBsonDocuments(TranslateBytesToRequests(bytes));
         }
 
-        public static void WriteResponseToStream(BlockingMemoryStream stream, params ResponseMessage[] responses)
+        public static void WriteResponsesToStream(BlockingMemoryStream stream, params ResponseMessage[] responses)
         {
             lock (stream.Lock)
             {

Original file line number	Diff line number	Diff line change
`@@ -587,17 +587,17 @@ public void SendMessage(RequestMessage message, MessageEncoderSettings messageEn`
`587`	`587`	`Ensure.IsNotNull(message, nameof(message));`
`588`	`588`	`ThrowIfCancelledOrDisposedOrNotOpen(cancellationToken);`
`589`	`589`
`590`		`- var helper = new SendMessagesHelper(this, message, messageEncoderSettings);`
	`590`	`+ var helper = new SendMessageHelper(this, message, messageEncoderSettings);`
`591`	`591`	`try`
`592`	`592`	`{`
`593`	`593`	`helper.EncodingMessage();`
`594`		`- using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessages))`
	`594`	`+ using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessage))`
`595`	`595`	`{`
`596`	`596`	`helper.SendingMessage(uncompressedBuffer);`
`597`	`597`	`int sentLength;`
`598`		`- if (ShouldBeCompressed(sentMessages))`
	`598`	`+ if (ShouldBeCompressed(sentMessage))`
`599`	`599`	`{`
`600`		`- using (var compressedBuffer = CompressMessage(sentMessages, uncompressedBuffer, messageEncoderSettings))`
	`600`	`+ using (var compressedBuffer = CompressMessage(sentMessage, uncompressedBuffer, messageEncoderSettings))`
`601`	`601`	`{`
`602`	`602`	`SendBuffer(compressedBuffer, cancellationToken);`
`603`	`603`	`sentLength = compressedBuffer.Length;`
`@@ -608,12 +608,12 @@ public void SendMessage(RequestMessage message, MessageEncoderSettings messageEn`
`608`	`608`	`SendBuffer(uncompressedBuffer, cancellationToken);`
`609`	`609`	`sentLength = uncompressedBuffer.Length;`
`610`	`610`	`}`
`611`		`- helper.SentMessages(sentLength);`
	`611`	`+ helper.SentMessage(sentLength);`
`612`	`612`	`}`
`613`	`613`	`}`
`614`	`614`	`catch (Exception ex)`
`615`	`615`	`{`
`616`		`- helper.FailedSendingMessages(ex);`
	`616`	`+ helper.FailedSendingMessage(ex);`
`617`	`617`	`ThrowOperationCanceledExceptionIfRequired(ex);`
`618`	`618`	`throw;`
`619`	`619`	`}`
`@@ -624,17 +624,17 @@ public async Task SendMessageAsync(RequestMessage message, MessageEncoderSetting`
`624`	`624`	`Ensure.IsNotNull(message, nameof(message));`
`625`	`625`	`ThrowIfCancelledOrDisposedOrNotOpen(cancellationToken);`
`626`	`626`
`627`		`- var helper = new SendMessagesHelper(this, message, messageEncoderSettings);`
	`627`	`+ var helper = new SendMessageHelper(this, message, messageEncoderSettings);`
`628`	`628`	`try`
`629`	`629`	`{`
`630`	`630`	`helper.EncodingMessage();`
`631`		`- using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessages))`
	`631`	`+ using (var uncompressedBuffer = helper.EncodeMessage(cancellationToken, out var sentMessage))`
`632`	`632`	`{`
`633`	`633`	`helper.SendingMessage(uncompressedBuffer);`
`634`	`634`	`int sentLength;`
`635`		`- if (ShouldBeCompressed(sentMessages))`
	`635`	`+ if (ShouldBeCompressed(sentMessage))`
`636`	`636`	`{`
`637`		`- using (var compressedBuffer = CompressMessage(sentMessages, uncompressedBuffer, messageEncoderSettings))`
	`637`	`+ using (var compressedBuffer = CompressMessage(sentMessage, uncompressedBuffer, messageEncoderSettings))`
`638`	`638`	`{`
`639`	`639`	`await SendBufferAsync(compressedBuffer, cancellationToken).ConfigureAwait(false);`
`640`	`640`	`sentLength = compressedBuffer.Length;`
`@@ -645,12 +645,12 @@ public async Task SendMessageAsync(RequestMessage message, MessageEncoderSetting`
`645`	`645`	`await SendBufferAsync(uncompressedBuffer, cancellationToken).ConfigureAwait(false);`
`646`	`646`	`sentLength = uncompressedBuffer.Length;`
`647`	`647`	`}`
`648`		`- helper.SentMessages(sentLength);`
	`648`	`+ helper.SentMessage(sentLength);`
`649`	`649`	`}`
`650`	`650`	`}`
`651`	`651`	`catch (Exception ex)`
`652`	`652`	`{`
`653`		`- helper.FailedSendingMessages(ex);`
	`653`	`+ helper.FailedSendingMessage(ex);`
`654`	`654`	`ThrowOperationCanceledExceptionIfRequired(ex);`
`655`	`655`	`throw;`
`656`	`656`	`}`
`@@ -976,7 +976,7 @@ private Opcode PeekOpcode(BsonStream stream)`
`976`	`976`	`}`
`977`	`977`	`}`
`978`	`978`
`979`		`- private class SendMessagesHelper`
	`979`	`+ private class SendMessageHelper`
`980`	`980`	`{`
`981`	`981`	`private readonly Stopwatch _commandStopwatch;`
`982`	`982`	`private readonly BinaryConnection _connection;`
`@@ -986,7 +986,7 @@ private class SendMessagesHelper`
`986`	`986`	`private TimeSpan _serializationDuration;`
`987`	`987`	`private Stopwatch _networkStopwatch;`
`988`	`988`
`989`		`- public SendMessagesHelper(BinaryConnection connection, RequestMessage message, MessageEncoderSettings messageEncoderSettings)`
	`989`	`+ public SendMessageHelper(BinaryConnection connection, RequestMessage message, MessageEncoderSettings messageEncoderSettings)`
`990`	`990`	`{`
`991`	`991`	`_connection = connection;`
`992`	`992`	`_message = message;`
`@@ -1032,7 +1032,7 @@ public void EncodingMessage()`
`1032`	`1032`	`_connection._eventLogger.LogAndPublish(new ConnectionSendingMessagesEvent(_connection.ConnectionId, _requestIds.Value, EventContext.OperationId));`
`1033`	`1033`	`}`
`1034`	`1034`
`1035`		`- public void FailedSendingMessages(Exception ex)`
	`1035`	`+ public void FailedSendingMessage(Exception ex)`
`1036`	`1036`	`{`
`1037`	`1037`	`if (_connection._commandEventHelper.ShouldCallErrorSending)`
`1038`	`1038`	`{`
`@@ -1052,7 +1052,7 @@ public void SendingMessage(IByteBuffer buffer)`
`1052`	`1052`	`_networkStopwatch = Stopwatch.StartNew();`
`1053`	`1053`	`}`
`1054`	`1054`
`1055`		`- public void SentMessages(int bufferLength)`
	`1055`	`+ public void SentMessage(int bufferLength)`
`1056`	`1056`	`{`
`1057`	`1057`	`_networkStopwatch.Stop();`
`1058`	`1058`	`var networkDuration = _networkStopwatch.Elapsed;`
Original file line number	Diff line number	Diff line change
`@@ -489,7 +489,7 @@ private void SendMessage(RequestMessage message)`
`489`	`489`
`490`	`490`	`private void ReceiveMessage(ReplyMessage<BsonDocument> message)`
`491`	`491`	`{`
`492`		`- MessageHelper.WriteResponseToStream(_stream, message);`
	`492`	`+ MessageHelper.WriteResponsesToStream(_stream, message);`
`493`	`493`	`var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);`
`494`	`494`	`_subject.ReceiveMessageAsync(message.ResponseTo, encoderSelector, _messageEncoderSettings, CancellationToken.None).Wait();`
`495`	`495`	`}`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ public static List<BsonDocument> TranslateMessagesToBsonDocuments(byte[] bytes)`
`225`	`225`	`return TranslateMessagesToBsonDocuments(TranslateBytesToRequests(bytes));`
`226`	`226`	`}`
`227`	`227`
`228`		`- public static void WriteResponseToStream(BlockingMemoryStream stream, params ResponseMessage[] responses)`
	`228`	`+ public static void WriteResponsesToStream(BlockingMemoryStream stream, params ResponseMessage[] responses)`
`229`	`229`	`{`
`230`	`230`	`lock (stream.Lock)`
`231`	`231`	`{`