Kongroo.BuildingBlocks.Application 0.2.0

🦘 Kongroo.BuildingBlocks.Application

Application-layer building blocks for the application layer of my .NET microservices — an in-process domain-event dispatcher, CQRS command/query contracts, a unit-of-work seam, an integration-event base, and startup initializers. Builds on Kongroo.BuildingBlocks.Domain plus one DI abstraction, and stays AOT-compatible.

Installation

dotnet add package Kongroo.BuildingBlocks.Application

Building blocks

Usage

using Kongroo.BuildingBlocks.Application;
using Microsoft.Extensions.DependencyInjection;

// A domain-event handler — derive from the typed base:
public sealed class OrderPlacedHandler : DomainEventHandler<OrderPlaced>
{
    protected override Task HandleAsync(OrderPlaced domainEvent, CancellationToken cancellationToken)
    {
        // react to the event…
        return Task.CompletedTask;
    }
}

// A command and its handler — plain contracts, no mediator:
public sealed record ConfirmOrder(OrderId OrderId) : ICommand;

public sealed class ConfirmOrderHandler(IUnitOfWork unitOfWork) : ICommandHandler<ConfirmOrder>
{
    public async Task HandleAsync(ConfirmOrder command, CancellationToken cancellationToken)
    {
        // load the aggregate, mutate it, then commit via EF Core…
        await unitOfWork.CommitAsync(cancellationToken);
    }
}

// Registration — one call per handler; the in-process dispatcher is wired automatically:
services.AddDomainEventHandler<OrderPlacedHandler>();
services.AddScoped<ICommandHandler<ConfirmOrder>, ConfirmOrderHandler>();

After persisting an aggregate, an infrastructure component (e.g. an EF Core SaveChanges interceptor) calls IDomainEventDispatcher.DispatchAsync(aggregates, …), which invokes each matching IDomainEventHandler and then clears the aggregates. CQRS handlers carry no dispatcher — inject the handler interface directly where you need it.

Design notes

• No mediator: commands and queries are plain handler contracts you inject and call directly — no ISender, no pipeline behaviors.
• Explicit registration: handlers are registered one by one (AddDomainEventHandler<T>), so there is no assembly scanning or reflection and the package stays AOT/trim-safe. The first call also registers the in-process IDomainEventDispatcher.
• Dispatch is in-process and sequential: an aggregate's events are snapshotted before any handler runs, handlers fail fast, and sources are cleared only after a clean pass.
• Errors are exceptions (Kongroo.BuildingBlocks.Domain's DomainException), not a Result<T>.
• No repository abstraction — handlers use EF Core (or your data access) directly.

What's baked in

• Target: net10.0, nullable + implicit usings, warnings-as-errors, latest .NET analyzers + SonarAnalyzer.
• Dependencies: Kongroo.BuildingBlocks.Domain and Microsoft.Extensions.DependencyInjection.Abstractions; IsAotCompatible.
• API stability: the public surface is tracked with the public-API analyzer.
• Packaging: deterministic build, SourceLink, symbols (snupkg), and a MinVer-derived version.

Requirements

• .NET 10 SDK or later.

License

MIT