A powerful, lightweight, and extensible implementation of the Mediator pattern and Command Query Responsibility Segregation (CQRS) for .NET applications.
Arbiter is designed for building clean, modular architectures like Vertical Slice Architecture and CQRS. It provides a comprehensive suite of libraries that work together to simplify complex application patterns while maintaining high performance and flexibility.
Key Features
Clean Architecture: Perfect for Vertical Slice Architecture and CQRS patterns
High Performance: Minimal overhead with efficient mediator implementation
Extensible: Pipeline behaviors, custom handlers, and extensive customization options
Observable: Built-in OpenTelemetry support for tracing and metrics
Database Agnostic: Support for Entity Framework Core, MongoDB, and more
Web Ready: Minimal API endpoints and MVC controller support
Communication: Integrated email and SMS messaging capabilities
// Define your request
public class GetUserQuery : IRequest<User>
{
public int UserId { get; set; }
}
// Implement the handler
public class GetUserHandler : IRequestHandler<GetUserQuery, User>
{
public async ValueTask<User?> Handle(GetUserQuery request, CancellationToken cancellationToken)
{
// Your business logic here
return await GetUserFromDatabase(request.UserId);
}
}
Communication implementation for SendGrid and Twilio
Core Libraries
Arbiter.Mediation
A lightweight and extensible implementation of the Mediator pattern for .NET applications, designed for clean, modular architectures like Vertical Slice Architecture and CQRS.
Mediation Features
Request/Response Pattern: Handle requests with typed responses using IRequest<TResponse> and IRequestHandler<TRequest, TResponse>
Notifications/Events: Publish events using INotification and INotificationHandler<TNotification>
Pipeline Behaviors: Middleware-like cross-cutting concerns using IPipelineBehavior<TRequest, TResponse>
Dependency Injection: Seamless integration with .NET's DI container
High Performance: Minimal allocations and efficient execution
OpenTelemetry Ready: Built-in observability support
Installation
dotnet add package Arbiter.Mediation
Basic Usage
1. Define Request and Response
public class Ping : IRequest<Pong>
{
public string? Message { get; set; }
}
public class Pong
{
public string? Message { get; set; }
}
2. Implement Handler
public class PingHandler : IRequestHandler<Ping, Pong>
{
public async ValueTask<Pong?> Handle(
Ping request,
CancellationToken cancellationToken = default)
{
// Simulate async work
await Task.Delay(100, cancellationToken);
return new Pong { Message = $"{request.Message} Pong" };
}
}
3. Define Pipeline Behavior (Optional)
public class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TRequest : IRequest<TResponse>
{
private readonly ILogger<LoggingBehavior<TRequest, TResponse>> _logger;
public LoggingBehavior(ILogger<LoggingBehavior<TRequest, TResponse>> logger)
{
_logger = logger;
}
public async ValueTask<TResponse> Handle(
TRequest request,
RequestHandlerDelegate<TResponse> next,
CancellationToken cancellationToken = default)
{
_logger.LogInformation("Handling {RequestType}", typeof(TRequest).Name);
var response = await next(cancellationToken);
_logger.LogInformation("Handled {RequestType}", typeof(TRequest).Name);
return response;
}
}
var query = new EntityIdentifierQuery<int, ProductReadModel>(principal, 123);
var result = await mediator.Send(query);
Query with Filtering and Sorting:
var filters = new List<EntityFilter>
{
new EntityFilter { Name = "Status", Operator = FilterOperators.Equal, Value = "Active" },
new EntityFilter { Name = "Price", Operator = FilterOperators.GreaterThan, Value = 10.00m }
};
var sorts = new List<EntitySort>
{
new EntitySort { Name = "Name", Direction = SortDirections.Ascending }
};
var query = new EntityQuery
{
Filter = new EntityFilter { Filters = filters },
Sort = sorts
};
// no page or page size will return all matches
var command = new EntityPagedQuery<ProductReadModel>(principal, query);
var result = await mediator.Send(command);
Paginated Query:
var entityQuery = new EntityQuery
{
Filter = new EntityFilter
{
Name = "Category",
Operator = FilterOperators.Equal,
Value = "Electronics"
},
Sort = new List<EntitySort>
{
new EntitySort
{
Name = "CreatedDate",
Direction = SortDirections.Descending
}
},
Page = 1,
PageSize = 20
};
var query = new EntityPagedQuery<ProductReadModel>(principal, entityQuery);
var result = await mediator.Send(query);
Update Command:
var updateModel = new ProductUpdateModel
{
Name = "Updated Product",
Description = "Updated description",
Price = 29.99m
};
var command = new EntityUpdateCommand<int, ProductUpdateModel, ProductReadModel>(principal, 123, updateModel);
var result = await mediator.Send(command);
Advanced Filtering and Querying
Complex Filter Logic:
var complexEntityQuery = new EntityQuery
{
Filter = new EntityFilter
{
Filters = new List<EntityFilter>
{
new EntityFilter
{
Name = "Category",
Operator = FilterOperators.In,
Value = new[] { "Electronics", "Computers" }
},
new EntityFilter
{
Name = "Price",
Operator = FilterOperators.GreaterThanOrEqual,
Value = 100.00m
},
new EntityFilter
{
Name = "Name",
Operator = FilterOperators.Contains,
Value = "Gaming"
}
},
Logic = FilterLogic.And
},
Sort = new List<EntitySort>
{
new EntitySort { Name = "Price", Direction = SortDirections.Descending },
new EntitySort { Name = "Name", Direction = SortDirections.Ascending }
}
};
var query = new EntityPagedQuery<ProductReadModel>(principal, complexEntityQuery);
var result = await mediator.Send(query);
Data Providers
Arbiter.CommandQuery.EntityFramework
Entity Framework Core integration providing ready-to-use handlers for all base commands and queries.
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request
License
This project is licensed under the MIT License - see the LICENSE file for details.
Support
If you find this project useful, please consider:
Starring the repository
Reporting issues
Contributing improvements
Spreading the word
Change Log
Version 2.0
Major Breaking Changes and Improvements
Breaking Changes
Removed EntitySelectQuery: Replaced with enhanced EntityQuery that now supports both paged and non-paged results
Removed EntityUpsertCommand: Upsert functionality has been unified into EntityUpdateCommand with built-in upsert logic
Removed EntityContinuationQuery and EntityContinuationResult: Functionality now integrated into EntityQuery
Command/Query Reorganization:
Moved query classes (EntityIdentifierQuery, EntityIdentifiersQuery, EntityPagedQuery) to Commands namespace for better organization
Renamed base classes for consistency:
EntityIdentifierCommand → EntityIdentifierBase
EntityIdentifiersCommand → EntityIdentifiersBase
EntityModelCommand → EntityModelBase
Renamed filter, logic, and sort values for more consistent query building
EntityFilterOperators → FilterOperators
EntityFilterLogic → FilterLogic
EntitySortDirections → SortDirections
Architecture Improvements
Simplified Query System:
Consolidated multiple query types into a single, more powerful EntityQuery class
Removed redundant query handlers and behaviors
Enhanced filter and sort capabilities with better type safety
Enhanced Filtering:
Moved filter logic to dedicated Queries.FilterLogic and Queries.FilterOperators enums
Improved EntityFilterConverter with better validation and error handling
Enhanced LinqExpressionBuilder with more robust query building capabilities
Caching Simplification:
Removed DistributedCacheQueryBehavior and MemoryCacheQueryBehavior
Consolidated caching logic into HybridCacheQueryBehavior for better performance
Removed IDistributedCacheSerializer interface in favor of built-in serialization
Behavior Consolidation
Tenant Behaviors:
Removed TenantFilterBehaviorBase and TenantSelectQueryBehavior
Enhanced TenantPagedQueryBehavior to handle all tenant-related query filtering
Soft Delete Behaviors:
Removed DeletedFilterBehaviorBase and DeletedSelectQueryBehavior
Enhanced DeletedPagedQueryBehavior to handle all soft delete scenarios
Removed Legacy Behaviors:
TrackChangeCommandBehavior - functionality moved to handlers
Various base behavior classes that were no longer needed
Migration from Version 1.x
Updating Query Usage:
// Version 1.x - EntitySelectQuery (REMOVED)
var oldQuery = new EntitySelectQuery<ProductReadModel>(principal, filter, sort);
// Version 2.0 - Use EntityPagedQuery with EntityQuery instead
var entityQuery = new EntityQuery
{
Filter = filter,
Sort = sorts
};
var newQuery = new EntityPagedQuery<ProductReadModel>(principal, entityQuery);
Updating Filter Operators:
// Version 1.x - String operators (DEPRECATED)
var oldFilter = new EntityFilter
{
Name = "Status",
Operator = "eq",
Value = "Active"
};
// Version 2.0 - Enum operators
var newFilter = new EntityFilter
{
Name = "Status",
Operator = FilterOperators.Equal,
Value = "Active"
};
Updating Sort Directions:
// Version 1.x - String directions (DEPRECATED)
var oldSort = new EntitySort
{
Name = "Name",
Direction = "asc"
};
// Version 2.0 - Enum directions
var newSort = new EntitySort
{
Name = "Name",
Direction = SortDirections.Ascending
};
Upsert Operations:
// Version 1.x - Separate EntityUpsertCommand (REMOVED)
var oldUpsert = new EntityUpsertCommand<int, ProductUpsertModel, ProductReadModel>(principal, model);
// Version 2.0 - Use EntityUpdateCommand with upsert behavior
var newUpdate = new EntityUpdateCommand<int, ProductUpdateModel, ProductReadModel>(principal, id, model, true);
