diff --git a/src/M.EventBroker/Async/DelegateEventHandlerAsync.cs b/src/M.EventBroker/Async/DelegateEventHandlerAsync.cs
new file mode 100644
index 0000000..46bd1c8
--- /dev/null
+++ b/src/M.EventBroker/Async/DelegateEventHandlerAsync.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Threading.Tasks;
+
+namespace M.EventBroker
+{
+    /// <summary>
+    /// An adapter used to represent delegate as IEventHandler.
+    /// </summary>
+    /// <typeparam name="TEvent">The type of the event to be handled.</typeparam>
+    public class DelegateEventHandlerAsync<TEvent> : IEventHandlerAsync<TEvent>
+    {
+        private readonly Func<TEvent, Task> _handler;
+        private readonly Func<TEvent, Task<bool>> _filter;
+        private readonly Func<Exception, TEvent, Task> _onError;
+
+        /// <summary>
+        /// Creates a new instance of the DelegateEventHandler class.
+        /// </summary>
+        /// <param name="handler">A delegate used for event handling.</param>
+        /// <param name="filter">A delegate used to determine whether the event should be handled.</param>
+        /// <param name="onError">A delegate called when an error is caught during execution.</param>
+        public DelegateEventHandlerAsync(Func<TEvent, Task> handler, Func<TEvent, Task<bool>> filter = null, Func<Exception, TEvent, Task> onError = null)
+        {
+            _handler = handler;
+            _filter = filter;
+            _onError = onError;
+        }
+
+        /// <summary>
+        /// Handles the event.
+        /// </summary>
+        /// <param name="event">An instance of TEvent representing the event.</param>
+        public Task HandleAsync(TEvent @event) => _handler(@event);
+
+        /// <summary>
+        /// Called when an error is caught during execution.
+        /// </summary>
+        /// <param name="exception">The exception caught.</param>
+        /// <param name="event">The event instance which handling caused the exception.</param>
+        public Task OnErrorAsync(Exception exception, TEvent @event) => _onError?.Invoke(exception, @event);
+
+        /// <summary>
+        /// Returns a value indicating whether the event handler should be executed.
+        /// </summary>
+        /// <param name="event">An instance of TEvent representing the event.</param>
+        /// <returns>A value indicating whether the event handler should be executed.</returns>
+        public Task<bool> ShouldHandleAsync(TEvent @event)
+        {
+            if(_filter is null)
+            {
+                return Task.FromResult(true);
+            }
+
+            return _filter(@event);
+        }
+    }
+}
diff --git a/src/M.EventBroker/Async/EventBrokerAsync.cs b/src/M.EventBroker/Async/EventBrokerAsync.cs
new file mode 100644
index 0000000..d377e46
--- /dev/null
+++ b/src/M.EventBroker/Async/EventBrokerAsync.cs
@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace M.EventBroker
+{
+    /// <summary>
+    /// Manages event subscriptions and invoking of event handlers.
+    /// </summary>
+    public class EventBrokerAsync : IEventBrokerAsync
+    {
+        private readonly ConcurrentDictionary<Type, List<object>> _subscribers = new ConcurrentDictionary<Type, List<object>>();
+        private readonly IEventHandlerAsyncFactory _handlersFactory;
+        private readonly IEventHandlerRunnerAsync _runner;
+
+        /// <summary>
+        /// Creates a new instance of the EventBrokerAsync class.
+        /// </summary>
+        /// <param name="runner"></param>
+        /// <param name="handlersFactory">A delegate providing event handlers for event of givent type.</param>
+        public EventBrokerAsync(IEventHandlerRunnerAsync runner, IEventHandlerAsyncFactory handlersFactory = null)
+        {
+            _runner = runner;
+            _handlersFactory = handlersFactory;
+        }
+
+        /// <summary>
+        /// Adds subscription for events of type <typeparamref name="TEvent"/>.
+        /// </summary>
+        /// <typeparam name="TEvent">The type of the event.</typeparam>
+        /// <param name="handler">A delegate that will be invoked when event is published.</param>
+        /// <param name="filter">A delegate used to perform filtering of events before invoking the handler.</param>
+        /// <param name="onError">A delegate called when an error is caught during execution.</param>
+        public void Subscribe<TEvent>(Func<TEvent, Task> handler, Func<TEvent, Task<bool>> filter = null, Func<Exception, TEvent, Task> onError = null)
+        {
+            var handlers = _subscribers.GetOrAdd(typeof(TEvent), _ => new List<object>());
+            handlers.Add(new EventHandlerAsyncWrapper<TEvent>(handler, filter, onError));
+        }
+
+        /// <summary>
+        /// Adds subscription for events of type <typeparamref name="TEvent"/>.
+        /// </summary>
+        /// <typeparam name="TEvent">The type of the event.</typeparam>
+        /// <param name="handler">An instance of IEventHandler&lt;TEvent&gt; which Handle method will be invoked when event is published.</param>
+        public void Subscribe<TEvent>(IEventHandlerAsync<TEvent> handler)
+        {
+            var handlers = _subscribers.GetOrAdd(typeof(TEvent), _ => new List<object>());
+            handlers.Add(new EventHandlerAsyncWrapper<TEvent>(handler));
+        }
+
+        /// <summary>
+        /// Removes subscription for events of type <typeparamref name="TEvent"/>.
+        /// </summary>
+        /// <typeparam name="TEvent">The type of the event.</typeparam>
+        /// <param name="handler">A delegate to remove form subscribers.</param>
+        public void Unsubscribe<TEvent>(Func<TEvent, Task> handler)
+        {
+            Unsubscribe<TEvent>(x => x.IsWrapping(handler));
+        }
+
+        /// <summary>
+        /// Removes subscription for events of type <typeparamref name="TEvent"/>.
+        /// </summary>
+        /// <typeparam name="TEvent">The type of the event.</typeparam>
+        /// <param name="handler">An instance of IEventHandler&lt;TEvent&gt; to remove form subscribers.</param>
+        public void Unsubscribe<TEvent>(IEventHandlerAsync<TEvent> handler)
+        {
+            Unsubscribe<TEvent>(x => x.IsWrapping(handler));
+        }
+
+        /// <summary>
+        /// Publishes an event of type <typeparamref name="TEvent"/>.
+        /// </summary>
+        /// <typeparam name="TEvent">The type of the event.</typeparam>
+        /// <param name="event">An <typeparamref name="TEvent"/> instance to be passed to all handlers of the event. All handlers will be invoked asynchronously.</param>
+        public async Task PublishAsync<TEvent>(TEvent @event)
+        {
+            await EnqueueSubscribers(@event).ConfigureAwait(false);
+            await EnqueueFromHandlersFactory(@event).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Releases all resources used by the current instance of the EventBroker class.
+        /// </summary>
+        public void Dispose() => _runner.Dispose();
+
+        private void Unsubscribe<TEvent>(Func<EventHandlerAsyncWrapper<TEvent>, bool> handlerPredicate)
+        {
+            var handlers = _subscribers.GetOrAdd(typeof(TEvent), _ => new List<object>());
+            var targetHandlers = handlers.Cast<EventHandlerAsyncWrapper<TEvent>>().ToArray();
+            foreach (var handlerAction in targetHandlers.Where(x => handlerPredicate(x)))
+            {
+                handlers.Remove(handlerAction);
+                handlerAction.IsSubscribed = false;
+            }
+        }
+
+        private async Task EnqueueSubscribers<TEvent>(TEvent @event)
+        {
+            bool hasSubscribers = _subscribers.TryGetValue(typeof(TEvent), out List<object> handlers);
+            if (!hasSubscribers)
+            {
+                return;
+            }
+
+            if (handlers.Count == 0)
+            {
+                return;
+            }
+
+            Func<Task> CreateHandlerAction(EventHandlerAsyncWrapper<TEvent> handler)
+            {
+                return async () =>
+                {
+                    if (!handler.IsSubscribed)
+                    {
+                        return;
+                    }
+
+                    await TryRunHandler(handler, @event).ConfigureAwait(false);
+                };
+            }
+
+            Func<Task>[] handlerActions =
+                handlers.Cast<EventHandlerAsyncWrapper<TEvent>>()
+                        .Select(CreateHandlerAction)
+                        .ToArray();
+
+            await _runner.RunAsync(handlerActions).ConfigureAwait(false);
+        }
+
+        private async Task EnqueueFromHandlersFactory<TEvent>(TEvent @event)
+        {
+            if (_handlersFactory == null)
+            {
+                return;
+            }
+
+            IEnumerable<IEventHandlerAsync<TEvent>> handlerInstances = _handlersFactory.AsyncHandlersFor<TEvent>();
+            if (handlerInstances == null || !handlerInstances.Any())
+            {
+                return;
+            }
+
+            Func<Task> CreateHandlerAction(IEventHandlerAsync<TEvent> handler)
+            {
+                return async () => await TryRunHandler(handler, @event).ConfigureAwait(false);
+            }
+
+            Func<Task>[] handlerActions = handlerInstances.Select(CreateHandlerAction).ToArray();
+
+            await _runner.RunAsync(handlerActions).ConfigureAwait(false);
+        }
+
+        private async Task TryRunHandler<TEvent>(IEventHandlerAsync<TEvent> handler, TEvent @event)
+        {
+            try
+            {
+                if (!await handler.ShouldHandleAsync(@event).ConfigureAwait(false))
+                {
+                    return;
+                }
+
+                await handler.HandleAsync(@event).ConfigureAwait(false);
+            }
+            catch (Exception exception)
+            {
+                await TryReportError(exception, handler, @event).ConfigureAwait(false);
+            }
+        }
+
+        private async Task TryReportError<TEvent>(Exception exception, IEventHandlerAsync<TEvent> handler, TEvent @event)
+        {
+            try
+            {
+                await handler.OnErrorAsync(exception, @event).ConfigureAwait(false);
+            }
+            catch
+            {
+                // yes, we mute exceptions here
+            }
+        }
+    }
+}
diff --git a/src/M.EventBroker/Async/EventHandlerAsyncWrapper.cs b/src/M.EventBroker/Async/EventHandlerAsyncWrapper.cs
new file mode 100644
index 0000000..b3bcc4c
--- /dev/null
+++ b/src/M.EventBroker/Async/EventHandlerAsyncWrapper.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Threading.Tasks;
+
+namespace M.EventBroker
+{
+    internal class EventHandlerAsyncWrapper<TEvent> : IEventHandlerAsync<TEvent>
+    {
+        private readonly IEventHandlerAsync<TEvent> _eventHandler;
+        private readonly Func<TEvent, Task> _handler;
+
+        public EventHandlerAsyncWrapper(IEventHandlerAsync<TEvent> eventHandler)
+        {
+            _eventHandler = eventHandler;
+            _handler = eventHandler.HandleAsync;
+            IsSubscribed = true;
+        }
+
+        public EventHandlerAsyncWrapper(Func<TEvent, Task> handler, Func<TEvent, Task<bool>> filter = null, Func<Exception, TEvent, Task> onError = null)
+        {
+            _eventHandler = new DelegateEventHandlerAsync<TEvent>(handler, filter, onError);
+            _handler = handler;
+            IsSubscribed = true;
+        }
+
+        public bool IsSubscribed
+        {
+            get; set;
+        }
+
+        public Task HandleAsync(TEvent @event) => _eventHandler.HandleAsync(@event);
+
+        public Task<bool> ShouldHandleAsync(TEvent @event) => _eventHandler.ShouldHandleAsync(@event);
+
+        public Task OnErrorAsync(Exception exception, TEvent @event) => _eventHandler.OnErrorAsync(exception, @event);
+
+        public bool IsWrapping(IEventHandlerAsync<TEvent> eventHandler) => _eventHandler == eventHandler;
+
+        public bool IsWrapping(Func<TEvent, Task> handler) => _handler == handler;
+    }
+}
diff --git a/src/M.EventBroker/IEventBrokerAsync.cs b/src/M.EventBroker/IEventBrokerAsync.cs
index 747a025..2788e9b 100644
--- a/src/M.EventBroker/IEventBrokerAsync.cs
+++ b/src/M.EventBroker/IEventBrokerAsync.cs
@@ -44,6 +44,6 @@ public interface IEventBrokerAsync : IDisposable
         /// <typeparam name="TEvent">The type of the event.</typeparam>
         /// <param name="event">An <typeparamref name="TEvent"/> instance to be passed to all handlers of the event.</param>
         /// <returns>The task object representing the asynchronous operation.</returns>
-        Task Publish<TEvent>(TEvent @event);
+        Task PublishAsync<TEvent>(TEvent @event);
     }
 }
diff --git a/test/M.EventBroker.Tests/Async/EventBrokerAsyncTests.cs b/test/M.EventBroker.Tests/Async/EventBrokerAsyncTests.cs
new file mode 100644
index 0000000..3e747f1
--- /dev/null
+++ b/test/M.EventBroker.Tests/Async/EventBrokerAsyncTests.cs
@@ -0,0 +1,545 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FakeItEasy;
+using Xunit;
+
+namespace M.EventBroker.Async.Tests
+{
+    public class EventBrokerAsyncTests
+    {
+        [Fact]
+        public async Task Subscribe_WithDelegate_CreatesSubscribsion()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+
+            var handler = A.Fake<IEventHandlerAsync<string>>();
+
+            // Act
+            broker.Subscribe<string>(handler.HandleAsync);
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task Subscribe_WithHandlerInstance_CreatesSubscribsion()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+
+            var handler = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handler.ShouldHandleAsync(null))
+             .WithAnyArguments()
+             .Returns(true);
+
+            // Act
+            broker.Subscribe(handler);
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task Unsubscribe_WithDelegate_RemovesSubscribsion()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+
+            var handler = A.Fake<IEventHandlerAsync<string>>();
+
+            // Act
+            broker.Subscribe<string>(handler.HandleAsync);
+            broker.Unsubscribe<string>(handler.HandleAsync);
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Unsubscribe_WithHandlerInstance_RemovesSubscribsion()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+
+            var handler = A.Fake<IEventHandlerAsync<string>>();
+
+            // Act
+            broker.Subscribe(handler);
+            broker.Unsubscribe(handler);
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Publish_WithHandlersFactory_HandlerIsRunned()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            var eventHandlersFactory = new EventHandlersFactory();
+            eventHandlersFactory.Add(() => handlerMock);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock.HandleAsync("event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task Publish_WithHandlersFactory_FilterIsRespected()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(false);
+
+            var eventHandlersFactory = new EventHandlersFactory();
+            eventHandlersFactory.Add(() => handlerMock);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock.HandleAsync("event"))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Publish_WithHandlersFactoryReturningNull_NothingHappens()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var eventHandlersFactory = new EventHandlersFactory();
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Publish_WithHandlerInstanceSubscription_FilterIsRespected()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(false);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe(handlerMock);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock.HandleAsync("event"))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Publish_WithDelegateSubscription_FilterIsRespected()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(false);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe<string>(handlerMock.HandleAsync, handlerMock.ShouldHandleAsync);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock.HandleAsync("event"))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Publish_WithMultipleSubscribers_AllHandlersAreRunned()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First()).ToList().ForEach(a => a.Invoke()));
+
+            var handlerMock1 = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock1.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            var eventHandlersFactory = new EventHandlersFactory();
+            eventHandlersFactory.Add(() => handlerMock1);
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            var handlerMock2 = A.Fake<IEventHandlerAsync<string>>();
+            A.CallTo(() => handlerMock2.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+            broker.Subscribe(handlerMock2);
+
+            var handlerMock3 = A.Fake<IEventHandlerAsync<string>>();
+            broker.Subscribe<string>(handlerMock3.HandleAsync);
+
+            var handlerMock4 = A.Fake<IEventHandlerAsync<int>>();
+            broker.Subscribe(handlerMock4);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerMock1.HandleAsync("event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock2.HandleAsync("event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock3.HandleAsync("event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock4.HandleAsync(A<int>.Ignored))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public void EventBroker_Dispose_DisposesIHandlerRunner()
+        {
+            // Arrange
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+
+            // Act
+            broker.Dispose();
+
+            // Assert
+            A.CallTo(() => handlerRunnerMock.Dispose())
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task Publish_WithDelegateSubscriptionUnsubscribedWhileWaiting_HandlerIsNotRunned()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x =>
+             {
+                 Task.Factory.StartNew(() =>
+                 {
+                     Thread.Sleep(500);
+                     ((Func<Task>[])x.Arguments.First())[0].Invoke();
+                 });
+             });
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe<string>(handlerMock.HandleAsync);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+            broker.Unsubscribe<string>(handlerMock.HandleAsync);
+
+            // Assert
+            Thread.Sleep(500);
+            A.CallTo(() => handlerRunnerMock.RunAsync(A<Func<Task>>.Ignored))
+             .MustHaveHappened(Repeated.Exactly.Once);
+
+            A.CallTo(() => handlerMock.HandleAsync("event"))
+             .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task SubscribedWithOnErrorDelegate_ExceptionThrownDuringHandling_OnExceptionIsCalled()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe<string>(handlerMock.HandleAsync, handlerMock.ShouldHandleAsync, handlerMock.OnErrorAsync);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, "event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task SubscribedWithoutOnErrorDelegate_ExceptionThrownDuringHandling_ExceptionIsMuted()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe<string>(handlerMock.HandleAsync, handlerMock.ShouldHandleAsync, null);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            Assert.True(true);
+        }
+
+        [Fact]
+        public async Task SubscribedWithOnErrorDelegate_ExceptionThrownDuringOnError_ExceptionIsMuted()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, A<string>.Ignored))
+             .Throws<Exception>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe<string>(handlerMock.HandleAsync, handlerMock.ShouldHandleAsync, handlerMock.OnErrorAsync);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            Assert.True(true);
+        }
+
+        [Fact]
+        public async Task SubscribedWithHandlerInstancee_ExceptionThrownDuringHandling_OnExceptionIsCalled()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe(handlerMock);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, "event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task SubscribedWithHandlerInstance_ExceptionThrownDuringOnError_ExceptionIsMuted()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, A<string>.Ignored))
+             .Throws<Exception>();
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock);
+            broker.Subscribe(handlerMock);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            Assert.True(true);
+        }
+
+        [Fact]
+        public async Task SubscribedWithHandlersFactory_ExceptionThrownDuringHandling_OnExceptionIsCalled()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            var eventHandlersFactory = new EventHandlersFactory();
+            eventHandlersFactory.Add(() => handlerMock);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, "event"))
+             .MustHaveHappened(Repeated.Exactly.Once);
+        }
+
+        [Fact]
+        public async Task SubscribedWithHandlersFactory_ExceptionThrownDuringOnError_ExceptionIsMuted()
+        {
+            // Arrange
+            var handlerMock = A.Fake<IEventHandlerAsync<string>>();
+
+            A.CallTo(() => handlerMock.ShouldHandleAsync(A<string>.Ignored))
+             .Returns(true);
+
+            A.CallTo(() => handlerMock.HandleAsync(A<string>.Ignored))
+             .Throws<Exception>();
+
+            A.CallTo(() => handlerMock.OnErrorAsync(A<Exception>.Ignored, A<string>.Ignored))
+             .Throws<Exception>();
+
+            var eventHandlersFactory = new EventHandlersFactory();
+            eventHandlersFactory.Add(() => handlerMock);
+
+            var handlerRunnerMock = A.Fake<IEventHandlerRunnerAsync>();
+
+            A.CallTo(() => handlerRunnerMock.RunAsync(null))
+             .WithAnyArguments()
+             .Invokes(x => ((Func<Task>[])x.Arguments.First())[0].Invoke());
+
+            var broker = new EventBrokerAsync(handlerRunnerMock, eventHandlersFactory);
+
+            // Act
+            await broker.PublishAsync("event").ConfigureAwait(false);
+
+            // Assert
+            Assert.True(true);
+        }
+
+        public class EventHandlersFactory : IEventHandlerAsyncFactory
+        {
+            private readonly List<(Type type, object handler)> _handlers = new List<(Type, object)>();
+
+            public void Add<T>(Func<IEventHandlerAsync<T>> handlerProvider)
+            {
+                _handlers.Add((typeof(T), handlerProvider));
+            }
+
+            public IEnumerable<IEventHandlerAsync<T>> AsyncHandlersFor<T>()
+            {
+                return _handlers.Count > 0
+                        ? _handlers.Where(x => x.type == typeof(T))
+                                 .Select(x => ((Func<IEventHandlerAsync<T>>)x.handler)())
+                                 .ToArray()
+                        : null;
+            }
+        }
+    }
+}
diff --git a/test/M.EventBroker.Tests/Async/IActionAsync.cs b/test/M.EventBroker.Tests/Async/IActionAsync.cs
new file mode 100644
index 0000000..bdaedfc
--- /dev/null
+++ b/test/M.EventBroker.Tests/Async/IActionAsync.cs
@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace M.EventBroker.Tests
+{
+    public interface IActionAsync
+    {
+        Task Action();
+    }
+}