Dapr for .NET Developers: Building Blocks for Microservices

using Dapr.Workflow;

public sealed record CheckoutRequest(string OrderId, string CustomerId, decimal Total);
public sealed record PaymentResult(bool Succeeded, string? Reason);

public sealed class CheckoutWorkflow : Workflow<CheckoutRequest, string>
{
    public override async Task<string> RunAsync(WorkflowContext context, CheckoutRequest order)
    {
        var logger = context.CreateReplaySafeLogger<CheckoutWorkflow>();
        var retry = new WorkflowTaskOptions(new WorkflowRetryPolicy(
            maxNumberOfAttempts: 5,
            firstRetryInterval: TimeSpan.FromSeconds(2),
            backoffCoefficient: 2.0,
            maxRetryInterval: TimeSpan.FromMinutes(1)));

        await context.CallActivityAsync(nameof(ReserveStockActivity), order, retry);
        var payment = await context.CallActivityAsync<PaymentResult>(
            nameof(ChargePaymentActivity), order, retry);

        if (!payment.Succeeded)
        {
            // Saga compensation: undo the reservation
            await context.CallActivityAsync(nameof(ReleaseStockActivity), order, retry);
            logger.LogWarning("Payment failed for {OrderId}: {Reason}",
                order.OrderId, payment.Reason);
            return "Cancelled";
        }

        try
        {
            // Durable wait: costs nothing while idle and survives restarts
            await context.WaitForExternalEventAsync<bool>(
                "ShipmentConfirmed", TimeSpan.FromDays(3));
            return "Completed";
        }
        catch (TaskCanceledException)
        {
            await context.CallActivityAsync(nameof(EscalateActivity), order);
            return "Escalated";
        }
    }
}

public interface IPaymentGateway
{
    Task<PaymentResult> ChargeAsync(string customerId, decimal amount, string idempotencyKey);
}

// Activities are normal DI-enabled classes and may perform I/O.
// ReserveStockActivity, ReleaseStockActivity and EscalateActivity follow the same shape.
public sealed class ChargePaymentActivity(IPaymentGateway payments)
    : WorkflowActivity<CheckoutRequest, PaymentResult>
{
    public override Task<PaymentResult> RunAsync(WorkflowActivityContext context,
        CheckoutRequest order) =>
        payments.ChargeAsync(order.CustomerId, order.Total, context.TaskExecutionKey);
}

// Program.cs: explicit registration works in every 1.x SDK; 1.18 can discover types itself
builder.Services.AddDaprWorkflow(options =>
{
    options.RegisterWorkflow<CheckoutWorkflow>();
    options.RegisterActivity<ReserveStockActivity>();
    options.RegisterActivity<ChargePaymentActivity>();
    options.RegisterActivity<ReleaseStockActivity>();
    options.RegisterActivity<EscalateActivity>();
});

app.MapPost("/checkout", async (CheckoutRequest order, DaprWorkflowClient workflows) =>
{
    var id = await workflows.ScheduleNewWorkflowAsync(
        nameof(CheckoutWorkflow), $"checkout-{order.OrderId}", order);
    return Results.Accepted($"/checkout/{id}", new { id });
});

app.MapPost("/checkout/{id}/shipped", async (string id, DaprWorkflowClient workflows) =>
{
    await workflows.RaiseEventAsync(id, "ShipmentConfirmed", true);
    return Results.NoContent();
});