Stop Hardcoding Business Rules: Building a Dynamic Workflow Engine in C#

[ Incoming Request ]
         │
         ▼
[ Dynamic Workflow Engine ]
         │
         ├── 1. Fetch Steps & JSON Rules from Database
         │
         ├── 2. Evaluate Dynamic Rules (Microsoft.RulesEngine)
         │        ├── Passed ──► Proceed
         │        └── Failed ──► Abort & Return Reason
         │
         └── 3. Execute Step Handler (via Keyed DI)

public class OrderContext
{
    public string OrderId { get; set; } = string.Empty;
    public decimal Amount { get; set; }
    public int CustomerAge { get; set; }
    public int CreditScore { get; set; }

    public bool IsAborted { get; private set; }
    public string AbortReason { get; private set; } = string.Empty;

    public void Abort(string reason)
    {
        IsAborted = true;
        AbortReason = reason;
    }
}

[
  {
    "WorkflowName": "PaymentRules",
    "Rules": [
      {
        "RuleName": "HighValueCreditCheck",
        "ErrorMessage": "Orders over $5,000 require a Credit Score of at least 700.",
        "Expression": "Amount <= 5000 || CreditScore >= 700"
      }
    ]
  }
]

public interface IWorkflowHandler
{
    Task HandleAsync(OrderContext context, Func<Task> next);
}

public class DynamicWorkflowEngine
{
    private readonly IServiceProvider _serviceProvider;

    public DynamicWorkflowEngine(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;

    public async Task ExecuteAsync(OrderContext context, List<DbWorkflowStep> steps)
    {
        foreach (var step in steps)
        {
            if (context.IsAborted) break;

            // Step 1: Evaluate DB-stored Rules
            if (!string.IsNullOrWhiteSpace(step.StepRulesJson))
            {
                var workflowList = JsonConvert.DeserializeObject<List<WorkflowRules>>(step.StepRulesJson);
                var re = new RulesEngine.RulesEngine(workflowList.ToArray());

                var results = await re.ExecuteAllRulesAsync(workflowList[0].WorkflowName, context);

                if (results.Any(r => !r.IsSuccess))
                {
                    var failedRule = results.First(r => !r.IsSuccess);
                    context.Abort($"Rule failed at {step.HandlerKey}: {failedRule.Rule.ErrorMessage}");
                    break;
                }
            }

            // Step 2: Execute Handler from DI
            var handler = _serviceProvider.GetKeyedService<IWorkflowHandler>(step.HandlerKey);
            if (handler != null)
            {
                await handler.HandleAsync(context, () => Task.CompletedTask);
            }
        }
    }
}