Did some code style and small func fixes

Author: antonyvorontsov

README.md

@@ -4,7 +4,7 @@
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/f688764d2ba340099ec50b74726e25fd)](https://app.codacy.com/app/AntonyVorontsov/RabbitMQ.Client.Core.DependencyInjection?utm_source=github.com&utm_medium=referral&utm_content=AntonyVorontsov/RabbitMQ.Client.Core.DependencyInjection&utm_campaign=Badge_Grade_Dashboard)<br/>
 Wrapper-library of RabbitMQ.Client with Dependency Injection infrastructure under the .Net Core 2.2 platform.
 
-### Producer
+## Producer
 
 First of all you have to add all service dependencies in the `ConfigureServices` method. `AddRabbitMqClient` adds `IQueueService` that can send messages and `AddExchange` configures and adds an exchange. You can add multiple exchanges but the queue service will be single (and it will be added as singleton obviously).
 
@@ -75,7 +75,7 @@ queueService.Send(
 In order to make this possible, a default dead-letter-exchange with `"default.dlx.exchange"` name will be created. You can change it via main exchange configuration (example is down below).
 And also you have a default functionality of resending failed messages (if you get an error while processing recieved message).
 
-### Consumer
+## Consumer
 
 Lets imagine that you wanna make a consumer as a console application. Then code will look like this:
 
@@ -205,12 +205,12 @@ services.AddRabbitMqClient(rabbitMqSection)
 
 You can find example projects in the repository too.
 
-### appsettings.json configuration
+## appsettings.json configuration
 
  You have to add a couple configuration sections: (1) settings to connect to the RabbitMQ server and (2) a section that configures an exchange (one section per exchange frankly speaking).
  Exchange sections define how to bind queues and exchanges with each ohter and which routing keys to use for that.
  You can bind a queue to an exchange with more than one routing key, but if there are no routing keys in the queue section, then that queue will be bound to the exchange with its name.
-```
+```json
 {
   "RabbitMq": {
     "HostName": "127.0.0.1",
@@ -235,7 +235,7 @@ You can find example projects in the repository too.
 ```
 
 `Type`, `Durable`, `AutoDelete`, `DeadLetterExchange`, `RequeueFailedMessages` are set with default values in this example. So you can change it or leave it like this:
-```
+```json
 {
   "RabbitMq": {
     "HostName": "127.0.0.1",

src/Examples.ConsumerConsole/CustomAsyncMessageHandler.cs

@@ -8,12 +8,14 @@ public class CustomAsyncMessageHandler : IAsyncMessageHandler
     {
         readonly ILogger<CustomAsyncMessageHandler> _logger;
 
-        public CustomAsyncMessageHandler(ILogger<CustomAsyncMessageHandler> logger) =>
+        public CustomAsyncMessageHandler(ILogger<CustomAsyncMessageHandler> logger)
+        {
             _logger = logger;
+        }
 
         public async Task Handle(string message, string routingKey)
         {
-            await Task.Run(() => _logger.LogInformation("A weird example of runnig something async."));
+            await Task.Run(() => _logger.LogInformation("A weird example of runnig something async.")).ConfigureAwait(false);
         }
     }
 }

src/Examples.ConsumerConsole/CustomAsyncNonCyclicMessageHandler.cs

@@ -8,8 +8,10 @@ public class CustomAsyncNonCyclicMessageHandler : IAsyncNonCyclicMessageHandler
     {
         readonly ILogger<CustomAsyncNonCyclicMessageHandler> _logger;
 
-        public CustomAsyncNonCyclicMessageHandler(ILogger<CustomAsyncNonCyclicMessageHandler> logger) =>
+        public CustomAsyncNonCyclicMessageHandler(ILogger<CustomAsyncNonCyclicMessageHandler> logger)
+        {
             _logger = logger;
+        }
 
         public async Task Handle(string message, string routingKey, IQueueService queueService)
         {

src/Examples.ConsumerHost/CustomMessageHandler.cs

@@ -6,8 +6,10 @@ namespace Examples.ConsumerHost
     public class CustomMessageHandler : IMessageHandler
     {
         readonly ILogger<CustomMessageHandler> _logger;
-        public CustomMessageHandler(ILogger<CustomMessageHandler> logger) =>
+        public CustomMessageHandler(ILogger<CustomMessageHandler> logger)
+        {
             _logger = logger;
+        }
 
         public void Handle(string message, string routingKey)
         {

src/Examples.Producer/Program.cs

@@ -6,7 +6,7 @@
 
 namespace Examples.Producer
 {
-    public class Program
+    public static class Program
     {
         public static IConfiguration Configuration { get; set; }
 

src/RabbitMQ.Client.Core.DependencyInjection/Configuration/RabbitMqExchangeOptions.cs

@@ -20,7 +20,7 @@ public class RabbitMqExchangeOptions
         /// <summary>
         /// AutoDelete option.
         /// </summary>
-        public bool AutoDelete { get; set; } = false;
+        public bool AutoDelete { get; set; }
 
         /// <summary>
         /// Default dead-letter-exchange.

src/RabbitMQ.Client.Core.DependencyInjection/QueueService.cs

@@ -28,7 +28,7 @@ internal class QueueService : IQueueService
         public IModel Channel => _channel;
 
         EventHandler<BasicDeliverEventArgs> _receivedMessage;
-        bool _consumingStarted = false;
+        bool _consumingStarted;
 
         readonly IDictionary<string, IList<IMessageHandler>> _messageHandlers;
         readonly IDictionary<string, IList<IAsyncMessageHandler>> _asyncMessageHandlers;
@@ -128,8 +128,12 @@ public void StartConsuming()
             _consumingStarted = true;
 
             foreach (var exchange in _exchanges)
+            {
                 foreach (var queue in exchange.Options.Queues)
+                {
                     _channel.BasicConsume(queue: queue.Name, autoAck: false, consumer: _consumer);
+                }
+            }
         }
 
         public void Send<T>(T @object, string exchangeName, string routingKey) where T : class
@@ -201,28 +205,28 @@ public void Send(byte[] bytes, IBasicProperties properties, string exchangeName,
         }
 
         public async Task SendAsync<T>(T @object, string exchangeName, string routingKey) where T : class =>
-            await Task.Run(() => Send(@object, exchangeName, routingKey));
+            await Task.Run(() => Send(@object, exchangeName, routingKey)).ConfigureAwait(false);
 
         public async Task SendAsync<T>(T @object, string exchangeName, string routingKey, int secondsDelay) where T : class =>
-            await Task.Run(() => Send(@object, exchangeName, routingKey, secondsDelay));
+            await Task.Run(() => Send(@object, exchangeName, routingKey, secondsDelay)).ConfigureAwait(false);
 
         public async Task SendJsonAsync(string json, string exchangeName, string routingKey) =>
-            await Task.Run(() => SendJson(json, exchangeName, routingKey));
+            await Task.Run(() => SendJson(json, exchangeName, routingKey)).ConfigureAwait(false);
 
         public async Task SendJsonAsync(string json, string exchangeName, string routingKey, int secondsDelay) =>
-            await Task.Run(() => SendJson(json, exchangeName, routingKey, secondsDelay));
+            await Task.Run(() => SendJson(json, exchangeName, routingKey, secondsDelay)).ConfigureAwait(false);
 
         public async Task SendStringAsync(string message, string exchangeName, string routingKey) =>
-            await Task.Run(() => SendString(message, exchangeName, routingKey));
+            await Task.Run(() => SendString(message, exchangeName, routingKey)).ConfigureAwait(false);
 
         public async Task SendStringAsync(string message, string exchangeName, string routingKey, int secondsDelay) =>
-            await Task.Run(() => SendString(message, exchangeName, routingKey, secondsDelay));
+            await Task.Run(() => SendString(message, exchangeName, routingKey, secondsDelay)).ConfigureAwait(false);
 
         public async Task SendAsync(byte[] bytes, IBasicProperties properties, string exchangeName, string routingKey) =>
-            await Task.Run(() => Send(bytes, properties, exchangeName, routingKey));
+            await Task.Run(() => Send(bytes, properties, exchangeName, routingKey)).ConfigureAwait(false);
 
         public async Task SendAsync(byte[] bytes, IBasicProperties properties, string exchangeName, string routingKey, int secondsDelay) =>
-            await Task.Run(() => Send(bytes, properties, exchangeName, routingKey, secondsDelay));
+            await Task.Run(() => Send(bytes, properties, exchangeName, routingKey, secondsDelay)).ConfigureAwait(false);
 
         IBasicProperties CreateProperties()
         {
@@ -261,13 +265,15 @@ void HandleChannelBasicRecoverOk(object sender, EventArgs @event)
         {
             if (@event is null)
                 return;
+
             _logger.LogInformation("Connection has been reestablished.");
         }
 
         void HandleChannelCallbackException(object sender, CallbackExceptionEventArgs @event)
         {
             if (@event is null)
                 return;
+
             _logger.LogError(new EventId(), @event.Exception, @event.Exception.Message, @event);
         }
 
@@ -277,9 +283,13 @@ IDictionary<Type, List<string>> TransformMessageHandlerRouters(IEnumerable<Messa
             foreach (var router in routers)
             {
                 if (dictionary.ContainsKey(router.Type))
+                {
                     dictionary[router.Type] = dictionary[router.Type].Union(router.RoutingKeys).ToList();
+                }
                 else
+                {
                     dictionary.Add(router.Type, router.RoutingKeys);
+                }
             }
             return dictionary;
         }
@@ -295,10 +305,14 @@ IDictionary<string, IList<T>> TransformMessageHandlersCollection<T>(IEnumerable<
                     if (dictionary.ContainsKey(routingKey))
                     {
                         if (!dictionary[routingKey].Any(x => x.GetType() == handler.GetType()))
+                        {
                             dictionary[routingKey].Add(handler);
+                        }
                     }
                     else
+                    {
                         dictionary.Add(routingKey, new List<T>() { handler });
+                    }
                 }
             }
             return dictionary;
@@ -319,7 +333,9 @@ void StartClient()
                     {
                         var tasks = new List<Task>();
                         foreach (var handler in _asyncMessageHandlers[@event.RoutingKey])
+                        {
                             tasks.Add(RunAsyncHandler(handler, message, @event.RoutingKey));
+                        }
                         Task.WaitAll(tasks.ToArray());
                     }
                     if (_messageHandlers.ContainsKey(@event.RoutingKey))
@@ -335,7 +351,9 @@ void StartClient()
                     {
                         var tasks = new List<Task>();
                         foreach (var handler in _asyncNonCyclicHandlers[@event.RoutingKey])
+                        {
                             tasks.Add(RunAsyncNonCyclicHandler(handler, message, @event.RoutingKey));
+                        }
                         Task.WaitAll(tasks.ToArray());
                     }
                     if (_nonCyclicHandlers.ContainsKey(@event.RoutingKey))
@@ -385,10 +403,14 @@ void StartClient()
                 .Distinct();
 
             foreach (var exchangeName in deadLetterExchanges)
+            {
                 StartDeadLetterExchange(exchangeName);
+            }
 
             foreach (var exchange in _exchanges)
+            {
                 StartExchange(exchange);
+            }
         }
 
         async Task RunAsyncHandler(IAsyncMessageHandler handler, string message, string routingKey)
@@ -423,7 +445,9 @@ void StartExchange(RabbitMqExchange exchange)
                 arguments: exchange.Options.Arguments);
 
             foreach (var queue in exchange.Options.Queues)
+            {
                 StartQueue(queue, exchange.Name);
+            }
         }
 
         void StartQueue(RabbitMqQueueOptions queue, string exchangeName)
@@ -460,8 +484,7 @@ void ValidateArguments(string exchangeName, string routingKey)
                 throw new ArgumentException($"Argument {nameof(routingKey)} is null or empty.", nameof(routingKey));
 
             var deadLetterExchanges = _exchanges.Select(x => x.Options.DeadLetterExchange).Distinct();
-            if (!_exchanges.Any(x => x.Name == exchangeName)
-                && !deadLetterExchanges.Any(x => x == exchangeName))
+            if (!_exchanges.Any(x => x.Name == exchangeName) && !deadLetterExchanges.Any(x => x == exchangeName))
                 throw new ArgumentException($"Exchange {nameof(exchangeName)} has not been deaclared yet.", nameof(exchangeName));
         }
 
@@ -470,6 +493,7 @@ string GetDeadLetterExchange(string exchangeName)
             var exchange = _exchanges.FirstOrDefault(x => x.Name == exchangeName);
             if (string.IsNullOrEmpty(exchange.Options.DeadLetterExchange))
                 throw new ArgumentException($"Exchange {nameof(exchangeName)} has not been configured with a dead letter exchange.", nameof(exchangeName));
+
             return exchange.Options.DeadLetterExchange;
         }
 
@@ -492,7 +516,7 @@ string DeclareDelayedQueue(string exchange, string deadLetterExchange, string ro
             return delayedQueueName;
         }
 
-        Dictionary<string, object> CreateArguments(string exchangeName, string routingKey, int secondsDelay) =>
+        static Dictionary<string, object> CreateArguments(string exchangeName, string routingKey, int secondsDelay) =>
             new Dictionary<string, object>
             {
                 { "x-dead-letter-exchange", exchangeName },