rename BatchMessage to MessageBatch for consistency with Azure#539

Author: Emil Einarsson

src/Microsoft.Azure.ServiceBus/Core/MessageReceiver.cs

@@ -48,15 +48,15 @@ public class MessageReceiver : ClientEntity, IMessageReceiver
         readonly ConcurrentExpiringSet<Guid> requestResponseLockedMessages;
         readonly bool isSessionReceiver;
         readonly object messageReceivePumpSyncLock;
-        readonly object batchMessageReceivePumpSyncLock;
+        readonly object messageBatchReceivePumpSyncLock;
         readonly ActiveClientLinkManager clientLinkManager;
         readonly ServiceBusDiagnosticSource diagnosticSource;
 
         int prefetchCount;
         long lastPeekedSequenceNumber;
         MessageReceivePump receivePump;
         CancellationTokenSource receivePumpCancellationTokenSource;
-        BatchMessageReceivePump batchReceivePump;
+        MessageBatchReceivePump batchReceivePump;
         CancellationTokenSource batchReceivePumpCancellationTokenSource;
 
         /// <summary>
@@ -195,7 +195,7 @@ internal MessageReceiver(
             this.requestResponseLockedMessages = new ConcurrentExpiringSet<Guid>();
             this.PrefetchCount = prefetchCount;
             this.messageReceivePumpSyncLock = new object();
-            this.batchMessageReceivePumpSyncLock = new object();
+            this.messageBatchReceivePumpSyncLock = new object();
             this.clientLinkManager = new ActiveClientLinkManager(this, this.CbsTokenProvider);
             this.diagnosticSource = new ServiceBusDiagnosticSource(entityPath, serviceBusConnection.Endpoint);
             MessagingEventSource.Log.MessageReceiverCreateStop(serviceBusConnection.Endpoint.Authority, entityPath, this.ClientId);
@@ -827,7 +827,7 @@ public async Task RenewLocksAsync(IEnumerable<Message> messages)
 
             var lockTokens = messages.Select(x => x.SystemProperties.LockToken);
 
-            MessagingEventSource.Log.BatchMessageRenewLockStart(this.ClientId, messages.Count(), lockTokens);
+            MessagingEventSource.Log.MessageBatchRenewLockStart(this.ClientId, messages.Count(), lockTokens);
             bool isDiagnosticSourceEnabled = ServiceBusDiagnosticSource.IsEnabled();
             Activity activity = isDiagnosticSourceEnabled ? this.diagnosticSource.RenewLocksStart() : null;
 
@@ -856,7 +856,7 @@ public async Task RenewLocksAsync(IEnumerable<Message> messages)
             {
                 this.diagnosticSource.RenewLocksStop(activity, renewTask?.Status, lockedUntilUtc);
             }
-            MessagingEventSource.Log.BatchMessageRenewLockStop(this.ClientId);
+            MessagingEventSource.Log.MessageBatchRenewLockStop(this.ClientId);
 
         }
 
@@ -961,9 +961,9 @@ public void RegisterMessageHandler(Func<Message, CancellationToken, Task> handle
         /// </summary>
         /// <param name="handler">A <see cref="Func{T1, T2, TResult}"/> that processes messages.</param>
         /// <param name="exceptionReceivedHandler">A <see cref="Func{T1, TResult}"/> that is used to notify exceptions.</param>
-        public void RegisterBatchMessageHandler(Func<IList<Message>, CancellationToken, Task> handler, Func<ExceptionReceivedEventArgs, Task> exceptionReceivedHandler)
+        public void RegisterMessageBatchHandler(Func<IList<Message>, CancellationToken, Task> handler, Func<ExceptionReceivedEventArgs, Task> exceptionReceivedHandler)
         {
-            this.RegisterBatchMessageHandler(handler, new BatchMessageHandlerOptions(exceptionReceivedHandler));
+            this.RegisterMessageBatchHandler(handler, new MessageBatchHandlerOptions(exceptionReceivedHandler));
         }
 
         /// <summary>
@@ -986,10 +986,10 @@ public void RegisterMessageHandler(Func<Message, CancellationToken, Task> handle
         /// <param name="handler">A <see cref="Func{Message, CancellationToken, Task}"/> that processes messages.</param>
         /// <param name="messageHandlerOptions">The <see cref="MessageHandlerOptions"/> options used to configure the settings of the pump.</param>
         /// <remarks>Enable prefetch to speed up the receive rate.</remarks>
-        public void RegisterBatchMessageHandler(Func<IList<Message>, CancellationToken, Task> handler, BatchMessageHandlerOptions messageHandlerOptions)
+        public void RegisterMessageBatchHandler(Func<IList<Message>, CancellationToken, Task> handler, MessageBatchHandlerOptions messageHandlerOptions)
         {
             this.ThrowIfClosed();
-            this.OnBatchMessageHandler(messageHandlerOptions, handler);
+            this.OnMessageBatchHandler(messageHandlerOptions, handler);
         }
 
         /// <summary>
@@ -1099,7 +1099,7 @@ protected override async Task OnClosingAsync()
                     this.receivePump = null;
                 }
             }
-            lock (this.batchMessageReceivePumpSyncLock)
+            lock (this.messageBatchReceivePumpSyncLock)
             {
                 if (this.batchReceivePump != null)
                 {
@@ -1410,21 +1410,21 @@ protected virtual async Task<DateTime> OnRenewLocksAsync(IEnumerable<string> loc
         }
 
         /// <summary> </summary>
-        protected virtual void OnBatchMessageHandler(
-            BatchMessageHandlerOptions registerHandlerOptions,
+        protected virtual void OnMessageBatchHandler(
+            MessageBatchHandlerOptions registerHandlerOptions,
             Func<IList<Message>, CancellationToken, Task> callback)
         {
-            MessagingEventSource.Log.RegisterOnBatchMessageHandlerStart(this.ClientId, registerHandlerOptions);
+            MessagingEventSource.Log.RegisterOnMessageBatchHandlerStart(this.ClientId, registerHandlerOptions);
 
-            lock (this.batchMessageReceivePumpSyncLock)
+            lock (this.messageBatchReceivePumpSyncLock)
             {
                 if (this.batchReceivePump != null)
                 {
                     throw new InvalidOperationException(Resources.MessageHandlerAlreadyRegistered);
                 }
 
                 this.batchReceivePumpCancellationTokenSource = new CancellationTokenSource();
-                this.batchReceivePump = new BatchMessageReceivePump(this, registerHandlerOptions, callback, this.ServiceBusConnection.Endpoint, this.batchReceivePumpCancellationTokenSource.Token);
+                this.batchReceivePump = new MessageBatchReceivePump(this, registerHandlerOptions, callback, this.ServiceBusConnection.Endpoint, this.batchReceivePumpCancellationTokenSource.Token);
             }
 
             try
@@ -1434,7 +1434,7 @@ protected virtual void OnBatchMessageHandler(
             catch (Exception exception)
             {
                 MessagingEventSource.Log.RegisterOnMessageHandlerException(this.ClientId, exception);
-                lock (this.batchMessageReceivePumpSyncLock)
+                lock (this.messageBatchReceivePumpSyncLock)
                 {
                     if (this.batchReceivePump != null)
                     {

src/Microsoft.Azure.ServiceBus/BatchMessageHandlerOptions.cs renamed to src/Microsoft.Azure.ServiceBus/MessageBatchHandlerOptions.cs

@@ -10,15 +10,15 @@ namespace Microsoft.Azure.ServiceBus
     using System.Collections.Generic;
 
     /// <summary>Provides options associated with message pump processing using
-    /// <see cref="QueueClient.RegisterBatchMessageHandler(Func{IList{Message}, CancellationToken, Task}, BatchMessageHandlerOptions)" /> and
-    /// <see cref="SubscriptionClient.RegisterBatchMessageHandler(Func{IList{Message}, CancellationToken, Task}, BatchMessageHandlerOptions)" />.</summary>
-    public sealed class BatchMessageHandlerOptions
+    /// <see cref="QueueClient.RegisterMessageBatchHandler(Func{IList{Message}, CancellationToken, Task}, MessageBatchHandlerOptions)" /> and
+    /// <see cref="SubscriptionClient.RegisterMessageBatchHandler(Func{IList{Message}, CancellationToken, Task}, MessageBatchHandlerOptions)" />.</summary>
+    public sealed class MessageBatchHandlerOptions
     {
         int maxConcurrentCalls;
         TimeSpan maxAutoRenewDuration;
         int maxMessageCount;
 
-        /// <summary>Initializes a new instance of the <see cref="BatchMessageHandlerOptions" /> class.
+        /// <summary>Initializes a new instance of the <see cref="MessageBatchHandlerOptions" /> class.
         /// Default Values:
         ///     <see cref="MaxConcurrentCalls"/> = 1
         ///     <see cref="MaxMessageCount"/> = 1
@@ -28,7 +28,7 @@ public sealed class BatchMessageHandlerOptions
         /// </summary>
         /// <param name="exceptionReceivedHandler">A <see cref="Func{T1, TResult}"/> that is invoked during exceptions.
         /// <see cref="ExceptionReceivedEventArgs"/> contains contextual information regarding the exception.</param>
-        public BatchMessageHandlerOptions(Func<ExceptionReceivedEventArgs, Task> exceptionReceivedHandler)
+        public MessageBatchHandlerOptions(Func<ExceptionReceivedEventArgs, Task> exceptionReceivedHandler)
         {
             this.MaxConcurrentCalls = 1;
             this.MaxMessageCount = 1;

src/Microsoft.Azure.ServiceBus/BatchMessageReceivePump.cs renamed to src/Microsoft.Azure.ServiceBus/MessageBatchReceivePump.cs

@@ -12,25 +12,25 @@ namespace Microsoft.Azure.ServiceBus
     using Core;
     using Primitives;
 
-    sealed class BatchMessageReceivePump
+    sealed class MessageBatchReceivePump
     {
-        readonly Func<IList<Message>, CancellationToken, Task> onBatchMessageCallback;
+        readonly Func<IList<Message>, CancellationToken, Task> onMessageBatchCallback;
         readonly string endpoint;
-        readonly BatchMessageHandlerOptions registerHandlerOptions;
+        readonly MessageBatchHandlerOptions registerHandlerOptions;
         readonly MessageReceiver messageReceiver;
         readonly CancellationToken pumpCancellationToken;
         readonly SemaphoreSlim maxConcurrentCallsSemaphoreSlim;
         readonly ServiceBusDiagnosticSource diagnosticSource;
 
-        public BatchMessageReceivePump(MessageReceiver messageReceiver,
-            BatchMessageHandlerOptions registerHandlerOptions,
+        public MessageBatchReceivePump(MessageReceiver messageReceiver,
+            MessageBatchHandlerOptions registerHandlerOptions,
             Func<IList<Message>, CancellationToken, Task> callback,
             Uri endpoint,
             CancellationToken pumpCancellationToken)
         {
             this.messageReceiver = messageReceiver ?? throw new ArgumentNullException(nameof(messageReceiver));
             this.registerHandlerOptions = registerHandlerOptions;
-            this.onBatchMessageCallback = callback;
+            this.onMessageBatchCallback = callback;
             this.endpoint = endpoint.Authority;
             this.pumpCancellationToken = pumpCancellationToken;
             this.maxConcurrentCallsSemaphoreSlim = new SemaphoreSlim(this.registerHandlerOptions.MaxConcurrentCalls);
@@ -39,7 +39,7 @@ public BatchMessageReceivePump(MessageReceiver messageReceiver,
 
         public void StartPump()
         {
-            TaskExtensionHelper.Schedule(() => this.BatchMessagePumpTaskAsync());
+            TaskExtensionHelper.Schedule(() => this.MessageBatchPumpTaskAsync());
         }
 
         bool ShouldRenewLock()
@@ -55,7 +55,7 @@ Task RaiseExceptionReceived(Exception e, string action)
             return this.registerHandlerOptions.RaiseExceptionReceived(eventArgs);
         }
 
-        async Task BatchMessagePumpTaskAsync()
+        async Task MessageBatchPumpTaskAsync()
         {
             while (!this.pumpCancellationToken.IsCancellationRequested)
             {
@@ -71,11 +71,11 @@ async Task BatchMessagePumpTaskAsync()
                         {
                             if (ServiceBusDiagnosticSource.IsEnabled())
                             {
-                                return this.BatchMessageDispatchTaskInstrumented(messages);
+                                return this.MessageBatchDispatchTaskInstrumented(messages);
                             }
                             else
                             {
-                                return this.BatchMessageDispatchTask(messages);
+                                return this.MessageBatchDispatchTask(messages);
                             }
                         });
                     }
@@ -101,13 +101,13 @@ async Task BatchMessagePumpTaskAsync()
             }
         }
 
-        async Task BatchMessageDispatchTaskInstrumented(IList<Message> messages)
+        async Task MessageBatchDispatchTaskInstrumented(IList<Message> messages)
         {
             IEnumerable<Activity> activities = this.diagnosticSource.ProcessStart(messages);
             Task processTask = null;
             try
             {
-                processTask = BatchMessageDispatchTask(messages);
+                processTask = MessageBatchDispatchTask(messages);
                 await processTask.ConfigureAwait(false);
             }
             catch (Exception e)
@@ -121,12 +121,12 @@ async Task BatchMessageDispatchTaskInstrumented(IList<Message> messages)
             }
         }
 
-        async Task BatchMessageDispatchTask(IList<Message> messages)
+        async Task MessageBatchDispatchTask(IList<Message> messages)
         {
             CancellationTokenSource renewLockCancellationTokenSource = null;
             Timer autoRenewLockCancellationTimer = null;
 
-            MessagingEventSource.Log.BatchMessageReceiverPumpDispatchTaskStart(this.messageReceiver.ClientId, messages);
+            MessagingEventSource.Log.MessageBatchReceiverPumpDispatchTaskStart(this.messageReceiver.ClientId, messages);
 
             if (this.ShouldRenewLock())
             {
@@ -139,14 +139,14 @@ async Task BatchMessageDispatchTask(IList<Message> messages)
 
             try
             {
-                MessagingEventSource.Log.BatchMessageReceiverPumpUserCallbackStart(this.messageReceiver.ClientId);
-                await this.onBatchMessageCallback(messages, this.pumpCancellationToken).ConfigureAwait(false);
+                MessagingEventSource.Log.MessageBatchReceiverPumpUserCallbackStart(this.messageReceiver.ClientId);
+                await this.onMessageBatchCallback(messages, this.pumpCancellationToken).ConfigureAwait(false);
 
-                MessagingEventSource.Log.BatchMessageReceiverPumpUserCallbackStop(this.messageReceiver.ClientId);
+                MessagingEventSource.Log.MessageBatchReceiverPumpUserCallbackStop(this.messageReceiver.ClientId);
             }
             catch (Exception exception)
             {
-                MessagingEventSource.Log.BatchMessageReceiverPumpUserCallbackException(this.messageReceiver.ClientId, exception);
+                MessagingEventSource.Log.MessageBatchReceiverPumpUserCallbackException(this.messageReceiver.ClientId, exception);
                 await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.UserCallback).ConfigureAwait(false);
 
                 // Nothing much to do if UserCallback throws, Abandon message and Release semaphore.
@@ -175,7 +175,7 @@ async Task BatchMessageDispatchTask(IList<Message> messages)
             await this.CompleteMessagesIfNeededAsync(messages).ConfigureAwait(false);
             this.maxConcurrentCallsSemaphoreSlim.Release();
 
-            MessagingEventSource.Log.BatchMessageReceiverPumpDispatchTaskStop(this.messageReceiver.ClientId, this.maxConcurrentCallsSemaphoreSlim.CurrentCount);
+            MessagingEventSource.Log.MessageBatchReceiverPumpDispatchTaskStop(this.messageReceiver.ClientId, this.maxConcurrentCallsSemaphoreSlim.CurrentCount);
         }
 
         void CancelAutoRenewLock(object state)
@@ -232,7 +232,7 @@ async Task RenewMessageLockTask(IList<Message> messages, CancellationToken renew
                 try
                 {
                     var amount = MessagingUtilities.CalculateRenewAfterDuration(messages.Last().SystemProperties.LockedUntilUtc);
-                    MessagingEventSource.Log.BatchMessageReceiverPumpRenewMessageStart(this.messageReceiver.ClientId, amount);
+                    MessagingEventSource.Log.MessageBatchReceiverPumpRenewMessageStart(this.messageReceiver.ClientId, amount);
 
                     // We're awaiting the task created by 'ContinueWith' to avoid awaiting the Delay task which may be canceled
                     // by the renewLockCancellationToken. This way we prevent a TaskCanceledException.
@@ -248,7 +248,7 @@ async Task RenewMessageLockTask(IList<Message> messages, CancellationToken renew
                         !renewLockCancellationToken.IsCancellationRequested)
                     {
                         await this.messageReceiver.RenewLocksAsync(messages).ConfigureAwait(false);
-                        MessagingEventSource.Log.BatchMessageReceiverPumpRenewMessageStop(this.messageReceiver.ClientId);
+                        MessagingEventSource.Log.MessageBatchReceiverPumpRenewMessageStop(this.messageReceiver.ClientId);
                     }
                     else
                     {