https://github.com/zeidlab/eventbuss
EventBuss is a lightweight, high-performance in-process messaging library for .NET. It simplifies the mediator pattern with System.Threading.Channels for fast event publishing and handling. As a simpler MediatR alternative, it cleanly supports CQRS and event-driven designs without complex pipelines.
https://github.com/zeidlab/eventbuss
channels cqrs event-driven event-handling events in-process-messaging messaging request-response request-response-processing
Last synced: 3 months ago
JSON representation
EventBuss is a lightweight, high-performance in-process messaging library for .NET. It simplifies the mediator pattern with System.Threading.Channels for fast event publishing and handling. As a simpler MediatR alternative, it cleanly supports CQRS and event-driven designs without complex pipelines.
- Host: GitHub
- URL: https://github.com/zeidlab/eventbuss
- Owner: ZeidLab
- License: other
- Created: 2025-06-12T14:42:26.000Z (11 months ago)
- Default Branch: master
- Last Pushed: 2025-06-27T17:03:28.000Z (10 months ago)
- Last Synced: 2025-07-29T05:51:47.446Z (9 months ago)
- Topics: channels, cqrs, event-driven, event-handling, events, in-process-messaging, messaging, request-response, request-response-processing
- Language: C#
- Homepage:
- Size: 189 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# ZeidLab.ToolBox.EventBuss
## 🤔 What is `ZeidLab.ToolBox.EventBuss` Library?
**ZeidLab.ToolBox.EventBuss** is a lightweight, high-performance in-process event handling and messaging library for .NET applications. It provides a clean and efficient way to implement event-driven architectures, enabling loose coupling between components through a publisher-subscriber model. The library supports both event publishing (fire-and-forget) and request-response patterns, making it versatile for various communication needs within your application.
### 🎁 Features
* **Event Publishing:** Fire-and-forget event publishing with automatic handler discovery and invocation
* **Request Handling:** Send requests and optionally receive responses using a clean, typed interface
* **Automatic Registration:** Scan assemblies to automatically discover and register event and request handlers
* **High-Performance:** Optimized for minimal overhead and maximum throughput in critical paths
* **Background Processing:** Events are processed asynchronously in a background service
* **Parallel Execution:** Configurable parallel processing of events for improved throughput
* **Dependency Injection:** Seamless integration with Microsoft's dependency injection system
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## 📦 Installation
To use **ZeidLab.ToolBox.EventBuss** in your project, you can install it via NuGet:
```bash
dotnet add package ZeidLab.ToolBox.EventBuss
```
For more information, please visit [EventBuss Package on NuGet](https://www.nuget.org/packages/ZeidLab.ToolBox.EventBuss).
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## 📝 ChangeLogs
With each release, we add new features and fix bugs. You can find the full changelog at [EventBuss Releases](https://github.com/ZeidLab/EventBuss/releases).
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## 📖 Usage and Configuration
EventBuss provides a straightforward API for event publishing and request handling in your .NET applications.
### Basic Configuration
Register EventBuss in your application's service collection during startup:
```csharp
// Add with default configuration
builder.Services.AddEventBuss();
// Or with custom configuration
builder.Services.AddEventBuss(options =>
{
// Register handlers from specific assemblies
options.RegisterFromAssembly(typeof(Program).Assembly);
// Discover handlers from referenced assemblies
options.FromDependencies = true;
// Configure parallel processing (optional)
// The default value is the number of available processors cores
// One thread per core is recommended for optimal performance
options.MaxDegreeOfParallelism = 4;
});
```
### Publishing Events
Create event object by implementing the `IAppEvent` interface. It can be a simple record or class, however we recommend you to use a `readonly` type for optimized performance. In this example it is a `readonly record struct` . Then, use the `IEventBussService` to publish events:
```csharp
// Define an event
public readonly record struct UserCreatedEvent(string UserId, string Username) : IAppEvent;
// Publish an event
_eventBussService.Publish(new UserCreatedEvent("user123", "johndoe"));
```
### Creating Event Handlers
Implement the `IAppEventHandler` interface to handle specific events:
```csharp
public class UserCreatedEventHandler : IAppEventHandler
{
private readonly ILogger _logger;
public UserCreatedEventHandler(ILogger logger)
{
_logger = logger;
}
public async Task HandleAsync(UserCreatedEvent @event, CancellationToken cancellationToken)
{
_logger.LogInformation("User created: {UserId}, {Username}", @event.UserId, @event.Username);
await Task.CompletedTask;
}
}
```
### Sending Requests
Send requests and receive responses using the request-response pattern. The request can be a simple record or class, however we recommend you to use a `readonly` type for optimized performance. In this example it is a `readonly record struct` :
```csharp
// Define a request and handler
public readonly record struct GetUserRequest(string UserId) : IRequest;
public class GetUserRequestHandler : IRequestHandler
{
private readonly IUserRepository _repository;
public GetUserRequestHandler(IUserRepository repository)
{
_repository = repository;
}
public async Task HandleAsync(GetUserRequest request, CancellationToken cancellationToken)
{
return await _repository.GetUserByIdAsync(request.UserId, cancellationToken);
}
}
// Send the request and get a response
var userDetails = await _eventBussService.SendAsync(
new GetUserRequest("user123"),
cancellationToken
);
```
### Core Components
| Component | Description |
|---------------------------------------|--------------------------------------------------------------|
| `IEventBussService` | Core service for publishing events and sending requests |
| `IAppEvent` | Marker interface for event objects |
| `IAppEventHandler` | Interface for event handlers |
| `IRequest` | Interface for request objects that expect a response |
| `IRequest` | Interface for request objects that don't expect a response |
| `IRequestHandler` | Interface for request handlers that return a response |
| `IRequestHandler` | Interface for request handlers that do not return a response |
| `EventBussOptions` | Configuration options for EventBuss |
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## ⭐️ Star and Follow
Star this repository and follow me on GitHub to stay informed about new releases and updates. Your support fuels this
project's growth!
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## 💡 Love My Work? Support the Journey!
If my content adds value to your projects, consider supporting me via crypto.
- **Bitcoin:** bc1qlfljm9mysdtu064z5cf4yq4ddxgdfztgvghw3w
- **USDT(TRC20):** TJFME9tAnwdnhmqGHDDG5yCs617kyQDV39
Thank you for being part of this community—let’s build smarter, together
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## 🤝 Contributions
Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.
1. Fork the repository
2. Create a new branch for your feature or bugfix
3. Commit your changes following the project guidelines
4. Push your branch and submit a pull request
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)
## License
This project is licensed under the MIT License. See the [LICENSE](./LICENSE.txt) file for details.
[^ Back To Top](#-what-is-zeidlabtoolboxeventbuss-library)