Code re-factorings and formatting in EventBus projects

src/BuildingBlocks/EventBus/EventBus/Abstractions/IDynamicIntegrationEventHandler.cs

@@ -1,13 +1,9 @@
-using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions
 {
-    public interface IDynamicIntegrationEventHandler
-    {
-        Task Handle(dynamic eventData);
-    }
+	public interface IDynamicIntegrationEventHandler
+	{
+		Task Handle(dynamic eventData);
+	}
 }

src/BuildingBlocks/EventBus/EventBus/Abstractions/IEventBus.cs

@@ -1,24 +1,23 @@
-using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
-using System;
-
-namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions
+namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions
 {
-    public interface IEventBus
-    {
-        void Publish(IntegrationEvent @event);
+	using IntegrationEvent = Events.IntegrationEvent;
+
+	public interface IEventBus
+	{
+		void Publish(IntegrationEvent @event);
 
-        void Subscribe<T, TH>()
-            where T : IntegrationEvent
-            where TH : IIntegrationEventHandler<T>;
+		void Subscribe<T, TH>()
+		    where T : IntegrationEvent
+		    where TH : IIntegrationEventHandler<T>;
 
-        void SubscribeDynamic<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler;
+		void SubscribeDynamic<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler;
 
-        void UnsubscribeDynamic<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler;
+		void UnsubscribeDynamic<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler;
 
-        void Unsubscribe<T, TH>()
-            where TH : IIntegrationEventHandler<T>
-            where T : IntegrationEvent;
-    }
+		void Unsubscribe<T, TH>()
+		    where TH : IIntegrationEventHandler<T>
+		    where T : IntegrationEvent;
+	}
 }

src/BuildingBlocks/EventBus/EventBus/Abstractions/IIntegrationEventHandler.cs

@@ -1,15 +1,16 @@
-using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
-using System.Threading.Tasks;
+using Task = System.Threading.Tasks.Task;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions
 {
-    public interface IIntegrationEventHandler<in TIntegrationEvent> : IIntegrationEventHandler 
-        where TIntegrationEvent: IntegrationEvent
-    {
-        Task Handle(TIntegrationEvent @event);
-    }
+	using IntegrationEvent = Events.IntegrationEvent;
 
-    public interface IIntegrationEventHandler
-    {
-    }
+	public interface IIntegrationEventHandler<in TIntegrationEvent> : IIntegrationEventHandler
+	   where TIntegrationEvent : IntegrationEvent
+	{
+		Task Handle(TIntegrationEvent @event);
+	}
+
+	public interface IIntegrationEventHandler
+	{
+	}
 }

src/BuildingBlocks/EventBus/EventBus/Events/IntegrationEvent.cs

@@ -1,16 +1,17 @@
-using System;
+using DateTime = System.DateTime;
+using Guid = System.Guid;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events
 {
-    public class IntegrationEvent
-    {
-        public IntegrationEvent()
-        {
-            Id = Guid.NewGuid();
-            CreationDate = DateTime.UtcNow;
-        }
+	public class IntegrationEvent
+	{
+		public IntegrationEvent()
+		{
+			Id = Guid.NewGuid();
+			CreationDate = DateTime.UtcNow;
+		}
 
-        public Guid Id  { get; }
-        public DateTime CreationDate { get; }
-    }
+		public Guid Id { get; }
+		public DateTime CreationDate { get; }
+	}
 }

src/BuildingBlocks/EventBus/EventBus/IEventBusSubscriptionsManager.cs

@@ -2,33 +2,34 @@
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 using System;
 using System.Collections.Generic;
-using static Microsoft.eShopOnContainers.BuildingBlocks.EventBus.InMemoryEventBusSubscriptionsManager;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus
 {
-    public interface IEventBusSubscriptionsManager
-    {
-        bool IsEmpty { get; }
-        event EventHandler<string> OnEventRemoved;
-        void AddDynamicSubscription<TH>(string eventName)
-           where TH : IDynamicIntegrationEventHandler;
+	using static InMemoryEventBusSubscriptionsManager;
 
-        void AddSubscription<T, TH>()
-           where T : IntegrationEvent
-           where TH : IIntegrationEventHandler<T>;
+	public interface IEventBusSubscriptionsManager
+	{
+		bool IsEmpty { get; }
+		event EventHandler<string> OnEventRemoved;
+		void AddDynamicSubscription<TH>(string eventName)
+		   where TH : IDynamicIntegrationEventHandler;
 
-        void RemoveSubscription<T, TH>()
-             where TH : IIntegrationEventHandler<T>
-             where T : IntegrationEvent;
-        void RemoveDynamicSubscription<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler;
+		void AddSubscription<T, TH>()
+		   where T : IntegrationEvent
+		   where TH : IIntegrationEventHandler<T>;
 
-        bool HasSubscriptionsForEvent<T>() where T : IntegrationEvent;
-        bool HasSubscriptionsForEvent(string eventName);
-        Type GetEventTypeByName(string eventName);
-        void Clear();
-        IEnumerable<SubscriptionInfo> GetHandlersForEvent<T>() where T : IntegrationEvent;
-        IEnumerable<SubscriptionInfo> GetHandlersForEvent(string eventName);
-        string GetEventKey<T>();
-    }
+		void RemoveSubscription<T, TH>()
+			where TH : IIntegrationEventHandler<T>
+			where T : IntegrationEvent;
+		void RemoveDynamicSubscription<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler;
+
+		bool HasSubscriptionsForEvent<T>() where T : IntegrationEvent;
+		bool HasSubscriptionsForEvent(string eventName);
+		Type GetEventTypeByName(string eventName);
+		void Clear();
+		IEnumerable<SubscriptionInfo> GetHandlersForEvent<T>() where T : IntegrationEvent;
+		IEnumerable<SubscriptionInfo> GetHandlersForEvent(string eventName);
+		string GetEventKey<T>();
+	}
 }

src/BuildingBlocks/EventBus/EventBus/InMemoryEventBusSubscriptionsManager.cs

@@ -3,160 +3,135 @@ using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
-using System.Text;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus
 {
-    public partial class InMemoryEventBusSubscriptionsManager : IEventBusSubscriptionsManager
-    {
-
-
-        private readonly Dictionary<string, List<SubscriptionInfo>> _handlers;
-        private readonly List<Type> _eventTypes;
-
-        public event EventHandler<string> OnEventRemoved;
-
-        public InMemoryEventBusSubscriptionsManager()
-        {
-            _handlers = new Dictionary<string, List<SubscriptionInfo>>();
-            _eventTypes = new List<Type>();
-        }
-
-        public bool IsEmpty => !_handlers.Keys.Any();
-        public void Clear() => _handlers.Clear();
-
-        public void AddDynamicSubscription<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler
-        {
-            DoAddSubscription(typeof(TH), eventName, isDynamic: true);
-        }
-
-        public void AddSubscription<T, TH>()
-            where T : IntegrationEvent
-            where TH : IIntegrationEventHandler<T>
-        {
-            var eventName = GetEventKey<T>();
-            DoAddSubscription(typeof(TH), eventName, isDynamic: false);
-            _eventTypes.Add(typeof(T));
-        }
-
-        private void DoAddSubscription(Type handlerType, string eventName, bool isDynamic)
-        {
-            if (!HasSubscriptionsForEvent(eventName))
-            {
-                _handlers.Add(eventName, new List<SubscriptionInfo>());
-            }
-
-            if (_handlers[eventName].Any(s => s.HandlerType == handlerType))
-            {
-                throw new ArgumentException(
-                    $"Handler Type {handlerType.Name} already registered for '{eventName}'", nameof(handlerType));
-            }
-
-            if (isDynamic)
-            {
-                _handlers[eventName].Add(SubscriptionInfo.Dynamic(handlerType));
-            }
-            else
-            {
-                _handlers[eventName].Add(SubscriptionInfo.Typed(handlerType));
-            }
-        }
-
-
-        public void RemoveDynamicSubscription<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler
-        {
-            var handlerToRemove = FindDynamicSubscriptionToRemove<TH>(eventName);
-            DoRemoveHandler(eventName, handlerToRemove);
-        }
-
-
-        public void RemoveSubscription<T, TH>()
-            where TH : IIntegrationEventHandler<T>
-            where T : IntegrationEvent
-        {
-            var handlerToRemove = FindSubscriptionToRemove<T, TH>();
-            var eventName = GetEventKey<T>();
-            DoRemoveHandler(eventName, handlerToRemove);
-        }
-
-
-        private void DoRemoveHandler(string eventName, SubscriptionInfo subsToRemove)
-        {
-            if (subsToRemove != null)
-            {
-                _handlers[eventName].Remove(subsToRemove);
-                if (!_handlers[eventName].Any())
-                {
-                    _handlers.Remove(eventName);
-                    var eventType = _eventTypes.SingleOrDefault(e => e.Name == eventName);
-                    if (eventType != null)
-                    {
-                        _eventTypes.Remove(eventType);
-                    }
-                    RaiseOnEventRemoved(eventName);
-                }
-
-            }
-        }
-
-        public IEnumerable<SubscriptionInfo> GetHandlersForEvent<T>() where T : IntegrationEvent
-        {
-            var key = GetEventKey<T>();
-            return GetHandlersForEvent(key);
-        }
-        public IEnumerable<SubscriptionInfo> GetHandlersForEvent(string eventName) => _handlers[eventName];
-
-        private void RaiseOnEventRemoved(string eventName)
-        {
-            var handler = OnEventRemoved;
-            if (handler != null)
-            {
-                OnEventRemoved(this, eventName);
-            }
-        }
-
-
-        private SubscriptionInfo FindDynamicSubscriptionToRemove<TH>(string eventName)
-            where TH : IDynamicIntegrationEventHandler
-        {
-            return DoFindSubscriptionToRemove(eventName, typeof(TH));
-        }
-
-
-        private SubscriptionInfo FindSubscriptionToRemove<T, TH>()
-             where T : IntegrationEvent
-             where TH : IIntegrationEventHandler<T>
-        {
-            var eventName = GetEventKey<T>();
-            return DoFindSubscriptionToRemove(eventName, typeof(TH));
-        }
-
-        private SubscriptionInfo DoFindSubscriptionToRemove(string eventName, Type handlerType)
-        {
-            if (!HasSubscriptionsForEvent(eventName))
-            {
-                return null;
-            }
-
-            return _handlers[eventName].SingleOrDefault(s => s.HandlerType == handlerType);
-
-        }
-
-        public bool HasSubscriptionsForEvent<T>() where T : IntegrationEvent
-        {
-            var key = GetEventKey<T>();
-            return HasSubscriptionsForEvent(key);
-        }
-        public bool HasSubscriptionsForEvent(string eventName) => _handlers.ContainsKey(eventName);
-
-        public Type GetEventTypeByName(string eventName) => _eventTypes.SingleOrDefault(t => t.Name == eventName);
-
-        public string GetEventKey<T>()
-        {
-            return typeof(T).Name;
-        }
-    }
+	public partial class InMemoryEventBusSubscriptionsManager : IEventBusSubscriptionsManager
+	{
+
+
+		private readonly Dictionary<string, List<SubscriptionInfo>> _handlers;
+		private readonly List<Type> _eventTypes;
+
+		public event EventHandler<string> OnEventRemoved;
+
+		public InMemoryEventBusSubscriptionsManager()
+		{
+			_handlers = new Dictionary<string, List<SubscriptionInfo>>();
+			_eventTypes = new List<Type>();
+		}
+
+		public bool IsEmpty => !_handlers.Keys.Any();
+		public void Clear() => _handlers.Clear();
+
+		public void AddDynamicSubscription<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler 
+			=> DoAddSubscription(typeof(TH), eventName, isDynamic: true);
+
+		public void AddSubscription<T, TH>()
+		    where T : IntegrationEvent
+		    where TH : IIntegrationEventHandler<T>
+		{
+			var eventName = GetEventKey<T>();
+			DoAddSubscription(typeof(TH), eventName, isDynamic: false);
+			_eventTypes.Add(typeof(T));
+		}
+
+		private void DoAddSubscription(Type handlerType, string eventName, bool isDynamic)
+		{
+			if (!HasSubscriptionsForEvent(eventName))
+			{
+				_handlers.Add(eventName, new List<SubscriptionInfo>());
+			}
+
+			if (_handlers[eventName].Any(s => s.HandlerType == handlerType))
+			{
+				throw new ArgumentException(
+				    $"Handler Type {handlerType.Name} already registered for '{eventName}'", nameof(handlerType));
+			}
+
+			if (isDynamic)
+			{
+				_handlers[eventName].Add(SubscriptionInfo.Dynamic(handlerType));
+			}
+			else
+			{
+				_handlers[eventName].Add(SubscriptionInfo.Typed(handlerType));
+			}
+		}
+
+
+		public void RemoveDynamicSubscription<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler
+		{
+			var handlerToRemove = FindDynamicSubscriptionToRemove<TH>(eventName);
+			DoRemoveHandler(eventName, handlerToRemove);
+		}
+
+
+		public void RemoveSubscription<T, TH>()
+		    where TH : IIntegrationEventHandler<T>
+		    where T : IntegrationEvent
+		{
+			var handlerToRemove = FindSubscriptionToRemove<T, TH>();
+			var eventName = GetEventKey<T>();
+			DoRemoveHandler(eventName, handlerToRemove);
+		}
+
+
+		private void DoRemoveHandler(string eventName, SubscriptionInfo subsToRemove)
+		{
+			if (subsToRemove != null)
+			{
+				_handlers[eventName].Remove(subsToRemove);
+				if (!_handlers[eventName].Any())
+				{
+					_handlers.Remove(eventName);
+					var eventType = _eventTypes.SingleOrDefault(e => e.Name == eventName);
+					if (eventType != null)
+					{
+						_eventTypes.Remove(eventType);
+					}
+					RaiseOnEventRemoved(eventName);
+				}
+
+			}
+		}
+
+		public IEnumerable<SubscriptionInfo> GetHandlersForEvent<T>() where T : IntegrationEvent
+			=> GetHandlersForEvent(GetEventKey<T>());
+		public IEnumerable<SubscriptionInfo> GetHandlersForEvent(string eventName) => _handlers[eventName];
+
+		private void RaiseOnEventRemoved(string eventName)
+		{
+			var handler = OnEventRemoved;
+			if (handler != null)
+			{
+				OnEventRemoved(this, eventName);
+			}
+		}
+
+
+		private SubscriptionInfo FindDynamicSubscriptionToRemove<TH>(string eventName)
+		    where TH : IDynamicIntegrationEventHandler 
+			=> DoFindSubscriptionToRemove(eventName, typeof(TH));
+
+
+		private SubscriptionInfo FindSubscriptionToRemove<T, TH>()
+			where T : IntegrationEvent
+			where TH : IIntegrationEventHandler<T> 
+			=> DoFindSubscriptionToRemove(GetEventKey<T>(), typeof(TH));
+
+		private SubscriptionInfo DoFindSubscriptionToRemove(string eventName, Type handlerType) 
+			=> !HasSubscriptionsForEvent(eventName) ? null : _handlers[eventName].SingleOrDefault(s => s.HandlerType == handlerType);
+
+		public bool HasSubscriptionsForEvent<T>() where T : IntegrationEvent
+			=> HasSubscriptionsForEvent(GetEventKey<T>());
+		public bool HasSubscriptionsForEvent(string eventName) => _handlers.ContainsKey(eventName);
+
+		public Type GetEventTypeByName(string eventName) => _eventTypes.SingleOrDefault(t => t.Name == eventName);
+
+		public string GetEventKey<T>() 
+			=> typeof(T).Name;
+	}
 }

src/BuildingBlocks/EventBus/EventBus/SubscriptionInfo.cs

@@ -2,27 +2,27 @@
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.EventBus
 {
-    public partial class InMemoryEventBusSubscriptionsManager : IEventBusSubscriptionsManager
-    {
-        public class SubscriptionInfo
-        {
-            public bool IsDynamic { get; }
-            public Type HandlerType{ get; }
+	public partial class InMemoryEventBusSubscriptionsManager : IEventBusSubscriptionsManager
+	{
+		public class SubscriptionInfo
+		{
+			public bool IsDynamic { get; }
+			public Type HandlerType { get; }
 
-            private SubscriptionInfo(bool isDynamic, Type handlerType)
-            {
-                IsDynamic = isDynamic;
-                HandlerType = handlerType;
-            }
+			private SubscriptionInfo(bool isDynamic, Type handlerType)
+			{
+				IsDynamic = isDynamic;
+				HandlerType = handlerType;
+			}
 
-            public static SubscriptionInfo Dynamic(Type handlerType)
-            {
-                return new SubscriptionInfo(true, handlerType);
-            }
-            public static SubscriptionInfo Typed(Type handlerType)
-            {
-                return new SubscriptionInfo(false, handlerType);
-            }
-        }
-    }
+			public static SubscriptionInfo Dynamic(Type handlerType)
+			{
+				return new SubscriptionInfo(true, handlerType);
+			}
+			public static SubscriptionInfo Typed(Type handlerType)
+			{
+				return new SubscriptionInfo(false, handlerType);
+			}
+		}
+	}
 }