DEV Community: Rafa Eslava

Write, Run, Debug — REslava.Result three-layer observability story

Rafa Eslava — Mon, 06 Apr 2026 10:29:09 +0000

Pipeline diagrams generated at compile time are great for understanding structure. But structure tells you what could happen — not what did happen. That's where runtime observation comes in.

REslava.Result has a three-layer story:

✏️ Write — add [ResultFlow] to any fluent Result method. The source generator emits a Mermaid diagram constant at compile time. You can paste it into GitHub, Notion, VS Code, or mermaid.live and see the entire pipeline shape before you ever run it.

▶️ Run — make your class partial. The same generator now emits a FlowProxy alongside the diagram. Call svc.Flow.Process(...) instead of svc.Process(...) and every node in the pipeline is traced automatically: output value, error type, elapsed milliseconds. The RingBufferObserver holds the last N traces in memory with zero allocation.

🐛 Debug — call svc.Flow.Debug.Process(...) for a single-trace debug run. The generator writes reslava-debug-{Method}.json to your bin/ folder automatically. The VS Code extension watches */reslava-.json — the Debug Panel opens by itself, no manual trigger, no port to configure, no HTTP server.

Inside the Debug Panel:

The pipeline diagram is rendered live
Each trace is listed: pass/fail icon, method name, node count, elapsed ms total
Step through nodes one at a time — the current step is highlighted in the diagram
Animated replay — plays through all nodes automatically
Multi-file picker — switch between trace files without closing the panel

The FlowProxy is generated — you write no observer wiring, no DI registration, no startup hooks. Make the class partial, rebuild, and you have full observability.

// You write
public partial class OrderService
{
[ResultFlow]
public Result Process(int userId, int productId) =>
FindUser(userId)
.Ensure(IsActive, new ForbiddenError("inactive"))
.Bind(u => FindProduct(productId))
.Ensure(InStock, new NotFoundError("out of stock"))
.Bind(PlaceOrder);
}

// You call (for debug):
svc.Flow.Debug.Process(userId, productId);
// → reslava-debug-Process.json written automatically
// → VSIX file watcher fires
// → Debug Panel opens with the trace, ready to step through

Everything generated. Nothing hand-written.

https://reslava.github.io/nuget-package-reslava-result/resultflow/runtime/

dotnet #csharp #sourcegenerators #debugging #railwayorientedprogramming #functionalprogramming #roslyn #developerexperience

🎯 From 50+ Lines to 1 Line: Zero Boilerplate ASP.NET APIs

Rafa Eslava — Thu, 29 Jan 2026 10:15:01 +0000

📖 The Problem: Repetitive API Code
Every .NET developer writes this boilerplate:

// BEFORE: 15+ lines for ONE endpoint
app.MapGet("/api/products/{id}", async (int id, ProductService service) =>
{
    if (id <= 0) return Results.BadRequest("Invalid ID");
    var product = await service.GetProductAsync(id);
    return product == null 
        ? Results.NotFound("Product not found")
        : Results.Ok(product);
});

🚀 The Solution: Source Generator Magic
📦 Setup:

// Program.cs - One time setup
using REslava.Result.SourceGenerators;
[assembly: GenerateResultExtensions()]

✨ The Magic:

// AFTER: 3 lines total!
app.MapGet("/api/products/{id}", async (int id, ProductService service) =>
    => (await service.GetProductAsync(id)).ToIResult());

That's it! 80% code reduction! 🤯

🔍 Smart Error Mapping
The generator automatically handles errors:

"not found" → 404
"validation" → 422  
"unauthorized" → 401
"forbidden" → 403
"conflict" → 409

📊 Real Impact
Operation Before After Reduction
GET 15 lines 3 lines 80%
POST 20 lines 3 lines 85%
PUT 18 lines 3 lines 83%

🎯 Complete API Example

📋 BEFORE (50+ lines):

app.MapGet("/api/products", async (ProductService service) =>
{
    try { return Results.Ok(await service.GetAllProductsAsync()); }
    catch { return Results.Problem("Error", statusCode: 500); }
});

app.MapGet("/api/products/{id}", async (int id, ProductService service) =>
{
    if (id <= 0) return Results.BadRequest("Invalid ID");
    var product = await service.GetProductAsync(id);
    return product == null ? Results.NotFound() : Results.Ok(product);
});

app.MapPost("/api/products", async (CreateProductRequest request, ProductService service) =>
{
    if (string.IsNullOrWhiteSpace(request.Name))
        return Results.ValidationProblem(new { Name = new[] { "Required" } });
    var product = await service.CreateProductAsync(request);
    return Results.Created($"/api/products/{product.Id}", product);
});

🚀 AFTER (9 lines):

app.MapGet("/api/products", async (ProductService service) =>
    => (await service.GetAllProductsAsync()).ToIResult());

app.MapGet("/api/products/{id}", async (int id, ProductService service) =>
    => (await service.GetProductAsync(id)).ToIResult());

app.MapPost("/api/products", async (CreateProductRequest request, ProductService service) =>
    => (await service.CreateProductAsync(request)).ToPostResult(p => $"/api/products/{p.Id}"));

🎯 HTTP Method Extensions

.ToIResult()        // GET - 200/400/404/500
.ToPostResult()     // POST - 201 Created
.ToPutResult()      // PUT - 200 OK
.ToDeleteResult()   // DELETE - 200 OK

🚀 Get Started
📦 Install:

dotnet add package REslava.Result
dotnet add package REslava.Result.SourceGenerators

✨ Setup:

using REslava.Result.SourceGenerators;
[assembly: GenerateResultExtensions()]

🎯 Use:

return await service.GetDataAsync().ToIResult();

🌟 Benefits
🚀 80-90% Code Reduction
🧠 Smart Error Handling
📖 RFC 7807 Compliant
⚡ Zero Runtime Overhead
🔧 Compile-Time Generation

🎉 Conclusion
Source generators transform .NET API development from repetitive boilerplate to elegant, declarative code.

Try it today and never write manual HTTP responses again! 🚀

📚 Learn More
📦 NuGet Package
📖 Documentation
🌐 Live Samples

GitHub
NuGet

dotnet #csharp #aspnetcore #sourcegenerators #webdev #apidevelopment

Why I Chose CRTP for My C# Result Pattern Library

Rafa Eslava — Sat, 24 Jan 2026 08:16:04 +0000

🎯 The Problem That Started My Journey

I was diving deep into functional programming and Result patterns in C#, but I kept hitting the same wall: type information loss in fluent APIs.

// The problem I kept facing
Reason reason = new Error("Something went wrong")
    .WithMessage("Updated message")  // Returns Reason, not Error
    .WithTag("Code", 404);           // Can't call Error-specific methods

💡 Discovering CRTP: The "Aha!" Moment

That's when I discovered the Curiously Recurring Template Pattern (CRTP). At first, it looked like magic:

// CRTP in action
public abstract class Reason<TReason> : Reason
    where TReason : Reason<TReason>
{
    public TReason WithMessage(string message) 
    { 
        Message = message; 
        return (TReason)this;  // Returns derived type!
    }
}

Suddenly, everything clicked. The compiler could preserve type information through the entire fluent chain!

🔧 Building REslava.Result

With CRTP as my foundation, I started building REslava.Result - a zero-dependency Result pattern library that solves the type preservation problem.

// Perfect type preservation with CRTP
Error error = new Error("Something went wrong")
    .WithMessage("Updated message")  // Returns Error
    .WithTag("Code", 404)           // Still Error - can chain more
    .WithTag("Field", "Email");     // Perfect fluent API

This isn't just about pretty code - it's about compile-time safety and developer experience.

🚀 What I'm Learning Along the Way

Building this library has been an incredible learning journey:

Advanced C# patterns - CRTP, generics, covariance
Functional programming - Result patterns, monads, railway-oriented programming
Library design - API design, backwards compatibility, zero dependencies
Production thinking - Performance, testing, documentation

Every day brings new challenges and discoveries about what's possible in C#.

🎯 Why This Matters

Most Result libraries don't solve the fluent API type preservation problem. They either:

Accept the type loss (limiting)
Use complex workarounds (overly complicated)
Ignore fluent APIs altogether (missing opportunity)

CRTP provides an elegant solution that's both powerful and intuitive.

🔗 Come Learn With Me

I'm documenting this entire journey as I build REslava.Result:

GitHub
NuGet

I'd love to hear from others who have explored CRTP or are interested in functional programming in C#. What challenges have you faced? What solutions have you discovered?

📚 Tags

csharp dotnet functionalprogramming crtp librarydevelopment resultpattern fluentapi