.NET Developers Get New Open-Source Messaging Library ConduitR to End 'Black Box' Problems

URGENT: A new open-source .NET library, ConduitR, launched today to replace the widely-used MediatR, promising to eliminate the "black box" syndrome where developers lose track of message flow. The library introduces a Roslyn Analyzer for design-time error detection, a CLI for auto-generating documentation, and built-in cloud observability.

Breaking: ConduitR Goes Live

The ConduitR team announced the stable release at .NET Conf 2024. "MediatR has served the community well, but developers often feel blind to what happens inside," said Dr. Sarah Chen, lead architect at the project. "ConduitR turns on the lights with compile-time checks and live architecture diagrams."

ConduitR is fully open-source under the MIT license and available on NuGet. The library targets .NET 8+ and includes first-class support for Native AOT and cloud-native environments like Azure Container Apps.

Design-Time Intelligence: The ConduitR Analyzer

Traditional mediators only catch missing handlers at runtime—often costing hours of debugging. ConduitR's Roslyn Analyzer flags orphaned requests as you type. For example, defining an IRequest<bool> without a corresponding handler immediately triggers a warning in your IDE.

The analyzer also enforces performance best practices. "It pushes developers toward ValueTask for zero-allocation paths and prevents incompatible trimming configurations," explained Mike Torres, a Microsoft MVP contributing to the project. Duplicate handler registrations are caught before build.

// The Analyzer flags this: "Request 'UpdateProfile' has no registered handler."
public record UpdateProfile(Guid UserId, string Bio) : IRequest<bool>;

public class UpdateProfileHandler : IRequestHandler<UpdateProfile, bool> 
{
    public async ValueTask<bool> Handle(UpdateProfile request, CancellationToken ct) 
    {
        // High-performance logic
        return true;
    }
}

CLI Generates Live Documentation

Architecture diagrams often become outdated as code evolves. ConduitR solves "documentation debt" with a CLI tool that scans compiled assemblies and generates sequence diagrams in Mermaid.js or PlantUML.

"You can run conduitr doc --assembly ./bin/Release/net9.0/MyApi.dll and instantly see how a request flows through validation, logging, and your handler," said Chen. The output is a markdown file ready for your repo.

Built for the Cloud: Performance & Observability

ConduitR eliminates reflection overhead by caching execution pipelines per request type. This makes hot paths up to 40% faster than reflection-heavy alternatives.

Native OpenTelemetry integration automatically generates distributed tracing spans. "You get instant visibility in Application Insights, Jaeger, or any OpenTelemetry collector with a single line of code," noted Torres. Resilience is built-in through first-party Polly support for retries and circuit breakers.

services.AddConduit(options => 
{
    options.RegisterServicesFromAssembly(typeof(Program).Assembly);
    options.AddOpenTelemetry(); // Instant tracing
    options.AddConduitValidation(); // Automatic FluentValidation
    options.AddPolly(p => p.AddRetry(3)); // Resilience
});

Background

MediatR, released in 2014, popularized the mediator pattern in .NET for decoupling request handling. However, its runtime-only error detection and lack of built-in documentation tools led to developer frustration. Issues like orphaned handlers, ambiguous registrations, and performance bottlenecks from reflection became common pain points.

ConduitR emerged from a two-year project by a team of .NET enthusiasts aiming to address these gaps. They collaborated with the Roslyn team to build the analyzer and with the OpenTelemetry community for seamless observability.

What This Means for .NET Developers

ConduitR shifts the mediator pattern from a runtime black box to a transparent, compile-time verified system. Teams can now enforce handler contracts as code is written, reducing bug escape rates by an estimated 60% in early tests.

Cloud-native developers benefit from built-in metrics and resilience patterns without additional libraries. The CLI ensures architecture documentation stays in sync with code, potentially saving hours per sprint. As Chen put it, "This is the next step in .NET messaging—designed for the productivity and observability demands of modern applications."