Housekeeping

src/Abc.Zebus/Dispatch/DynamicMessageHandlerInvoker.cs

@@ -30,10 +30,7 @@ namespace Abc.Zebus.Dispatch
         public Type MessageType { get; }
         public MessageTypeId MessageTypeId { get; }
 
-        public IEnumerable<Subscription> GetStartupSubscriptions()
-        {
-            return Enumerable.Empty<Subscription>();
-        }
+        public IEnumerable<Subscription> GetStartupSubscriptions() => Enumerable.Empty<Subscription>();
 
         public void InvokeMessageHandler(IMessageHandlerInvocation invocation)
         {
@@ -45,9 +42,7 @@ namespace Abc.Zebus.Dispatch
         }
 
         public Task InvokeMessageHandlerAsync(IMessageHandlerInvocation invocation)
-        {
-            throw new NotSupportedException("InvokeMessageHandlerAsync is not supported in Synchronous mode");
-        }
+            => throw new NotSupportedException("InvokeMessageHandlerAsync is not supported in Synchronous mode");
 
         public bool ShouldHandle(IMessage message)
         {
@@ -60,10 +55,7 @@ namespace Abc.Zebus.Dispatch
             return false;
         }
 
-        public bool CanMergeWith(IMessageHandlerInvoker other)
-        {
-            return false;
-        }
+        public bool CanMergeWith(IMessageHandlerInvoker other) => false;
 
         private class DummyHandler : IMessageHandler<IMessage>
         {

src/Abc.Zebus/Dispatch/MessageDispatcher.cs

@@ -13,14 +13,14 @@ namespace Abc.Zebus.Dispatch
 {
     public class MessageDispatcher : IMessageDispatcher, IProvideQueueLength
     {
-        private static readonly List<IMessageHandlerInvoker> _emptyInvokers = new List<IMessageHandlerInvoker>();
+        private static readonly List<IMessageHandlerInvoker> _emptyInvokers = new();
         private static readonly ILogger _logger = ZebusLogManager.GetLogger(typeof(MessageDispatcher));
 
-        private readonly ConcurrentDictionary<string, DispatchQueue> _dispatchQueues = new ConcurrentDictionary<string, DispatchQueue>(StringComparer.OrdinalIgnoreCase);
-        private readonly object _lock = new object();
+        private readonly ConcurrentDictionary<string, DispatchQueue> _dispatchQueues = new(StringComparer.OrdinalIgnoreCase);
+        private readonly object _lock = new();
         private readonly IMessageHandlerInvokerLoader[] _invokerLoaders;
         private readonly IDispatchQueueFactory _dispatchQueueFactory;
-        private ConcurrentDictionary<MessageTypeId, List<IMessageHandlerInvoker>> _invokers = new ConcurrentDictionary<MessageTypeId, List<IMessageHandlerInvoker>>();
+        private ConcurrentDictionary<MessageTypeId, List<IMessageHandlerInvoker>> _invokers = new();
         private Func<Assembly, bool>? _assemblyFilter;
         private Func<Type, bool>? _handlerFilter;
         private Func<Type, bool>? _messageFilter;
@@ -35,20 +35,11 @@ namespace Abc.Zebus.Dispatch
         public event Action? Starting;
         public event Action? Stopping;
 
-        public void ConfigureAssemblyFilter(Func<Assembly, bool> assemblyFilter)
-        {
-            _assemblyFilter = assemblyFilter;
-        }
+        public void ConfigureAssemblyFilter(Func<Assembly, bool> assemblyFilter) => _assemblyFilter = assemblyFilter;
 
-        public void ConfigureHandlerFilter(Func<Type, bool> handlerFilter)
-        {
-            _handlerFilter = handlerFilter;
-        }
+        public void ConfigureHandlerFilter(Func<Type, bool> handlerFilter) => _handlerFilter = handlerFilter;
 
-        public void ConfigureMessageFilter(Func<Type, bool> messageFilter)
-        {
-            _messageFilter = messageFilter;
-        }
+        public void ConfigureMessageFilter(Func<Type, bool> messageFilter) => _messageFilter = messageFilter;
 
         public event Action? MessageHandlerInvokersUpdated;
 
@@ -96,15 +87,9 @@ namespace Abc.Zebus.Dispatch
             }
         }
 
-        public IEnumerable<MessageTypeId> GetHandledMessageTypes()
-        {
-            return _invokers.Keys;
-        }
+        public IEnumerable<MessageTypeId> GetHandledMessageTypes() => _invokers.Keys;
 
-        public IEnumerable<IMessageHandlerInvoker> GetMessageHandlerInvokers()
-        {
-            return _invokers.SelectMany(x => x.Value);
-        }
+        public IEnumerable<IMessageHandlerInvoker> GetMessageHandlerInvokers() => _invokers.SelectMany(x => x.Value);
 
         public void Dispatch(MessageDispatch dispatch)
         {
@@ -261,15 +246,9 @@ namespace Abc.Zebus.Dispatch
             MessageHandlerInvokersUpdated?.Invoke();
         }
 
-        public int Purge()
-        {
-            return _dispatchQueues.Values.Sum(x => x.Purge());
-        }
+        public int Purge() => _dispatchQueues.Values.Sum(x => x.Purge());
 
-        public int GetReceiveQueueLength()
-        {
-            return _dispatchQueues.Values.Sum(x => x.QueueLength);
-        }
+        public int GetReceiveQueueLength() => _dispatchQueues.Values.Sum(x => x.QueueLength);
 
         private TypeSource CreateTypeSource()
         {

src/Abc.Zebus/Dispatch/MessageHandlerInvoker.cs

@@ -41,26 +41,16 @@ namespace Abc.Zebus.Dispatch
         public virtual MessageHandlerInvokerMode Mode => MessageHandlerInvokerMode.Synchronous;
 
         public IEnumerable<Subscription> GetStartupSubscriptions()
-        {
-            return _subscriber.GetStartupSubscriptions(MessageType, MessageTypeId, _container);
-        }
+            => _subscriber.GetStartupSubscriptions(MessageType, MessageTypeId, _container);
 
         public abstract void InvokeMessageHandler(IMessageHandlerInvocation invocation);
 
         public virtual Task InvokeMessageHandlerAsync(IMessageHandlerInvocation invocation)
-        {
-            throw new NotSupportedException("InvokeMessageHandlerAsync is not supported in Synchronous mode");
-        }
+            => throw new NotSupportedException("InvokeMessageHandlerAsync is not supported in Synchronous mode");
 
-        public virtual bool ShouldHandle(IMessage message)
-        {
-            return true;
-        }
+        public virtual bool ShouldHandle(IMessage message) => true;
 
-        public virtual bool CanMergeWith(IMessageHandlerInvoker other)
-        {
-            return false;
-        }
+        public virtual bool CanMergeWith(IMessageHandlerInvoker other) => false;
 
         protected internal object CreateHandler(MessageContext messageContext)
         {

src/Abc.Zebus/Dispatch/MessageHandlerInvokerSubscriber.cs

@@ -24,16 +24,16 @@ namespace Abc.Zebus.Dispatch
                 return new MessageHandlerInvokerSubscriber(subscriptionModeAttribute.SubscriptionMode, subscriptionModeAttribute.StartupSubscriberType);
 
             if (Attribute.IsDefined(messageHandlerType, typeof(NoScanAttribute)))
-                return new MessageHandlerInvokerSubscriber(SubscriptionMode.Manual, null);
+                return new MessageHandlerInvokerSubscriber(SubscriptionMode.Manual, startupSubscriberType: null);
 
-            return new MessageHandlerInvokerSubscriber(null, null);
+            return new MessageHandlerInvokerSubscriber(subscriptionMode: null, startupSubscriberType: null);
         }
 
         public IEnumerable<Subscription> GetStartupSubscriptions(Type messageType, MessageTypeId messageTypeId, IContainer container)
         {
-            if (_startupSubscriberType is { } startupSubscriberType)
+            if (_startupSubscriberType != null)
             {
-                var startupSubscriber = (IStartupSubscriber)container.GetInstance(startupSubscriberType);
+                var startupSubscriber = (IStartupSubscriber)container.GetInstance(_startupSubscriberType);
                 return GetSubscriptionsFromSubscriber(startupSubscriber, messageTypeId, messageType);
             }
 
@@ -60,7 +60,7 @@ namespace Abc.Zebus.Dispatch
             {
                 SubscriptionMode.Auto   => new[] { new Subscription(messageTypeId) },
                 SubscriptionMode.Manual => Array.Empty<Subscription>(),
-                _                       => throw new NotSupportedException($"Unsupported subscription mode: {_subscriptionMode}"),
+                _                       => throw new NotSupportedException($"Unsupported subscription mode: {subscriptionMode}"),
             };
         }
     }

src/Abc.Zebus/SubscriptionModeAttribute.cs

@@ -28,6 +28,10 @@ namespace Abc.Zebus
         }
 
         public SubscriptionMode SubscriptionMode { get; }
+
+        /// <summary>
+        /// A type which implements the interface <see cref="IStartupSubscriber"/>
+        /// </summary>
         public Type? StartupSubscriberType { get; }
     }
 }