diff --git a/src/Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection/CqrsInjector.cs b/src/Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection/CqrsInjector.cs
index 5b0272a..15da06e 100644
--- a/src/Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection/CqrsInjector.cs
+++ b/src/Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection/CqrsInjector.cs
@@ -111,9 +111,9 @@ public CqrsInjector AddRemoteQueryCache<TRemote>(Action<CacheableRequestOptions>
     ///     Use default implementation of <see cref="IFileProvider"/> that accesses file system directly.
     /// </summary>
     /// <returns></returns>
-    public CqrsInjector UseDefaultFileProvider()
+    public CqrsInjector AddDefaultFileProvider()
     {
-        return UseFileProvider<DefaultFileProvider>();
+        return AddFileProvider<DefaultFileProvider>();
     }
 
     /// <summary>
@@ -121,7 +121,7 @@ public CqrsInjector UseDefaultFileProvider()
     /// </summary>
     /// <typeparam name="TProvider">The implementation type.</typeparam>
     /// <returns></returns>
-    public CqrsInjector UseFileProvider<TProvider>()
+    public CqrsInjector AddFileProvider<TProvider>()
         where TProvider : class, IFileProvider
     {
         Services.AddScoped<IFileProvider, TProvider>();
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/BufferedIntegrationEvent.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/BufferedIntegrationEvent.cs
new file mode 100644
index 0000000..47c56b7
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/BufferedIntegrationEvent.cs
@@ -0,0 +1,8 @@
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     The integration event stored in buffer.
+/// </summary>
+/// <param name="Name">The event name.</param>
+/// <param name="Event">The event data.</param>
+public record BufferedIntegrationEvent(string Name, IntegrationEvent Event);
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/Cnblogs.Architecture.Ddd.EventBus.Abstractions.csproj b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/Cnblogs.Architecture.Ddd.EventBus.Abstractions.csproj
index cf45e84..8f83a44 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/Cnblogs.Architecture.Ddd.EventBus.Abstractions.csproj
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/Cnblogs.Architecture.Ddd.EventBus.Abstractions.csproj
@@ -6,6 +6,6 @@
     </Description>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="MediatR" Version="12.1.1" />
+    <ProjectReference Include="..\Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection\Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBus.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/DefaultEventBus.cs
similarity index 51%
rename from src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBus.cs
rename to src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/DefaultEventBus.cs
index a107de6..f9277bc 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBus.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/DefaultEventBus.cs
@@ -1,61 +1,44 @@
-using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
-using Dapr.Client;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 
-namespace Cnblogs.Architecture.Ddd.EventBus.Dapr;
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
 
 /// <summary>
-///     Dapr EventBus 实现。
+///     Default implementation for <see cref="IEventBus"/>
 /// </summary>
-public class DaprEventBus : IEventBus
+public class DefaultEventBus : IEventBus
 {
-    private readonly DaprClient _daprClient;
-    private readonly DaprOptions _daprOptions;
+    private readonly IEventBuffer _eventBuffer;
     private readonly IMediator _mediator;
-    private readonly ILogger<DaprEventBus> _logger;
+    private readonly ILogger<DefaultEventBus> _logger;
 
     /// <summary>
-    ///     创建一个 DaprEventBus
+    ///     Create a <see cref="DefaultEventBus"/> instance.
     /// </summary>
-    /// <param name="daprOptions"><see cref="DaprOptions"/></param>
-    /// <param name="daprClient"><see cref="DaprClient"/></param>
-    /// <param name="logger">日志记录器。</param>
-    /// <param name="mediator"><see cref="IMediator"/></param>
-    public DaprEventBus(
-        IOptions<DaprOptions> daprOptions,
-        DaprClient daprClient,
-        IMediator mediator,
-        ILogger<DaprEventBus> logger)
+    /// <param name="eventBuffer">The underlying event buffer.</param>
+    /// <param name="mediator">The IMediator.</param>
+    /// <param name="logger">The logger.</param>
+    public DefaultEventBus(IEventBuffer eventBuffer, IMediator mediator, ILogger<DefaultEventBus> logger)
     {
-        _daprClient = daprClient;
+        _eventBuffer = eventBuffer;
         _logger = logger;
         _mediator = mediator;
-        _daprOptions = daprOptions.Value;
     }
 
     /// <inheritdoc />
-    public async Task PublishAsync<TEvent>(TEvent @event)
+    public Task PublishAsync<TEvent>(TEvent @event)
         where TEvent : IntegrationEvent
     {
-        await PublishAsync(typeof(TEvent).Name, @event);
+        return PublishAsync(typeof(TEvent).Name, @event);
     }
 
     /// <inheritdoc />
-    public async Task PublishAsync<TEvent>(string eventName, TEvent @event)
+    public Task PublishAsync<TEvent>(string eventName, TEvent @event)
         where TEvent : IntegrationEvent
     {
-        _logger.LogInformation(
-            "Publishing IntegrationEvent, Name: {EventName}, Body: {Event}, TraceId: {TraceId}",
-            eventName,
-            @event,
-            @event.TraceId ?? @event.Id);
         @event.TraceId = TraceId;
-        await _daprClient.PublishEventAsync(
-            DaprOptions.PubSubName,
-            DaprUtils.GetDaprTopicName(_daprOptions.AppName, eventName),
-            @event);
+        _eventBuffer.Add(eventName, @event);
+        return Task.CompletedTask;
     }
 
     /// <inheritdoc />
@@ -97,4 +80,4 @@ public Task ReceiveAsync<TEvent>(TEvent receivedEvent)
 
     /// <inheritdoc />
     public Guid? TraceId { get; set; }
-}
\ No newline at end of file
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptions.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptions.cs
new file mode 100644
index 0000000..82b5289
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptions.cs
@@ -0,0 +1,19 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Options for event bus.
+/// </summary>
+public class EventBusOptions
+{
+    /// <summary>
+    ///     The service collection for
+    /// </summary>
+    public IServiceCollection? Services { get; set; }
+
+    /// <summary>
+    ///     Interval for publish integration event.
+    /// </summary>
+    public int Interval { get; set; } = 1;
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptionsBuilder.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptionsBuilder.cs
new file mode 100644
index 0000000..1c8d549
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusOptionsBuilder.cs
@@ -0,0 +1,36 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Builder for <see cref="EventBusOptions"/>.
+/// </summary>
+public class EventBusOptionsBuilder
+{
+    /// <summary>
+    ///     Create a <see cref="EventBusOptionsBuilder"/>.
+    /// </summary>
+    /// <param name="services"></param>
+    public EventBusOptionsBuilder(IServiceCollection services)
+    {
+        Services = services;
+    }
+
+    /// <summary>
+    ///     Internal service collection.
+    /// </summary>
+    public IServiceCollection Services { get; }
+
+    /// <summary>
+    ///     The interval in milliseconds for checking pending integration events.
+    /// </summary>
+    public int Interval { get; set; } = 1000;
+
+    internal Action<EventBusOptions> GetConfiguration()
+    {
+        return o =>
+        {
+            o.Interval = Interval;
+        };
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusServiceInjector.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusServiceInjector.cs
new file mode 100644
index 0000000..357cbf0
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/EventBusServiceInjector.cs
@@ -0,0 +1,54 @@
+using System.Reflection;
+using Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Extension methods for injecting <see cref="IEventBus"/> to service collection.
+/// </summary>
+public static class EventBusServiceInjector
+{
+    /// <summary>
+    ///     Add event bus for integration event support.
+    /// </summary>
+    /// <param name="services">The services.</param>
+    /// <param name="configuration">Extra configurations for event bus.</param>
+    /// <param name="handlerAssemblies">The assemblies for handlers.</param>
+    /// <returns><see cref="IServiceCollection"/>.</returns>
+    public static IServiceCollection AddEventBus(
+        this IServiceCollection services,
+        Action<EventBusOptionsBuilder>? configuration = null,
+        params Assembly[] handlerAssemblies)
+    {
+        services.TryAddSingleton<IEventBuffer, InMemoryEventBuffer>();
+        services.TryAddScoped<IEventBus, DefaultEventBus>();
+        services.AddHostedService<PublishIntegrationEventHostedService>();
+        var builder = new EventBusOptionsBuilder(services);
+        configuration?.Invoke(builder);
+        services.Configure(builder.GetConfiguration());
+        if (handlerAssemblies.Length > 0)
+        {
+            services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(handlerAssemblies));
+        }
+
+        return services;
+    }
+
+    /// <summary>
+    ///     Add event bus for integration event support.
+    /// </summary>
+    /// <param name="cqrsInjector">The <see cref="CqrsInjector"/>.</param>
+    /// <param name="configuration">The configuration.</param>
+    /// <param name="handlerAssemblies">The assemblies for handlers.</param>
+    /// <returns></returns>
+    public static CqrsInjector AddEventBus(
+        this CqrsInjector cqrsInjector,
+        Action<EventBusOptionsBuilder>? configuration = null,
+        params Assembly[] handlerAssemblies)
+    {
+        cqrsInjector.Services.AddEventBus(configuration, handlerAssemblies);
+        return cqrsInjector;
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBuffer.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBuffer.cs
new file mode 100644
index 0000000..17970e1
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBuffer.cs
@@ -0,0 +1,33 @@
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Buffer for integration events.
+/// </summary>
+public interface IEventBuffer
+{
+    /// <summary>
+    ///     Number of pending events.
+    /// </summary>
+    int Count { get; }
+
+    /// <summary>
+    ///     Add an event to buffer.
+    /// </summary>
+    /// <param name="name">The name of integration event.</param>
+    /// <param name="event">The event.</param>
+    /// <typeparam name="TEvent">The type of integration event.</typeparam>
+    void Add<TEvent>(string name, TEvent @event)
+        where TEvent : IntegrationEvent;
+
+    /// <summary>
+    ///     Get an integration event without removing it.
+    /// </summary>
+    /// <returns>The integration event, <c>null</c> will be returned if buffer is empty.</returns>
+    BufferedIntegrationEvent? Peek();
+
+    /// <summary>
+    ///     Get an integration event and remove it.
+    /// </summary>
+    /// <returns>The integration event, <c>null</c> will be returned if buffer is empty.</returns>
+    BufferedIntegrationEvent? Pop();
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusProvider.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusProvider.cs
new file mode 100644
index 0000000..527c19e
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusProvider.cs
@@ -0,0 +1,15 @@
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Provider contract for event bus.
+/// </summary>
+public interface IEventBusProvider
+{
+    /// <summary>
+    ///     Emit an integration event.
+    /// </summary>
+    /// <param name="eventName">The name of the event.</param>
+    /// <param name="event">The event body.</param>
+    /// <returns></returns>
+    Task PublishAsync(string eventName, IntegrationEvent @event);
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusHandler.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusRequestHandler.cs
similarity index 77%
rename from src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusHandler.cs
rename to src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusRequestHandler.cs
index 15a10f0..e5dc196 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusHandler.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IEventBusRequestHandler.cs
@@ -3,6 +3,6 @@ namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
 /// <summary>
 /// The empty interface as a generic type constraint
 /// </summary>
-public interface IEventBusHandler
+public interface IEventBusRequestHandler
 {
 }
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IIntegrationEventHandler.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IIntegrationEventHandler.cs
index f533225..3968f00 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IIntegrationEventHandler.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/IIntegrationEventHandler.cs
@@ -6,7 +6,7 @@ namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
 /// 集成事件处理器。
 /// </summary>
 /// <typeparam name="TEvent">集成事件。</typeparam>
-public interface IIntegrationEventHandler<TEvent> : INotificationHandler<TEvent>, IEventBusHandler
+public interface IIntegrationEventHandler<TEvent> : INotificationHandler<TEvent>, IEventBusRequestHandler
     where TEvent : IntegrationEvent
 {
 }
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/InMemoryEventBuffer.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/InMemoryEventBuffer.cs
new file mode 100644
index 0000000..82b8898
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/InMemoryEventBuffer.cs
@@ -0,0 +1,33 @@
+using System.Collections.Concurrent;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     Implementation of <see cref="IEventBuffer"/> using <see cref="ConcurrentQueue{T}"/>.
+/// </summary>
+public class InMemoryEventBuffer : IEventBuffer
+{
+    private readonly ConcurrentQueue<BufferedIntegrationEvent> _queue = new();
+
+    /// <inheritdoc />
+    public int Count => _queue.Count;
+
+    /// <inheritdoc />
+    public void Add<TEvent>(string name, TEvent @event)
+        where TEvent : IntegrationEvent
+    {
+        _queue.Enqueue(new BufferedIntegrationEvent(name, @event));
+    }
+
+    /// <inheritdoc />
+    public BufferedIntegrationEvent? Peek()
+    {
+        return _queue.TryPeek(out var @event) ? @event : null;
+    }
+
+    /// <inheritdoc />
+    public BufferedIntegrationEvent? Pop()
+    {
+        return _queue.TryDequeue(out var @event) ? @event : null;
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/PublishIntegrationEventHostedService.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/PublishIntegrationEventHostedService.cs
new file mode 100644
index 0000000..041c718
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Abstractions/PublishIntegrationEventHostedService.cs
@@ -0,0 +1,87 @@
+using System.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+
+/// <summary>
+///     The hosted service for publishing integration event at background.
+/// </summary>
+public sealed class PublishIntegrationEventHostedService : BackgroundService
+{
+    private readonly EventBusOptions _options;
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IEventBuffer _eventBuffer;
+    private readonly ILogger<PublishIntegrationEventHostedService> _logger;
+
+    /// <summary>
+    ///     Create a <see cref="PublishIntegrationEventHostedService"/>.
+    /// </summary>
+    /// <param name="options">The event bus options.</param>
+    /// <param name="serviceProvider">The service provider.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="eventBuffer">The buffer for integration events.</param>
+    public PublishIntegrationEventHostedService(
+        IOptions<EventBusOptions> options,
+        IServiceProvider serviceProvider,
+        ILogger<PublishIntegrationEventHostedService> logger,
+        IEventBuffer eventBuffer)
+    {
+        _options = options.Value;
+        _serviceProvider = serviceProvider;
+        _logger = logger;
+        _eventBuffer = eventBuffer;
+    }
+
+    /// <inheritdoc />
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        _logger.LogInformation("Integration event publisher running.");
+        var watch = new Stopwatch();
+        using var timer = new PeriodicTimer(TimeSpan.FromMicroseconds(_options.Interval));
+        while (await timer.WaitForNextTickAsync(stoppingToken))
+        {
+            try
+            {
+                watch.Restart();
+                var beforeCount = _eventBuffer.Count;
+                await PublishEventAsync();
+                watch.Stop();
+                var afterCount = _eventBuffer.Count;
+                _logger.LogInformation(
+                    "Published {PublishedEventCount} events in {Duration} ms, resting count: {RestingEventCount}",
+                    beforeCount - afterCount,
+                    watch.ElapsedMilliseconds,
+                    afterCount);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Publish integration event failed, pending count: {Count}", _eventBuffer.Count);
+            }
+        }
+    }
+
+    private async Task PublishEventAsync()
+    {
+        if (_eventBuffer.Count == 0)
+        {
+            return;
+        }
+
+        using var scope = _serviceProvider.CreateScope();
+        var provider = scope.ServiceProvider.GetRequiredService<IEventBusProvider>();
+        while (_eventBuffer.Count > 0)
+        {
+            var buffered = _eventBuffer.Peek();
+            if (buffered is null)
+            {
+                return;
+            }
+
+            await provider.PublishAsync(buffered.Name, buffered.Event);
+            _eventBuffer.Pop();
+        }
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/Cnblogs.Architecture.Ddd.EventBus.Dapr.csproj b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/Cnblogs.Architecture.Ddd.EventBus.Dapr.csproj
index 8fa239b..d79a384 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/Cnblogs.Architecture.Ddd.EventBus.Dapr.csproj
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/Cnblogs.Architecture.Ddd.EventBus.Dapr.csproj
@@ -7,7 +7,6 @@
   <ItemGroup>
     <ProjectReference Include="..\Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection\Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection.csproj" />
     <ProjectReference Include="..\Cnblogs.Architecture.Ddd.EventBus.Abstractions\Cnblogs.Architecture.Ddd.EventBus.Abstractions.csproj" />
-    <FrameworkReference Include="Microsoft.AspNetCore.App" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Dapr.AspNetCore" Version="1.11.0" />
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/CqrsInjectorExtensions.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/CqrsInjectorExtensions.cs
index 63ce26e..c81873a 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/CqrsInjectorExtensions.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/CqrsInjectorExtensions.cs
@@ -1,7 +1,6 @@
 using System.Reflection;
 using Cnblogs.Architecture.Ddd.Cqrs.DependencyInjection;
 using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Cnblogs.Architecture.Ddd.EventBus.Dapr;
 
@@ -16,16 +15,10 @@ public static class CqrsInjectorExtensions
     /// <param name="cqrsInjector"><see cref="CqrsInjector"/></param>
     /// <param name="integrationEventAssembly">集成事件所在的 Assembly。</param>
     /// <returns></returns>
+    [Obsolete("Use builder.AddCqrs().AddEventBus(o => o.UseDapr(assembly)) instead.", true)]
     public static CqrsInjector AddDaprEventBus(this CqrsInjector cqrsInjector, Assembly integrationEventAssembly)
     {
-        var appName = integrationEventAssembly.GetCustomAttribute<AssemblyAppNameAttribute>();
-        if (appName is null)
-        {
-            throw new InvalidOperationException(
-                "No AssemblyAppNameAttribute was found, add attribute to Assembly or specify AppName with AddDaprEventBus(string appName)");
-        }
-
-        return cqrsInjector.AddDaprEventBus(appName.Name);
+        return cqrsInjector.AddEventBus(o => o.UseDapr(integrationEventAssembly));
     }
 
     /// <summary>
@@ -34,9 +27,10 @@ public static CqrsInjector AddDaprEventBus(this CqrsInjector cqrsInjector, Assem
     /// <param name="cqrsInjector"><see cref="CqrsInjector"/></param>
     /// <param name="appName">发布事件时使用的 appName。</param>
     /// <returns></returns>
+    [Obsolete("Use builder.AddCqrs().AddEventBus(o => o.UseDapr(appName)) instead.", true)]
     public static CqrsInjector AddDaprEventBus(this CqrsInjector cqrsInjector, string appName)
     {
-        cqrsInjector.Services.AddDaprEventBus(appName);
+        cqrsInjector.AddEventBus(o => o.UseDapr(appName));
         return cqrsInjector;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusInjector.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusInjector.cs
new file mode 100644
index 0000000..cb5d981
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusInjector.cs
@@ -0,0 +1,44 @@
+using System.Reflection;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Dapr;
+
+/// <summary>
+///     Injector methods for dapr event bus.
+/// </summary>
+public static class DaprEventBusInjector
+{
+    /// <summary>
+    ///     Use dapr as event bus provider.
+    /// </summary>
+    /// <param name="builder">The <see cref="EventBusOptionsBuilder"/>.</param>
+    /// <param name="integrationEventAssembly">The assembly of integration events of current app.</param>
+    /// <returns></returns>
+    public static EventBusOptionsBuilder UseDapr(this EventBusOptionsBuilder builder, Assembly integrationEventAssembly)
+    {
+        var appName = integrationEventAssembly.GetCustomAttribute<AssemblyAppNameAttribute>();
+        if (appName is null)
+        {
+            throw new InvalidOperationException(
+                "No AssemblyAppNameAttribute was found, add attribute to Assembly or specify AppName with AddDaprEventBus(string appName)");
+        }
+
+        return builder.UseDapr(appName.Name);
+    }
+
+    /// <summary>
+    ///     Use dapr as event bus provider.
+    /// </summary>
+    /// <param name="builder">The <see cref="EventBusOptionsBuilder"/>.</param>
+    /// <param name="appName">The name of current app.</param>
+    /// <returns></returns>
+    public static EventBusOptionsBuilder UseDapr(this EventBusOptionsBuilder builder, string appName)
+    {
+        var services = builder.Services;
+        services.Configure<DaprOptions>(o => o.AppName = appName);
+        services.AddControllers().AddDapr();
+        services.AddScoped<IEventBusProvider, DaprEventBusProvider>();
+        return builder;
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusProvider.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusProvider.cs
new file mode 100644
index 0000000..dbdc62c
--- /dev/null
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusProvider.cs
@@ -0,0 +1,46 @@
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Dapr.Client;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Cnblogs.Architecture.Ddd.EventBus.Dapr;
+
+/// <summary>
+///     Implementations for <see cref="IEventBusProvider"/> using Dapr.
+/// </summary>
+public class DaprEventBusProvider : IEventBusProvider
+{
+    private readonly DaprClient _daprClient;
+    private readonly DaprOptions _daprOptions;
+    private readonly ILogger<DaprEventBusProvider> _logger;
+
+    /// <summary>
+    ///     Create a <see cref="DaprEventBusProvider"/>.
+    /// </summary>
+    /// <param name="daprClient">The underlying dapr client.</param>
+    /// <param name="daprOptions">The options for dapr.</param>
+    /// <param name="logger">The logger.</param>
+    public DaprEventBusProvider(
+        DaprClient daprClient,
+        IOptions<DaprOptions> daprOptions,
+        ILogger<DaprEventBusProvider> logger)
+    {
+        _daprClient = daprClient;
+        _daprOptions = daprOptions.Value;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task PublishAsync(string eventName, IntegrationEvent @event)
+    {
+        _logger.LogInformation(
+            "Publishing IntegrationEvent, Name: {EventName}, Body: {Event}, TraceId: {TraceId}",
+            eventName,
+            @event,
+            @event.TraceId ?? @event.Id);
+        await _daprClient.PublishEventAsync(
+            DaprOptions.PubSubName,
+            DaprUtils.GetDaprTopicName(_daprOptions.AppName, eventName),
+            @event);
+    }
+}
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusServiceCollectionExtensions.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusServiceCollectionExtensions.cs
index cb8f7fa..7c8f69f 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusServiceCollectionExtensions.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/DaprEventBusServiceCollectionExtensions.cs
@@ -19,20 +19,13 @@ public static class DaprEventBusServiceCollectionExtensions
     /// <param name="appName">The app name used when publishing integration events.</param>
     /// <param name="assemblies">Assemblies to scan by MediatR</param>
     /// <returns></returns>
+    [Obsolete("use services.AddEventBus(o => o.UseDapr(), assemblies) instead.", true)]
     public static IServiceCollection AddDaprEventBus(
         this IServiceCollection services,
         string appName,
         params Assembly[] assemblies)
     {
-        services.Configure<DaprOptions>(o => o.AppName = appName);
-        services.AddControllers().AddDapr();
-        services.AddScoped<IEventBus, DaprEventBus>();
-
-        if (assemblies.Length > 0)
-        {
-            services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(assemblies));
-        }
-
+        services.AddEventBus(o => o.UseDapr(appName), assemblies);
         return services;
     }
 }
diff --git a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/EndPointExtensions.cs b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/EndPointExtensions.cs
index c8830fb..221788d 100644
--- a/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/EndPointExtensions.cs
+++ b/src/Cnblogs.Architecture.Ddd.EventBus.Dapr/EndPointExtensions.cs
@@ -90,7 +90,7 @@ public static IEndpointRouteBuilder Subscribe(this IEndpointRouteBuilder builder
     /// <typeparam name="TEventHandler">The integration event handler that implements <![CDATA[IIntegrationEventHandler<TEvent>]]></typeparam>
     /// <param name="builder"><see cref="IEndpointRouteBuilder"/></param>
     public static IEndpointRouteBuilder SubscribeByEventHandler<TEventHandler>(this IEndpointRouteBuilder builder)
-        where TEventHandler : IEventBusHandler
+        where TEventHandler : IEventBusRequestHandler
     {
         return builder.SubscribeByEventHandler(typeof(TEventHandler));
     }
diff --git a/src/Cnblogs.Architecture.Ddd.Infrastructure.FileProviders.AliyunOss/CqrsInjectorExtensions.cs b/src/Cnblogs.Architecture.Ddd.Infrastructure.FileProviders.AliyunOss/CqrsInjectorExtensions.cs
index b03c7cb..ebad89e 100644
--- a/src/Cnblogs.Architecture.Ddd.Infrastructure.FileProviders.AliyunOss/CqrsInjectorExtensions.cs
+++ b/src/Cnblogs.Architecture.Ddd.Infrastructure.FileProviders.AliyunOss/CqrsInjectorExtensions.cs
@@ -24,6 +24,6 @@ public static CqrsInjector UseAliyunOssFileProvider(
     {
         injector.Services.AddOssClient(configuration, configurationSectionName);
         injector.Services.Configure<AliyunOssOptions>(configuration.GetSection(configurationSectionName));
-        return injector.UseFileProvider<AliyunOssFileProvider>();
+        return injector.AddFileProvider<AliyunOssFileProvider>();
     }
 }
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CommandHandlers.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CommandHandlers.cs
index abcc139..1496920 100644
--- a/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CommandHandlers.cs
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CommandHandlers.cs
@@ -1,5 +1,7 @@
 using Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
 using Cnblogs.Architecture.IntegrationTestProject.Application.Errors;
+using Cnblogs.Architecture.IntegrationTestProject.Domain.Events;
+using MediatR;
 
 namespace Cnblogs.Architecture.IntegrationTestProject.Application.Commands;
 
@@ -7,27 +9,37 @@ public class CommandHandlers
     : ICommandHandler<CreateCommand, TestError>, ICommandHandler<UpdateCommand, TestError>,
         ICommandHandler<DeleteCommand, TestError>
 {
+    private readonly IMediator _mediator;
+
+    public CommandHandlers(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
     /// <inheritdoc />
-    public Task<CommandResponse<TestError>> Handle(CreateCommand request, CancellationToken cancellationToken)
+    public async Task<CommandResponse<TestError>> Handle(CreateCommand request, CancellationToken cancellationToken)
     {
-        return Task.FromResult(request.NeedError
-            ? CommandResponse<TestError>.Fail(TestError.Default)
-            : CommandResponse<TestError>.Success());
+        await _mediator.Publish(new StringCreatedDomainEvent(request.Data ?? string.Empty), cancellationToken);
+        return request.NeedError
+                ? CommandResponse<TestError>.Fail(TestError.Default)
+                : CommandResponse<TestError>.Success();
     }
 
     /// <inheritdoc />
     public Task<CommandResponse<TestError>> Handle(UpdateCommand request, CancellationToken cancellationToken)
     {
-        return Task.FromResult(request.NeedExecutionError
-            ? CommandResponse<TestError>.Fail(TestError.Default)
-            : CommandResponse<TestError>.Success());
+        return Task.FromResult(
+            request.NeedExecutionError
+                ? CommandResponse<TestError>.Fail(TestError.Default)
+                : CommandResponse<TestError>.Success());
     }
 
     /// <inheritdoc />
     public Task<CommandResponse<TestError>> Handle(DeleteCommand request, CancellationToken cancellationToken)
     {
-        return Task.FromResult(request.NeedError
-            ? CommandResponse<TestError>.Fail(TestError.Default)
-            : CommandResponse<TestError>.Success());
+        return Task.FromResult(
+            request.NeedError
+                ? CommandResponse<TestError>.Fail(TestError.Default)
+                : CommandResponse<TestError>.Success());
     }
-}
\ No newline at end of file
+}
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CreateCommand.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CreateCommand.cs
index 9909c70..eeb78ef 100644
--- a/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CreateCommand.cs
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Application/Commands/CreateCommand.cs
@@ -3,4 +3,4 @@
 
 namespace Cnblogs.Architecture.IntegrationTestProject.Application.Commands;
 
-public record CreateCommand(bool NeedError, bool ValidateOnly = false) : ICommand<TestError>;
\ No newline at end of file
+public record CreateCommand(bool NeedError, string? Data = null, bool ValidateOnly = false) : ICommand<TestError>;
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Application/EventHandlers/StringCreatedEventHandler.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Application/EventHandlers/StringCreatedEventHandler.cs
new file mode 100644
index 0000000..57ce6cb
--- /dev/null
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Application/EventHandlers/StringCreatedEventHandler.cs
@@ -0,0 +1,22 @@
+using Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Cnblogs.Architecture.IntegrationTestProject.Domain.Events;
+using Cnblogs.Architecture.TestIntegrationEvents;
+
+namespace Cnblogs.Architecture.IntegrationTestProject.Application.EventHandlers;
+
+public class StringCreatedEventHandler : IDomainEventHandler<StringCreatedDomainEvent>
+{
+    private readonly IEventBus _eventBus;
+
+    public StringCreatedEventHandler(IEventBus eventBus)
+    {
+        _eventBus = eventBus;
+    }
+
+    /// <inheritdoc />
+    public async Task Handle(StringCreatedDomainEvent notification, CancellationToken cancellationToken)
+    {
+        await _eventBus.PublishAsync(new TestIntegrationEvent(Guid.NewGuid(), DateTimeOffset.Now, notification.Data));
+    }
+}
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Cnblogs.Architecture.IntegrationTestProject.csproj b/test/Cnblogs.Architecture.IntegrationTestProject/Cnblogs.Architecture.IntegrationTestProject.csproj
index 99d0d0c..1b9b076 100644
--- a/test/Cnblogs.Architecture.IntegrationTestProject/Cnblogs.Architecture.IntegrationTestProject.csproj
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Cnblogs.Architecture.IntegrationTestProject.csproj
@@ -9,4 +9,7 @@
     <ProjectReference Include="..\Cnblogs.Architecture.TestIntegrationEvents\Cnblogs.Architecture.TestIntegrationEvents.csproj" />
   </ItemGroup>
 
+
+
+
 </Project>
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Domain/Events/StringCreatedDomainEvent.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Domain/Events/StringCreatedDomainEvent.cs
new file mode 100644
index 0000000..fa075ca
--- /dev/null
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Domain/Events/StringCreatedDomainEvent.cs
@@ -0,0 +1,5 @@
+using Cnblogs.Architecture.Ddd.Domain.Abstractions;
+
+namespace Cnblogs.Architecture.IntegrationTestProject.Domain.Events;
+
+public record StringCreatedDomainEvent(string Data) : DomainEvent;
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Payloads/CreatePayload.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Payloads/CreatePayload.cs
index 6cabfc4..65b7eac 100644
--- a/test/Cnblogs.Architecture.IntegrationTestProject/Payloads/CreatePayload.cs
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Payloads/CreatePayload.cs
@@ -1,3 +1,3 @@
 namespace Cnblogs.Architecture.IntegrationTestProject.Payloads;
 
-public record CreatePayload(bool NeedError);
\ No newline at end of file
+public record CreatePayload(bool NeedError, string? Data);
diff --git a/test/Cnblogs.Architecture.IntegrationTestProject/Program.cs b/test/Cnblogs.Architecture.IntegrationTestProject/Program.cs
index 8c7f2a8..9adca7b 100644
--- a/test/Cnblogs.Architecture.IntegrationTestProject/Program.cs
+++ b/test/Cnblogs.Architecture.IntegrationTestProject/Program.cs
@@ -1,5 +1,6 @@
 using System.Reflection;
 using Cnblogs.Architecture.Ddd.Cqrs.AspNetCore;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
 using Cnblogs.Architecture.Ddd.EventBus.Dapr;
 using Cnblogs.Architecture.IntegrationTestProject;
 using Cnblogs.Architecture.IntegrationTestProject.Application.Commands;
@@ -11,7 +12,7 @@
 
 builder.Services.AddCqrs(Assembly.GetExecutingAssembly(), typeof(TestIntegrationEvent).Assembly)
     .AddDefaultDateTimeAndRandomProvider()
-    .AddDaprEventBus(Constants.AppName);
+    .AddEventBus(o => o.UseDapr(Constants.AppName));
 builder.Services.AddControllers().AddCqrsModelBinderProvider();
 
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
@@ -38,7 +39,7 @@
 v1.MapQuery<GetStringQuery>("apps/{appId}/strings/{stringId:int}/value", MapNullableRouteParameter.Enable, enableHead: true);
 v1.MapQuery<GetStringQuery>("strings/{id:int}");
 v1.MapQuery<ListStringsQuery>("strings");
-v1.MapCommand("strings", (CreatePayload payload) => new CreateCommand(payload.NeedError));
+v1.MapCommand("strings", (CreatePayload payload) => new CreateCommand(payload.NeedError, payload.Data));
 v1.MapCommand(
     "strings/{id:int}",
     (int id, UpdatePayload payload) => new UpdateCommand(id, payload.NeedValidationError, payload.NeedExecutionError));
diff --git a/test/Cnblogs.Architecture.IntegrationTests/DaprTests.cs b/test/Cnblogs.Architecture.IntegrationTests/DaprTests.cs
index e480264..a017ad5 100644
--- a/test/Cnblogs.Architecture.IntegrationTests/DaprTests.cs
+++ b/test/Cnblogs.Architecture.IntegrationTests/DaprTests.cs
@@ -1,4 +1,6 @@
 using System.Net;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Cnblogs.Architecture.Ddd.EventBus.Dapr;
 using Cnblogs.Architecture.IntegrationTestProject.EventHandlers;
 using Cnblogs.Architecture.TestIntegrationEvents;
 using FluentAssertions;
@@ -19,10 +21,10 @@ public async Task Dapr_SubscribeEndpoint_OkAsync(SubscribeType subscribeType)
     {
         // Arrange
         var builder = WebApplication.CreateBuilder();
-        builder.Services.AddDaprEventBus(nameof(DaprTests));
+        builder.Services.AddEventBus(o => o.UseDapr(nameof(DaprTests)));
         builder.WebHost.UseTestServer();
 
-        using var app = builder.Build();
+        await using var app = builder.Build();
 
         _ = subscribeType switch
         {
@@ -51,7 +53,7 @@ public async Task Dapr_SubscribeWithoutAnyAssembly_OkAsync()
     {
         // Arrange
         var builder = WebApplication.CreateBuilder();
-        builder.Services.AddDaprEventBus(nameof(DaprTests));
+        builder.Services.AddEventBus(o => o.UseDapr(nameof(DaprTests)));
         builder.WebHost.UseTestServer();
 
         var app = builder.Build();
diff --git a/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventHandlerTests.cs b/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventHandlerTests.cs
index a1f6306..f078764 100644
--- a/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventHandlerTests.cs
+++ b/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventHandlerTests.cs
@@ -1,10 +1,11 @@
 using System.Net.Http.Json;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Cnblogs.Architecture.Ddd.EventBus.Dapr;
 using Cnblogs.Architecture.IntegrationTestProject.EventHandlers;
 using Cnblogs.Architecture.TestIntegrationEvents;
 using FluentAssertions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.TestHost;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Serilog;
 using Serilog.Sinks.InMemory;
@@ -29,8 +30,9 @@ public async Task IntegrationEventHandler_TestIntegrationEvent_SuccessAsync()
         // Arrange
         var builder = WebApplication.CreateBuilder();
         builder.Logging.AddSerilog(logger => logger.WriteTo.InMemory().WriteTo.Console());
-        builder.Services
-            .AddDaprEventBus(nameof(IntegrationEventHandlerTests), typeof(TestIntegrationEventHandler).Assembly);
+        builder.Services.AddEventBus(
+            o => o.UseDapr(nameof(IntegrationEventHandlerTests)),
+            typeof(TestIntegrationEventHandler).Assembly);
         builder.WebHost.UseTestServer();
         var app = builder.Build();
         app.Subscribe<TestIntegrationEvent>();
diff --git a/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventPublishTests.cs b/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventPublishTests.cs
new file mode 100644
index 0000000..979f39a
--- /dev/null
+++ b/test/Cnblogs.Architecture.IntegrationTests/IntegrationEventPublishTests.cs
@@ -0,0 +1,45 @@
+using System.Net.Http.Json;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Cnblogs.Architecture.IntegrationTestProject;
+using Cnblogs.Architecture.IntegrationTestProject.Payloads;
+using Cnblogs.Architecture.TestIntegrationEvents;
+using FluentAssertions;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Moq;
+
+namespace Cnblogs.Architecture.IntegrationTests;
+
+public class IntegrationEventPublishTests
+{
+    [Fact]
+    public async Task EventBus_PublishEvent_SuccessAsync()
+    {
+        // Arrange
+        const string data = "hello";
+        var builder = new WebApplicationFactory<Program>();
+        var eventBusMock = new Mock<IEventBusProvider>();
+        builder = builder.WithWebHostBuilder(
+            b => b.ConfigureServices(
+                services =>
+                {
+                    services.RemoveAll<IEventBusProvider>();
+                    services.AddScoped<IEventBusProvider>(_ => eventBusMock.Object);
+                }));
+
+        // Act
+        var response = await builder.CreateClient().PostAsJsonAsync(
+            "/api/v1/strings",
+            new CreatePayload(false, data));
+        var content = await response.Content.ReadAsStringAsync();
+        await Task.Delay(1500);
+
+        // Assert
+        response.Should().BeSuccessful();
+        content.Should().BeNullOrEmpty();
+        eventBusMock.Verify(
+            x => x.PublishAsync(It.IsAny<string>(), It.Is<TestIntegrationEvent>(t => t.Message == data)),
+            Times.Once);
+    }
+}
diff --git a/test/Cnblogs.Architecture.TestShared/Cnblogs.Architecture.TestShared.csproj b/test/Cnblogs.Architecture.TestShared/Cnblogs.Architecture.TestShared.csproj
index b1f332d..89dca54 100644
--- a/test/Cnblogs.Architecture.TestShared/Cnblogs.Architecture.TestShared.csproj
+++ b/test/Cnblogs.Architecture.TestShared/Cnblogs.Architecture.TestShared.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <ItemGroup>
         <PackageReference Include="FluentAssertions" Version="6.11.0" />
-        <PackageReference Include="Moq" Version="4.18.4" />
+        <PackageReference Include="Moq" Version="4.20.1" />
     </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/test/Cnblogs.Architecture.UnitTests/EventBus/AssemblyAttributeTests.cs b/test/Cnblogs.Architecture.UnitTests/EventBus/AssemblyAttributeTests.cs
index 529f855..3ad6a62 100644
--- a/test/Cnblogs.Architecture.UnitTests/EventBus/AssemblyAttributeTests.cs
+++ b/test/Cnblogs.Architecture.UnitTests/EventBus/AssemblyAttributeTests.cs
@@ -1,7 +1,8 @@
-using Cnblogs.Architecture.TestIntegrationEvents;
+using Cnblogs.Architecture.Ddd.EventBus.Abstractions;
+using Cnblogs.Architecture.Ddd.EventBus.Dapr;
+using Cnblogs.Architecture.TestIntegrationEvents;
 using FluentAssertions;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Cnblogs.Architecture.UnitTests.EventBus;
 
@@ -12,7 +13,7 @@ public void SubscribeByAssemblyMeta_Success()
     {
         // Arrange
         var builder = WebApplication.CreateBuilder();
-        builder.Services.AddDaprEventBus(nameof(AssemblyAttributeTests));
+        builder.Services.AddEventBus(o => o.UseDapr(nameof(AssemblyAttributeTests)));
         var app = builder.Build();
 
         // Act
@@ -35,4 +36,4 @@ public void SubscribeByAssemblyMeta_Throw()
         // Assert
         act.Should().Throw<InvalidOperationException>();
     }
-}
\ No newline at end of file
+}