ObservR – View Details

DataArc OrchestratR

DataArc ObservR

Event-Driven Infrastructure, Seamlessly Modular

What is DataArc ObservR?

ObservR is a lightweight, high-performance domain event dispatcher tailored for clean architecture and modular monoliths. It allows your domain layer to emit events without any dependency on infrastructure, preserving purity while enabling reactive workflows. Events are observed, queued, and dispatched after orchestrator completion — ensuring order, consistency, and transparency.

Why DataArc ObservR?

Traditional event dispatchers are often either too tightly coupled to infrastructure or overly generic. ObservR is intentionally minimal and opinionated: it works in-process, with zero dependencies on message brokers, and uses simple observer registration via DI or assembly scanning. Perfect for teams who want domain events with zero ceremony — no external queues, no boilerplate.

Core Features

Feature	Description
In-Process Dispatch	Dispatch domain events without external queues or messaging infrastructure.
Post-Orchestrator Flow	Events are collected during orchestrator execution and dispatched after completion.
Observer Discoverability	Explicit interface-based handlers make it clear which observer handles each event — no guesswork, no convention-based resolution.
Zero Domain Coupling	Event publishing requires no reference to infrastructure — 100% domain clean.
ObservableEventDispatcher	Simple interface to dispatch, replay, and inspect event flows.


using DataArc.ObservR;
using DataArc.ObservR.Abstractions;
using Microsoft.Extensions.DependencyInjection;

// Define events
public record IntegrationStartedEvent() : IObservableEvent;
public record IntegrationStoppedEvent() : IObservableEvent;
public record IntegrationCompletedEvent() : IObservableEvent;

// Define observers
public class IntegrationStartedObserver : IEventObserver
{
    public async Task HandleAsync(IntegrationStartedEvent evt)
    {
        Console.WriteLine("Integration started.");
        await Task.CompletedTask;
    }
}

public class IntegrationStoppedObserver : IEventObserver
{
    public async Task HandleAsync(IntegrationStoppedEvent evt)
    {
        Console.WriteLine("Integration stopped.");
        await Task.CompletedTask;
    }
}

public class IntegrationCompletedObserver : IEventObserver
{
    public async Task HandleAsync(IntegrationCompletedEvent evt)
    {
        Console.WriteLine("Integration completed.");
        await Task.CompletedTask;
    }
}

internal class Program
{
    private static async Task Main(string[] args)
    {
        // Register ObservR + observers explicitly
        var serviceProvider = new ServiceCollection()
            .AddDataArcObserver(obs =>
            {
                obs.AddObserver<IntegrationStartedObserver>();
                obs.AddObserver<IntegrationStoppedObserver>();
                obs.AddObserver<IntegrationCompletedObserver>();
            })
            .BuildServiceProvider();

        // Prepare events
        var events = new IObservableEvent[]
        {
            new IntegrationStartedEvent(),
            new IntegrationStoppedEvent(),
            new IntegrationCompletedEvent()
        };

        // Resolve dispatcher and dispatch
        var dispatcher = serviceProvider.GetRequiredService<IObservableEventHandler>();
        await dispatcher.DispatchAsync(events);
    }
}