Orbitra.Abstractions 1.0.1

Orbitra.Abstractions

Orbitra.Abstractions contains the core building blocks for working with the Orbitra dispatcher.
It provides lightweight interfaces to define your requests, handlers, and pipeline behaviours, without bringing in any dependencies like Microsoft.Extensions.DependencyInjection.

This package is perfect for:

• Shared contracts across projects (e.g., in a domain or application layer)
• Unit testing without requiring the full Orbitra runtime
• Keeping dependencies minimal in class libraries

Orbitra.Abstractions by itself does not contain the dispatcher implementation or source generation, just the abstraction.
Use the main Orbitra package together with this one when you need dispatching and pipeline execution.

Install

dotnet add package Orbitra.Abstractions

Core Concepts

Requests

A request represents an operation that your system can perform.
Orbitra supports three styles of requests:

Example:

using Orbitra.Abstractions.Requests;

// Neutral request
public sealed record PingRequest(string Message) : IRequest<string>;

// Command
public sealed record CreateUserCommand(string UserName) : ICommand<string>;

// Query
public sealed record GetUserQuery(int Id) : IQuery<UserDto>;
public sealed record UserDto(int Id, string Name);

Handlers

A handler processes a request and returns a result.
Each handler implements either the generic IRequestHandler<TRequest, TResult>,
or the more specific ICommandHandler<,> or IQueryHandler<,>.

using Orbitra.Abstractions;

// Neutral handler
public sealed class PingRequestHandler : IRequestHandler<PingRequest, string>
{
    public Task<string> HandleAsync(PingRequest request, CancellationToken token = default)
        => Task.FromResult($"PONG: {request.Message}");
}

// Command handler
public sealed class CreateUserCommandHandler : ICommandHandler<CreateUserCommand, string>
{
    public Task<string> HandleAsync(CreateUserCommand command, CancellationToken token = default)
        => Task.FromResult($"User {command.UserName} created!");
}

// Query handler
public sealed class GetUserQueryHandler : IQueryHandler<GetUserQuery, UserDto>
{
    public Task<UserDto> HandleAsync(GetUserQuery query, CancellationToken token = default)
        => Task.FromResult(new UserDto(query.Id, "Alice"));
}

Pipeline Behaviours

Pipeline behaviours let you define cross-cutting concerns such as logging, validation, or metrics.
They implement IPipelineBehaviour<TRequest, TResult> and wrap around the handler invocation.

using Orbitra.Abstractions.Pipelines;
using Orbitra.Abstractions.Requests;

public sealed class LoggingBehaviour<TRequest, TResult> : IPipelineBehaviour<TRequest, TResult>
    where TRequest : IRequest<TResult>
{
    public async Task<TResult> HandleAsync(
        TRequest request,
        DispatchHandlerDelegate<TResult> next,
        CancellationToken token = default)
    {
        Console.WriteLine($"Handling {typeof(TRequest).Name}");
        var result = await next();
        Console.WriteLine($"Handled {typeof(TRequest).Name}");
        return result;
    }
}

When to Use Orbitra.Abstractions Alone

You might only need Orbitra.Abstractions when:

1. Defining shared contracts in a clean architecture setup.
   • Example: MyApp.Contracts project references only abstractions, no runtime dependencies.
2. Writing unit tests for handlers without setting up the full dispatcher or DI.
3. Keeping libraries lightweight and dependency-free, while still being compatible with Orbitra.

Related Packages

TL;DR

• Orbitra.Abstractions = contracts and interfaces only.
• Use it to define requests, handlers, and pipelines without runtime dependencies.
• Combine with Orbitra and optionally Orbitra.DependencyInjection.Microsoft when you need full functionality.