😋😋😋

src/Plus/Event/Bus/EventBus.cs

@@ -36,7 +36,6 @@ namespace Plus.Event.Bus
 
         public static EventBus Default { get; } = new EventBus();
 
-
         public ILogger Logger { get; set; }
 
         public EventBus()
@@ -55,11 +54,6 @@ namespace Plus.Event.Bus
             return Register(typeof(TEventData), handler);
         }
 
-        public IDisposable Register<TEventData, THandler>() where TEventData : IEventData where THandler : IEventHandler<TEventData>, new()
-        {
-            return Register(typeof(TEventData), new TransientEventHandlerFactory<THandler>());
-        }
-
         public IDisposable Register(Type eventType, IEventHandler handler)
         {
             return Register(eventType, new SingleInstanceHandlerFactory(handler));
@@ -77,6 +71,23 @@ namespace Plus.Event.Bus
             return new FactoryUnregistrar(this, eventType, handlerFactory);
         }
 
+        public IDisposable Register<TEventData, THandler>()
+            where TEventData : IEventData
+            where THandler : IEventHandler, new()
+        {
+            return Register(typeof(TEventData), new TransientEventHandlerFactory<THandler>());
+        }
+
+        public IDisposable AsyncRegister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData
+        {
+            return Register(typeof(TEventData), new AsyncActionEventHandler<TEventData>(action));
+        }
+
+        public IDisposable AsyncRegister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+            return Register(typeof(TEventData), handler);
+        }
+
         public void Unregister<TEventData>(Action<TEventData> action) where TEventData : IEventData
         {
             GetOrCreateHandlerFactories(typeof(TEventData))
@@ -128,6 +139,36 @@ namespace Plus.Event.Bus
             GetOrCreateHandlerFactories(eventType).Locking(factories => factories.Remove(factory));
         }
 
+        public void AsyncUnregister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData
+        {
+            GetOrCreateHandlerFactories(typeof(TEventData))
+                .Locking(factories =>
+                {
+                    factories.RemoveAll(
+                        factory =>
+                        {
+                            var singleInstanceFactory = factory as SingleInstanceHandlerFactory;
+                            if (singleInstanceFactory == null)
+                            {
+                                return false;
+                            }
+
+                            var actionHandler = singleInstanceFactory.HandlerInstance as AsyncActionEventHandler<TEventData>;
+                            if (actionHandler == null)
+                            {
+                                return false;
+                            }
+
+                            return actionHandler.Action == action;
+                        });
+                });
+        }
+
+        public void AsyncUnregister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+            Unregister(typeof(TEventData), handler);
+        }
+
         public void UnregisterAll<TEventData>() where TEventData : IEventData
         {
             UnregisterAll(typeof(TEventData));
@@ -167,6 +208,52 @@ namespace Plus.Event.Bus
             }
         }
 
+        public Task TriggerAsync<TEventData>(TEventData eventData) where TEventData : IEventData
+        {
+            return TriggerAsync((object)null, eventData);
+        }
+
+        public Task TriggerAsync<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData
+        {
+            ExecutionContext.SuppressFlow();
+            Task result = Task.Factory.StartNew(delegate
+            {
+                try
+                {
+                    Trigger(eventSource, eventData);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Warn(ex.ToString(), ex);
+                }
+            });
+            ExecutionContext.RestoreFlow();
+            return result;
+        }
+
+        public Task TriggerAsync(Type eventType, IEventData eventData)
+        {
+            return TriggerAsync(eventType, null, eventData);
+        }
+
+        public Task TriggerAsync(Type eventType, object eventSource, IEventData eventData)
+        {
+            ExecutionContext.SuppressFlow();
+            Task result = Task.Factory.StartNew(delegate
+            {
+                try
+                {
+                    Trigger(eventType, eventSource, eventData);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Warn(ex.ToString(), ex);
+                }
+            });
+            ExecutionContext.RestoreFlow();
+            return result;
+        }
+
         private void TriggerHandlingException(Type eventType, object eventSource, IEventData eventData, List<Exception> exceptions)
         {
             eventData.EventSource = eventSource;
@@ -245,52 +332,6 @@ namespace Plus.Event.Bus
             return false;
         }
 
-        public Task TriggerAsync<TEventData>(TEventData eventData) where TEventData : IEventData
-        {
-            return TriggerAsync((object)null, eventData);
-        }
-
-        public Task TriggerAsync<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData
-        {
-            ExecutionContext.SuppressFlow();
-            Task result = Task.Factory.StartNew(delegate
-            {
-                try
-                {
-                    Trigger(eventSource, eventData);
-                }
-                catch (Exception ex)
-                {
-                    Logger.Warn(ex.ToString(), ex);
-                }
-            });
-            ExecutionContext.RestoreFlow();
-            return result;
-        }
-
-        public Task TriggerAsync(Type eventType, IEventData eventData)
-        {
-            return TriggerAsync(eventType, null, eventData);
-        }
-
-        public Task TriggerAsync(Type eventType, object eventSource, IEventData eventData)
-        {
-            ExecutionContext.SuppressFlow();
-            Task result = Task.Factory.StartNew(delegate
-            {
-                try
-                {
-                    Trigger(eventType, eventSource, eventData);
-                }
-                catch (Exception ex)
-                {
-                    Logger.Warn(ex.ToString(), ex);
-                }
-            });
-            ExecutionContext.RestoreFlow();
-            return result;
-        }
-
         private List<IEventHandlerFactory> GetOrCreateHandlerFactories(Type eventType)
         {
             return _handlerFactories.GetOrAdd(eventType, (Type type) => new List<IEventHandlerFactory>());

src/Plus/Event/Bus/EventData.cs

+using System;
+
+namespace Plus.Event.Bus
+{
+    /// <summary>
+    /// 实现 <see cref="IEventData"/> 接口
+    /// </summary>
+    [Serializable]
+    public class EventData : IEventData
+    {
+        public DateTime EventTime { get; set; }
+
+        public object EventSource { get; set; }
+
+        protected EventData()
+        {
+            EventTime = DateTime.Now;
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/IEventBus.cs

@@ -10,46 +10,204 @@ namespace Plus.Event.Bus
     /// </summary>
     public interface IEventBus
     {
+        #region Register
+
+        /// <summary>
+        /// Registers to an event.
+        /// Given action is called for all event occurrences.
+        /// </summary>
+        /// <param name="action">Action to handle events</param>
+        /// <typeparam name="TEventData">Event type</typeparam>
         IDisposable Register<TEventData>(Action<TEventData> action) where TEventData : IEventData;
 
+        /// <summary>
+        /// Registers to an event.
+        /// Given action is called for all event occurrences.
+        /// </summary>
+        /// <param name="action">Action to handle events</param>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        IDisposable AsyncRegister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData;
+
+        /// <summary>
+        /// Registers to an event. 
+        /// Same (given) instance of the handler is used for all event occurrences.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="handler">Object to handle the event</param>
         IDisposable Register<TEventData>(IEventHandler<TEventData> handler) where TEventData : IEventData;
 
-        IDisposable Register<TEventData, THandler>() where TEventData : IEventData where THandler : IEventHandler<TEventData>, new();
+        /// <summary>
+        /// Registers to an event. 
+        /// Same (given) instance of the async handler is used for all event occurrences.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="handler">Object to handle the event</param>
+        IDisposable AsyncRegister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData;
 
+        /// <summary>
+        /// Registers to an event.
+        /// A new instance of <see cref="THandler"/> object is created for every event occurrence.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <typeparam name="THandler">Type of the event handler</typeparam>
+        IDisposable Register<TEventData, THandler>() where TEventData : IEventData where THandler : IEventHandler, new();
+
+        /// <summary>
+        /// Registers to an event.
+        /// Same (given) instance of the handler is used for all event occurrences.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="handler">Object to handle the event</param>
         IDisposable Register(Type eventType, IEventHandler handler);
 
-        IDisposable Register<TEventData>(IEventHandlerFactory handlerFactory) where TEventData : IEventData;
+        /// <summary>
+        /// Registers to an event.
+        /// Given factory is used to create/release handlers
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="factory">A factory to create/release handlers</param>
+        IDisposable Register<TEventData>(IEventHandlerFactory factory) where TEventData : IEventData;
+
+        /// <summary>
+        /// Registers to an event.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="factory">A factory to create/release handlers</param>
+        IDisposable Register(Type eventType, IEventHandlerFactory factory);
+
+        #endregion
 
-        IDisposable Register(Type eventType, IEventHandlerFactory handlerFactory);
+        #region Unregister
 
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="action"></param>
         void Unregister<TEventData>(Action<TEventData> action) where TEventData : IEventData;
 
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="action"></param>
+        void AsyncUnregister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData;
+
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="handler">Handler object that is registered before</param>
         void Unregister<TEventData>(IEventHandler<TEventData> handler) where TEventData : IEventData;
 
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="handler">Handler object that is registered before</param>
+        void AsyncUnregister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData;
+
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="handler">Handler object that is registered before</param>
         void Unregister(Type eventType, IEventHandler handler);
 
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="factory">Factory object that is registered before</param>
         void Unregister<TEventData>(IEventHandlerFactory factory) where TEventData : IEventData;
 
+        /// <summary>
+        /// Unregisters from an event.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="factory">Factory object that is registered before</param>
         void Unregister(Type eventType, IEventHandlerFactory factory);
 
+        /// <summary>
+        /// Unregisters all event handlers of given event type.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
         void UnregisterAll<TEventData>() where TEventData : IEventData;
 
+        /// <summary>
+        /// Unregisters all event handlers of given event type.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
         void UnregisterAll(Type eventType);
 
+        #endregion
+
+        #region Trigger
+
+        /// <summary>
+        /// Triggers an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="eventData">Related data for the event</param>
         void Trigger<TEventData>(TEventData eventData) where TEventData : IEventData;
 
+        /// <summary>
+        /// Triggers an event.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="eventSource">The object which triggers the event</param>
+        /// <param name="eventData">Related data for the event</param>
         void Trigger<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData;
 
+        /// <summary>
+        /// Triggers an event.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="eventData">Related data for the event</param>
         void Trigger(Type eventType, IEventData eventData);
 
+        /// <summary>
+        /// Triggers an event.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="eventSource">The object which triggers the event</param>
+        /// <param name="eventData">Related data for the event</param>
         void Trigger(Type eventType, object eventSource, IEventData eventData);
 
+        /// <summary>
+        /// Triggers an event asynchronously.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="eventData">Related data for the event</param>
+        /// <returns>The task to handle async operation</returns>
         Task TriggerAsync<TEventData>(TEventData eventData) where TEventData : IEventData;
 
+        /// <summary>
+        /// Triggers an event asynchronously.
+        /// </summary>
+        /// <typeparam name="TEventData">Event type</typeparam>
+        /// <param name="eventSource">The object which triggers the event</param>
+        /// <param name="eventData">Related data for the event</param>
+        /// <returns>The task to handle async operation</returns>
         Task TriggerAsync<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData;
 
+        /// <summary>
+        /// Triggers an event asynchronously.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="eventData">Related data for the event</param>
+        /// <returns>The task to handle async operation</returns>
         Task TriggerAsync(Type eventType, IEventData eventData);
 
+        /// <summary>
+        /// Triggers an event asynchronously.
+        /// </summary>
+        /// <param name="eventType">Event type</param>
+        /// <param name="eventSource">The object which triggers the event</param>
+        /// <param name="eventData">Related data for the event</param>
+        /// <returns>The task to handle async operation</returns>
         Task TriggerAsync(Type eventType, object eventSource, IEventData eventData);
+
+        #endregion
     }
 }
\ No newline at end of file

src/Plus/Event/Bus/NullEventBus.cs

+using Plus.Event.Bus.Factories;
+using Plus.Event.Bus.Handlers;
+using System;
+using System.Threading.Tasks;
+
+namespace Plus.Event.Bus
+{
+    /// <summary>
+    /// 实现空对象模式的事件
+    /// </summary>
+    public sealed class NullEventBus : IEventBus
+    {
+        /// <summary>
+        /// 获取 <see cref="NullEventBus"/> 实例
+        /// </summary>
+        public static NullEventBus Instance { get; } = new NullEventBus();
+
+        private NullEventBus()
+        {
+
+        }
+
+        public IDisposable Register<TEventData>(Action<TEventData> action) where TEventData : IEventData
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable AsyncRegister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable Register<TEventData>(IEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable AsyncRegister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable Register<TEventData, THandler>()
+            where TEventData : IEventData
+            where THandler : IEventHandler, new()
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable Register(Type eventType, IEventHandler handler)
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable Register<TEventData>(IEventHandlerFactory handlerFactory) where TEventData : IEventData
+        {
+            return NullDisposable.Instance;
+        }
+
+        public IDisposable Register(Type eventType, IEventHandlerFactory handlerFactory)
+        {
+            return NullDisposable.Instance;
+        }
+
+        public void Unregister<TEventData>(Action<TEventData> action) where TEventData : IEventData
+        {
+
+        }
+
+        public void AsyncUnregister<TEventData>(Func<TEventData, Task> action) where TEventData : IEventData
+        {
+
+        }
+
+        public void Unregister<TEventData>(IEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+
+        }
+
+        public void AsyncUnregister<TEventData>(IAsyncEventHandler<TEventData> handler) where TEventData : IEventData
+        {
+
+        }
+
+        public void Unregister(Type eventType, IEventHandler handler)
+        {
+        }
+
+        public void Unregister<TEventData>(IEventHandlerFactory factory) where TEventData : IEventData
+        {
+
+        }
+
+        public void Unregister(Type eventType, IEventHandlerFactory factory)
+        {
+
+        }
+
+        public void UnregisterAll<TEventData>() where TEventData : IEventData
+        {
+
+        }
+
+        public void UnregisterAll(Type eventType)
+        {
+
+        }
+
+        public void Trigger<TEventData>(TEventData eventData) where TEventData : IEventData
+        {
+
+        }
+
+        public void Trigger<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData
+        {
+
+        }
+
+        public void Trigger(Type eventType, IEventData eventData)
+        {
+
+        }
+
+        public void Trigger(Type eventType, object eventSource, IEventData eventData)
+        {
+
+        }
+
+        public Task TriggerAsync<TEventData>(TEventData eventData) where TEventData : IEventData
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task TriggerAsync<TEventData>(object eventSource, TEventData eventData) where TEventData : IEventData
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task TriggerAsync(Type eventType, IEventData eventData)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task TriggerAsync(Type eventType, object eventSource, IEventData eventData)
+        {
+            return Task.CompletedTask;
+        }
+    }
+}
\ No newline at end of file

src/Plus/NullDisposable.cs

+using System;
+
+namespace Plus
+{
+    /// <summary>
+    /// 该类用于模拟不做任何操作的一次性组件
+    /// </summary>
+    internal sealed class NullDisposable : IDisposable
+    {
+        public static NullDisposable Instance { get; } = new NullDisposable();
+
+
+        private NullDisposable()
+        {
+
+        }
+
+        public void Dispose()
+        {
+
+        }
+    }
+}
\ No newline at end of file

src/Plus/PlusStarter.cs

@@ -17,15 +17,9 @@ namespace Plus
 
         private IPlusModuleManager _moduleManager;
 
-        public Type StartupModule
-        {
-            get;
-        }
+        public Type StartupModule { get; }
 
-        public IIocManager IocManager
-        {
-            get;
-        }
+        public IIocManager IocManager { get; }
 
         private PlusStarter(Type startupModule, Action<PlusStarterOptions> optionsAction = null)
         {
@@ -95,10 +89,9 @@ namespace Plus
         {
             if (!IocManager.IsRegistered<PlusStarter>())
             {
-                IocManager.IocContainer.Register((IRegistration[])new IRegistration[1]
-                {
+                IocManager.IocContainer.Register(
                      Component.For<PlusStarter>().Instance(this)
-                });
+                );
             }
         }