Made message handlers consume BasicDeliverEventArgs instead of raw string messages.

Anton Vorontsov · Anton Vorontsov · commit bc8dc092bd6f · 2020-10-01T04:09:20.000+03:00
diff --git a/docs/advanced-usage.md b/docs/advanced-usage.md
@@ -11,7 +11,7 @@ Let' say your application is a web API and you want to use both `IConsumingServi
 ```c#
 public class Startup
 {
-    private IConfiguration Configuration { get; }
+    IConfiguration Configuration { get; }
 
     public Startup(IConfiguration configuration)
     {
diff --git a/docs/message-consumption.md b/docs/message-consumption.md
@@ -91,7 +91,7 @@ public class Program
 
 public class Worker : BackgroundService
 {
-    private readonly IQueueService _queueService;
+    readonly IQueueService _queueService;
 
     public Worker(IQueueService queueService)
     {
diff --git a/docs/message-production.md b/docs/message-production.md
@@ -10,7 +10,7 @@ It can be a custom service or a controller.
 [Route("api/[controller]")]
 public class HomeController : Controller
 {
-    private readonly IQueueService _queueService;
+    readonly IQueueService _queueService;
     public HomeController(IQueueService queueService)
     {
         _queueService = queueService;
diff --git a/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomAsyncMessageHandler.cs b/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomAsyncMessageHandler.cs
@@ -1,11 +1,12 @@
 using System.Threading.Tasks;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
+using RabbitMQ.Client.Events;
 
 namespace Examples.AdvancedConfiguration.MessageHandlers
 {
     public class CustomAsyncMessageHandler : IAsyncMessageHandler
     {
-        public async Task Handle(string message, string routingKey)
+        public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)
         {
             // The message handler does not do anything.
             // It is just an example.
diff --git a/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomAsyncNonCyclicMessageHandler.cs b/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomAsyncNonCyclicMessageHandler.cs
@@ -1,12 +1,13 @@
 using System.Threading.Tasks;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
+using RabbitMQ.Client.Events;
 
 namespace Examples.AdvancedConfiguration.MessageHandlers
 {
     public class CustomAsyncNonCyclicMessageHandler : IAsyncNonCyclicMessageHandler
     {
-        public async Task Handle(string message, string routingKey, IQueueService queueService)
+        public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)
         {
             // The message handler does not do anything.
             // It is just an example.
diff --git a/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomMessageHandler.cs b/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomMessageHandler.cs
@@ -1,10 +1,11 @@
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
+using RabbitMQ.Client.Events;
 
 namespace Examples.AdvancedConfiguration.MessageHandlers
 {
     public class CustomMessageHandler : IMessageHandler
     {
-        public void Handle(string message, string routingKey)
+        public void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)
         {
             // The message handler does not do anything.
             // It is just an example.
diff --git a/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomNonCyclicMessageHandler.cs b/examples/Examples.AdvancedConfiguration/MessageHandlers/CustomNonCyclicMessageHandler.cs
@@ -1,11 +1,12 @@
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
+using RabbitMQ.Client.Events;
 
 namespace Examples.AdvancedConfiguration.MessageHandlers
 {
     public class CustomNonCyclicMessageHandler : INonCyclicMessageHandler
     {
-        public void Handle(string message, string routingKey, IQueueService queueService)
+        public void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)
         {
             // The message handler does not do anything.
             // It is just an example.
diff --git a/examples/Examples.AdvancedConfiguration/Startup.cs b/examples/Examples.AdvancedConfiguration/Startup.cs
@@ -9,7 +9,7 @@ namespace Examples.AdvancedConfiguration
 {
     public class Startup
     {
-        private IConfiguration Configuration { get; }
+        IConfiguration Configuration { get; }
 
         public Startup(IConfiguration configuration)
         {
diff --git a/examples/Examples.ConsumerConsole/CustomAsyncMessageHandler.cs b/examples/Examples.ConsumerConsole/CustomAsyncMessageHandler.cs
@@ -1,6 +1,8 @@
 ﻿using Microsoft.Extensions.Logging;
 using System.Threading.Tasks;
+using RabbitMQ.Client.Core.DependencyInjection;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
+using RabbitMQ.Client.Events;
 
 namespace Examples.ConsumerConsole
 {
@@ -13,9 +15,9 @@ public CustomAsyncMessageHandler(ILogger<CustomAsyncMessageHandler> logger)
             _logger = logger;
         }
 
-        public async Task Handle(string message, string routingKey)
+        public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)
         {
-            _logger.LogInformation($"A weird example of running something async with message {message} that has been received by {routingKey}.");
+            _logger.LogInformation($"A weird example of running something async with message {eventArgs.GetMessage()} that has been received by {matchingRoute}.");
             await Task.CompletedTask.ConfigureAwait(false);
         }
     }
diff --git a/examples/Examples.ConsumerConsole/CustomAsyncNonCyclicMessageHandler.cs b/examples/Examples.ConsumerConsole/CustomAsyncNonCyclicMessageHandler.cs
@@ -1,7 +1,9 @@
 ﻿using Microsoft.Extensions.Logging;
 using System.Threading.Tasks;
+using RabbitMQ.Client.Core.DependencyInjection;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
+using RabbitMQ.Client.Events;
 
 namespace Examples.ConsumerConsole
 {
@@ -14,11 +16,13 @@ public CustomAsyncNonCyclicMessageHandler(ILogger<CustomAsyncNonCyclicMessageHan
             _logger = logger;
         }
 
-        public async Task Handle(string message, string routingKey, IQueueService queueService)
+        public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)
         {
-            _logger.LogInformation("A weird example of running something async.");
-            var response = new { message, routingKey };
-            await queueService.SendAsync(response, "exchange.name", "routing.key");
+            _logger.LogInformation($"A weird example of running something async. Message has been received by routing key {matchingRoute}");
+            var response = eventArgs.GetPayload<Message>();
+            const string routingKey = "another.routing.key";
+            _logger.LogInformation($"Sending the same message to {routingKey}.");
+            await queueService.SendAsync(response, "exchange.name", routingKey);
         }
     }
 }
diff --git a/examples/Examples.ConsumerConsole/Message.cs b/examples/Examples.ConsumerConsole/Message.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace Examples.ConsumerConsole
+{
+    public class Message
+    {
+        public string Name { get; set; }
+
+        public bool Flag { get; set; }
+
+        public int Index { get; set; }
+
+        public IEnumerable<int> Numbers { get; set; }
+    }
+}
diff --git a/examples/Examples.ConsumerHost/CustomMessageHandler.cs b/examples/Examples.ConsumerHost/CustomMessageHandler.cs
@@ -1,5 +1,7 @@
 ﻿using Microsoft.Extensions.Logging;
+using RabbitMQ.Client.Core.DependencyInjection;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
+using RabbitMQ.Client.Events;
 
 namespace Examples.ConsumerHost
 {
@@ -11,9 +13,9 @@ public CustomMessageHandler(ILogger<CustomMessageHandler> logger)
             _logger = logger;
         }
 
-        public void Handle(string message, string routingKey)
+        public void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)
         {
-            _logger.LogInformation($"Handling message {message} by routing key {routingKey}");
+            _logger.LogInformation($"Handling message {eventArgs.GetMessage()} by routing key {matchingRoute}");
         }
     }
 }
diff --git a/examples/Examples.ConsumerHost/CustomNonCyclicMessageHandler.cs b/examples/Examples.ConsumerHost/CustomNonCyclicMessageHandler.cs
@@ -1,6 +1,8 @@
 ﻿using Microsoft.Extensions.Logging;
+using RabbitMQ.Client.Core.DependencyInjection;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
+using RabbitMQ.Client.Events;
 
 namespace Examples.ConsumerHost
 {
@@ -12,10 +14,10 @@ public CustomNonCyclicMessageHandler(ILogger<CustomNonCyclicMessageHandler> logg
             _logger = logger;
         }
 
-        public void Handle(string message, string routingKey, IQueueService queueService)
+        public void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)
         {
             _logger.LogInformation("Handling messages");
-            var response = new { message, routingKey };
+            var response = new { message = eventArgs.GetMessage(), matchingRoute };
             queueService.Send(response, "exchange.name", "routing.key");
         }
     }
diff --git a/readme.md b/readme.md
@@ -35,7 +35,7 @@ Now you can inject an instance of `IQueueService` inside anything you want.
 [Route("api/[controller]")]
 public class HomeController : Controller
 {
-    private readonly IQueueService _queueService;
+    readonly IQueueService _queueService;
     public HomeController(IQueueService queueService)
     {
         _queueService = queueService;
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/BasicDeliverEventArgsExtensions.cs b/src/RabbitMQ.Client.Core.DependencyInjection/BasicDeliverEventArgsExtensions.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json;
+using RabbitMQ.Client.Events;
+
+namespace RabbitMQ.Client.Core.DependencyInjection
+{
+    /// <summary>
+    /// BasicDeliverEventArgsExtensions extension that help to work with messages,
+    /// </summary>
+    public static class BasicDeliverEventArgsExtensions
+    {
+        /// <summary>
+        /// Get message from BasicDeliverEventArgs body.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <returns>Message as a string.</returns>
+        public static string GetMessage(this BasicDeliverEventArgs eventArgs)
+        {
+            eventArgs.EnsureIsNotNull();
+            return Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+        }
+
+        /// <summary>
+        /// Get message payload.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <typeparam name="T">Type of a message body.</typeparam>
+        /// <returns>Object of type <see cref="T"/>.</returns>
+        public static T GetPayload<T>(this BasicDeliverEventArgs eventArgs)
+        {
+            eventArgs.EnsureIsNotNull();
+            var messageString = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+            return JsonConvert.DeserializeObject<T>(messageString);
+        }
+        
+        /// <summary>
+        /// Get message payload.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="settings">Serializer settings <see cref="JsonSerializerSettings"/>.</param>
+        /// <typeparam name="T">Type of a message body.</typeparam>
+        /// <returns>Object of type <see cref="T"/>.</returns>
+        public static T GetPayload<T>(this BasicDeliverEventArgs eventArgs, JsonSerializerSettings settings)
+        {
+            eventArgs.EnsureIsNotNull();
+            var messageString = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+            return JsonConvert.DeserializeObject<T>(messageString, settings);
+        }
+        
+        /// <summary>
+        /// Get message payload.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="converters">A collection of json converters <see cref="JsonConverter"/>.</param>
+        /// <typeparam name="T">Type of a message body.</typeparam>
+        /// <returns>Object of type <see cref="T"/>.</returns>
+        public static T GetPayload<T>(this BasicDeliverEventArgs eventArgs, IEnumerable<JsonConverter> converters)
+        {
+            eventArgs.EnsureIsNotNull();
+            var messageString = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+            return JsonConvert.DeserializeObject<T>(messageString, converters.ToArray());
+        }
+        
+        /// <summary>
+        /// Get message payload as an anonymous object.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="anonymousTypeObject">An anonymous object base.</param>
+        /// <typeparam name="T">Type of an anonymous object.</typeparam>
+        /// <returns>Anonymous object.</returns>
+        public static T GetAnonymousPayload<T>(this BasicDeliverEventArgs eventArgs, T anonymousTypeObject)
+        {
+            eventArgs.EnsureIsNotNull();
+            var messageString = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+            return JsonConvert.DeserializeAnonymousType<T>(messageString, anonymousTypeObject);
+        }
+        
+        /// <summary>
+        /// Get message payload as an anonymous object.
+        /// </summary>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="anonymousTypeObject">An anonymous object base.</param>
+        /// <param name="settings">Serializer settings <see cref="JsonSerializerSettings"/>.</param>
+        /// <typeparam name="T">Type of an anonymous object.</typeparam>
+        /// <returns>Anonymous object.</returns>
+        public static T GetAnonymousPayload<T>(this BasicDeliverEventArgs eventArgs, T anonymousTypeObject, JsonSerializerSettings settings)
+        {
+            eventArgs.EnsureIsNotNull();
+            var messageString = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
+            return JsonConvert.DeserializeAnonymousType<T>(messageString, anonymousTypeObject, settings);
+        }
+        
+        static void EnsureIsNotNull(this BasicDeliverEventArgs eventArgs)
+        {
+            if (eventArgs is null)
+            {
+                throw new ArgumentNullException(nameof(eventArgs), "BasicDeliverEventArgs have to be not null to parse a message");
+            }
+        }
+    }
+}
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/InternalExtensions/WildcardExtensions.cs b/src/RabbitMQ.Client.Core.DependencyInjection/InternalExtensions/WildcardExtensions.cs
@@ -1,7 +1,9 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using RabbitMQ.Client.Core.DependencyInjection.Models;
 
+[assembly:InternalsVisibleTo("RabbitMQ.Client.Core.DependencyInjection.Tests")]
 namespace RabbitMQ.Client.Core.DependencyInjection.InternalExtensions
 {
     /// <summary>
@@ -11,7 +13,7 @@ namespace RabbitMQ.Client.Core.DependencyInjection.InternalExtensions
     /// Methods of that class allows finding route patterns by which message handlers are "listening" for messages.
     /// Public access modifier set for this class due to unit testing.
     /// </remarks>
-    public static class WildcardExtensions
+    internal static class WildcardExtensions
     {
         const string Separator = ".";
         const string SingleWordPattern = "*";
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IAsyncMessageHandler.cs b/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IAsyncMessageHandler.cs
@@ -1,4 +1,5 @@
 ﻿using System.Threading.Tasks;
+using RabbitMQ.Client.Events;
 
 namespace RabbitMQ.Client.Core.DependencyInjection.MessageHandlers
 {
@@ -10,8 +11,8 @@ public interface IAsyncMessageHandler : IBaseMessageHandler
         /// <summary>
         /// Handle message from a queue.
         /// </summary>
-        /// <param name="message">Json message.</param>
-        /// <param name="routingKey">Routing key.</param>
-        Task Handle(string message, string routingKey);
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="matchingRoute">Matching routing key.</param>
+        Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute);
     }
 }
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IAsyncNonCyclicMessageHandler.cs b/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IAsyncNonCyclicMessageHandler.cs
@@ -1,5 +1,6 @@
 ﻿using System.Threading.Tasks;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
+using RabbitMQ.Client.Events;
 
 namespace RabbitMQ.Client.Core.DependencyInjection.MessageHandlers
 {
@@ -11,9 +12,9 @@ public interface IAsyncNonCyclicMessageHandler : IBaseMessageHandler
         /// <summary>
         /// Handle message from a queue.
         /// </summary>
-        /// <param name="message">Json message.</param>
-        /// <param name="routingKey">Routing key.</param>
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="matchingRoute">Matching routing key.</param>
         /// <param name="queueService">Instance of service <see cref="IQueueService"/> that can send messages.</param>
-        Task Handle(string message, string routingKey, IQueueService queueService);
+        Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService);
     }
 }
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IMessageHandler.cs b/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/IMessageHandler.cs
@@ -1,4 +1,6 @@
-﻿namespace RabbitMQ.Client.Core.DependencyInjection.MessageHandlers
+﻿using RabbitMQ.Client.Events;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.MessageHandlers
 {
     /// <summary>
     /// Interface of message handler.
@@ -8,8 +10,8 @@ public interface IMessageHandler : IBaseMessageHandler
         /// <summary>
         /// Handle message from a queue.
         /// </summary>
-        /// <param name="message">Json message.</param>
-        /// <param name="routingKey">Routing key.</param>
-        void Handle(string message, string routingKey);
+        /// <param name="eventArgs">Message event args.</param>
+        /// <param name="matchingRoute">Matching routing key.</param>
+        void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute);
     }
 }
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/INonCyclicMessageHandler.cs b/src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlers/INonCyclicMessageHandler.cs
diff --git a/src/RabbitMQ.Client.Core.DependencyInjection/Services/MessageHandlingService.cs b/src/RabbitMQ.Client.Core.DependencyInjection/Services/MessageHandlingService.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncMessageHandler.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncMessageHandler.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncNonCyclicMessageHandler.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncNonCyclicMessageHandler.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubCaller.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubCaller.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubExceptionMessageHandler.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubExceptionMessageHandler.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubMessageHandler.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubMessageHandler.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubNonCyclicMessageHandler.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubNonCyclicMessageHandler.cs
diff --git a/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/MessageHandlingServiceTests.cs b/tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/MessageHandlingServiceTests.cs

Original file line number	Diff line number	Diff line change
@@ -11,7 +11,7 @@ Let' say your application is a web API and you want to use both `IConsumingServi
`11`	`11`	```c#
`12`	`12`	`public class Startup`
`13`	`13`	`{`
`14`		`- private IConfiguration Configuration { get; }`
	`14`	`+ IConfiguration Configuration { get; }`
`15`	`15`
`16`	`16`	`public Startup(IConfiguration configuration)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public class Program`
`91`	`91`
`92`	`92`	`public class Worker : BackgroundService`
`93`	`93`	`{`
`94`		`- private readonly IQueueService _queueService;`
	`94`	`+ readonly IQueueService _queueService;`
`95`	`95`
`96`	`96`	`public Worker(IQueueService queueService)`
`97`	`97`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ It can be a custom service or a controller.`
`10`	`10`	`[Route("api/[controller]")]`
`11`	`11`	`public class HomeController : Controller`
`12`	`12`	`{`
`13`		`- private readonly IQueueService _queueService;`
	`13`	`+ readonly IQueueService _queueService;`
`14`	`14`	`public HomeController(IQueueService queueService)`
`15`	`15`	`{`
`16`	`16`	`_queueService = queueService;`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`	`1`	`using System.Threading.Tasks;`
`2`	`2`	`using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;`
	`3`	`+using RabbitMQ.Client.Events;`
`3`	`4`
`4`	`5`	`namespace Examples.AdvancedConfiguration.MessageHandlers`
`5`	`6`	`{`
`6`	`7`	`public class CustomAsyncMessageHandler : IAsyncMessageHandler`
`7`	`8`	`{`
`8`		`- public async Task Handle(string message, string routingKey)`
	`9`	`+ public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)`
`9`	`10`	`{`
`10`	`11`	`// The message handler does not do anything.`
`11`	`12`	`// It is just an example.`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`	`1`	`using System.Threading.Tasks;`
`2`	`2`	`using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;`
`3`	`3`	`using RabbitMQ.Client.Core.DependencyInjection.Services;`
	`4`	`+using RabbitMQ.Client.Events;`
`4`	`5`
`5`	`6`	`namespace Examples.AdvancedConfiguration.MessageHandlers`
`6`	`7`	`{`
`7`	`8`	`public class CustomAsyncNonCyclicMessageHandler : IAsyncNonCyclicMessageHandler`
`8`	`9`	`{`
`9`		`- public async Task Handle(string message, string routingKey, IQueueService queueService)`
	`10`	`+ public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)`
`10`	`11`	`{`
`11`	`12`	`// The message handler does not do anything.`
`12`	`13`	`// It is just an example.`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`	`1`	`using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;`
	`2`	`+using RabbitMQ.Client.Events;`
`2`	`3`
`3`	`4`	`namespace Examples.AdvancedConfiguration.MessageHandlers`
`4`	`5`	`{`
`5`	`6`	`public class CustomMessageHandler : IMessageHandler`
`6`	`7`	`{`
`7`		`- public void Handle(string message, string routingKey)`
	`8`	`+ public void Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)`
`8`	`9`	`{`
`9`	`10`	`// The message handler does not do anything.`
`10`	`11`	`// It is just an example.`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Examples.AdvancedConfiguration`
`9`	`9`	`{`
`10`	`10`	`public class Startup`
`11`	`11`	`{`
`12`		`- private IConfiguration Configuration { get; }`
	`12`	`+ IConfiguration Configuration { get; }`
`13`	`13`
`14`	`14`	`public Startup(IConfiguration configuration)`
`15`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`using Microsoft.Extensions.Logging;`
`2`	`2`	`using System.Threading.Tasks;`
	`3`	`+using RabbitMQ.Client.Core.DependencyInjection;`
`3`	`4`	`using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;`
	`5`	`+using RabbitMQ.Client.Events;`
`4`	`6`
`5`	`7`	`namespace Examples.ConsumerConsole`
`6`	`8`	`{`
`@@ -13,9 +15,9 @@ public CustomAsyncMessageHandler(ILogger<CustomAsyncMessageHandler> logger)`
`13`	`15`	`_logger = logger;`
`14`	`16`	`}`
`15`	`17`
`16`		`- public async Task Handle(string message, string routingKey)`
	`18`	`+ public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)`
`17`	`19`	`{`
`18`		`- _logger.LogInformation($"A weird example of running something async with message {message} that has been received by {routingKey}.");`
	`20`	`+ _logger.LogInformation($"A weird example of running something async with message {eventArgs.GetMessage()} that has been received by {matchingRoute}.");`
`19`	`21`	`await Task.CompletedTask.ConfigureAwait(false);`
`20`	`22`	`}`
`21`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
`1`	`1`	`using Microsoft.Extensions.Logging;`
`2`	`2`	`using System.Threading.Tasks;`
	`3`	`+using RabbitMQ.Client.Core.DependencyInjection;`
`3`	`4`	`using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;`
`4`	`5`	`using RabbitMQ.Client.Core.DependencyInjection.Services;`
	`6`	`+using RabbitMQ.Client.Events;`
`5`	`7`
`6`	`8`	`namespace Examples.ConsumerConsole`
`7`	`9`	`{`
`@@ -14,11 +16,13 @@ public CustomAsyncNonCyclicMessageHandler(ILogger<CustomAsyncNonCyclicMessageHan`
`14`	`16`	`_logger = logger;`
`15`	`17`	`}`
`16`	`18`
`17`		`- public async Task Handle(string message, string routingKey, IQueueService queueService)`
	`19`	`+ public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute, IQueueService queueService)`
`18`	`20`	`{`
`19`		`- _logger.LogInformation("A weird example of running something async.");`
`20`		`- var response = new { message, routingKey };`
`21`		`- await queueService.SendAsync(response, "exchange.name", "routing.key");`
	`21`	`+ _logger.LogInformation($"A weird example of running something async. Message has been received by routing key {matchingRoute}");`
	`22`	`+ var response = eventArgs.GetPayload<Message>();`
	`23`	`+ const string routingKey = "another.routing.key";`
	`24`	`+ _logger.LogInformation($"Sending the same message to {routingKey}.");`
	`25`	`+ await queueService.SendAsync(response, "exchange.name", routingKey);`
`22`	`26`	`}`
`23`	`27`	`}`
`24`	`28`	`}`