Added changelog and readme changes.

Author: Anton Vorontsov

docs/changelog.md

@@ -2,6 +2,19 @@
 
 All notable changes to this library will be documented in this file.
 
+## [4.0.0] - 2020-05-05
+
+### Added
+
+- `BaseBatchMessageHandler` and `BatchMessageHandler` for handling messages in batches via prefetch count feature.
+- Example of basic usages of batch message handlers.
+
+### Updated
+
+- Updated RabbitMQ.Client to the newest version 6.0.0. Made some changes according to the breaking changes that come with the newest version of RabbitMQ.Client.
+- Moved message handlers to the different namespace `RabbitMQ.Client.Core.DependencyInjection.MessageHandlers`.
+- Moved internal DI extensions to the different namespace `RabbitMQ.Client.Core.DependencyInjection.InternalExtensions`.
+
 ## [3.2.1] - 2020-03-29
 
 ### Fixed

docs/message-consumption.md

@@ -311,6 +311,84 @@ The message handling process is organized as follows:
 - If any exception occurs `IMessageHandlingService` acknowledges the message anyway and checks if the message has to be re-send. If exchange option `RequeueFailedMessages` is set `true` then `IMessageHandlingService` adds a header `"requeued"` to the message and sends it again with delay in 60 seconds. Mechanism of sending delayed messages covered in the message production [documentation](message-production.md).
 - If any exception occurs within handling the message that has been already re-sent that message will not be re-send again (re-send happens only once).
 
+### Batch message handlers
+
+There are also a feature that you can use in case of necessity of handling messages in batches.
+First of all you have to create a class that inherits a `BatchMessageHandler` class.
+You have to set up values for `QueueName` and `PrefetchCount` properties. These values are responsible for the queue that will be read by the message handler, and the size of batches of messages.
+
+```c#
+public class CustomBatchMessageHandler : BatchMessageHandler
+{
+    readonly ILogger<CustomBatchMessageHandler> _logger;
+    
+    public CustomBatchMessageHandler(
+        IEnumerable<BatchConsumerConnectionOptions> batchConsumerConnectionOptions,
+        ILogger<CustomBatchMessageHandler> logger)
+        : base(batchConsumerConnectionOptions, logger)
+    {
+        _logger = logger;
+    }
+
+    protected override ushort PrefetchCount { get; set; } = 50;
+    
+    protected override string QueueName { get; set; } = "another.queue.name";
+    
+    protected override Task HandleMessage(IEnumerable<string> messages, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Handling a batch of messages.");
+        foreach (var message in messages)
+        {
+            _logger.LogInformation(message);
+        }
+        return Task.CompletedTask;
+    }
+}
+```
+
+If you want to get raw messages as `ReadOnlyMemory<byte>` you can inherit base message handler class.
+
+```c#
+public class CustomBatchMessageHandler : BaseBatchMessageHandler
+{
+    readonly ILogger<CustomBatchMessageHandler> _logger;
+    
+    public CustomBatchMessageHandler(
+        IEnumerable<BatchConsumerConnectionOptions> batchConsumerConnectionOptions,
+        ILogger<CustomBatchMessageHandler> logger)
+        : base(batchConsumerConnectionOptions, logger)
+    {
+        _logger = logger;
+    }
+    
+    protected override ushort PrefetchCount { get; set; } = 3;
+
+    protected override string QueueName { get; set; } = "queue.name";
+    
+    protected override Task HandleMessages(IEnumerable<ReadOnlyMemory<byte>> messages, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Handling a batch of messages.");
+        foreach (var message in messages)
+        {
+            var stringifiedMessage = Encoding.UTF8.GetString(message.ToArray());
+            _logger.LogInformation(stringifiedMessage);
+        }
+        return Task.CompletedTask;
+    }
+}
+```
+
+After all you have to register that batch message handler via DI.
+```c#
+services.AddBatchMessageHandler<CustomBatchMessageHandler>(Configuration.GetSection("RabbitMq"));
+```
+
+The message handler will create a separate connection and use it for reading messages.
+When the message collection is full to the size of `PrefetchCount` they are passed to the `HandleMessage` method.
+Both `BaseBatchMessageHandler` and `BatchMessageHandler` implement `IDisposable` interface, so you can use it for release of resources.
+
+Use this method of getting messages only when you sure that the number of messages that pass through this queue is really huge. Otherwise, messages could stack in the temporary collection of messages waiting to get in full.
+
 For message production features see the [Previous page](message-production.md)
 
 For more information about advanced usage of the RabbitMQ client see the [Next page](advanced-usage.md)

readme.md

@@ -237,6 +237,49 @@ Exchange sections define how to bind queues and exchanges with each other using
 
 For more information about `appsettings.json` and manual configuration features, see [rabbit-configuration](./docs/rabbit-configuration.md) and [exchange-configuration](./docs/exchange-configuration.md) documentation files.
 
+## Batch message handlers
+
+There are also a feature that you can use in case of necessity of handling messages in batches.
+First of all you have to create a class that inherits a `BatchMessageHandler` class.
+You have to set up values for `QueueName` and `PrefetchCount` properties. These values are responsible for the queue that will be read by the message handler, and the size of batches of messages.
+
+```c#
+public class CustomBatchMessageHandler : BatchMessageHandler
+{
+    readonly ILogger<CustomBatchMessageHandler> _logger;
+    
+    public CustomBatchMessageHandler(
+        IEnumerable<BatchConsumerConnectionOptions> batchConsumerConnectionOptions,
+        ILogger<CustomBatchMessageHandler> logger)
+        : base(batchConsumerConnectionOptions, logger)
+    {
+        _logger = logger;
+    }
+
+    protected override ushort PrefetchCount { get; set; } = 50;
+    
+    protected override string QueueName { get; set; } = "another.queue.name";
+    
+    protected override Task HandleMessage(IEnumerable<string> messages, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Handling a batch of messages.");
+        foreach (var message in messages)
+        {
+            _logger.LogInformation(message);
+        }
+        return Task.CompletedTask;
+    }
+}
+```
+
+After all you have to register that batch message handler via DI.
+```c#
+services.AddBatchMessageHandler<CustomBatchMessageHandler>(Configuration.GetSection("RabbitMq"));
+```
+
+The message handler will create a separate connection and use it for reading messages.
+When the message collection is full to the size of `PrefetchCount` they are passed to the `HandleMessage` method. For more information, see the [message-consuming](./docs/message-consumption.md) documentation file.
+
 ## Advanced usage and nuances
 
 RabbitMQ client implemented in this library (class which implements `IQueueService`) opens two connections to the RabbitMQ server. One connection is used for message production and the other one is for message consumption.

src/RabbitMQ.Client.Core.DependencyInjection/BatchMessageHandlers/BaseBatchMessageHandler.cs

@@ -80,7 +80,7 @@ public Task StartAsync(CancellationToken cancellationToken)
                 }
 
                 var byteMessages = messages.Select(x => x.Body).ToList();
-                await HandleMessages(byteMessages, cancellationToken);
+                await HandleMessages(byteMessages, cancellationToken).ConfigureAwait(false);
                 var latestDeliveryTag = messages.Max(x => x.DeliveryTag);
                 messages.Clear();
                 Channel.BasicAck(latestDeliveryTag, true);
@@ -115,11 +115,17 @@ public Task StopAsync(CancellationToken cancellationToken)
             _logger.LogInformation($"Batch message handler {GetType()} has been stopped.");
             return Task.CompletedTask;
         }
-
-        public void Dispose()
+        
+        protected virtual void Dispose(bool disposing)
         {
             Connection?.Dispose();
             Channel?.Dispose();
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
     }
 }

src/RabbitMQ.Client.Core.DependencyInjection/BatchMessageHandlers/BatchMessageHandler.cs

@@ -30,7 +30,7 @@ protected BatchMessageHandler(
         protected override async Task HandleMessages(IEnumerable<ReadOnlyMemory<byte>> messages, CancellationToken cancellationToken)
         {
             var decodedMessages = messages.Select(x => Encoding.UTF8.GetString(x.ToArray()));
-            await HandleMessage(decodedMessages, cancellationToken);
+            await HandleMessage(decodedMessages, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>