enRose

public class RuleEngine<T> where T : class, new()
{
    public Dictionary<Type, object> SideEffect { get; set; }
        = new Dictionary<Type, object>();

    public RuleResultWithSideEffect FirstFailsWithSideEffect(
        IList<Func<T, RuleResultWithSideEffect>> sequentialRules, T ruleCtx)
    {
        RuleResultWithSideEffect firstFailed = null;

enRose

public class RuleResultWithSideEffect
{
    public bool IsValid { get; set; }
    public string Reason { get; set; }
    public (Type type, object val) SideEffect { get; set; }
}

enRose

public static RuleResult FirstFails<T> (
    this IList<Func<T, RuleResult>> sequentialRules, T ruleCtx)
    where T : class, new()
{
    return new RuleEngine<T>().FirstFails(sequentialRules, ruleCtx);
}

enRose

public class MarsService
{
    public RuleResult ApplyCreditCard()
    {
        var ctx = new ClusterRuleCtx();

        return new RuleCluster().Rules.FirstFails(ctx);
    }
}

enRose

public class RuleCluster
{
    public List<Func<ClusterRuleCtx, RuleResult>> Rules { get; set; }

    public RuleCluster()
    {
        Rules = new List<Func<ClusterRuleCtx, RuleResult>>() {};

        Rules.AddRange(new EligibilityRule().Rules);

enRose

public class MarsRule
{
    public List<Func<ClusterRuleCtx, RuleResult>> Rules =>
        new List<Func<ClusterRuleCtx, RuleResult>> {
            NumOfYearsOnMarsRule,
            AddressRule_CSharp_8
        };

    public RuleResult NumOfYearsOnMarsRule(ClusterRuleCtx ctx)
    {

enRose

public class EligibilityRule
  {
      public List<Func<ClusterRuleCtx, RuleResult>> Rules =>
          new List<Func<ClusterRuleCtx, RuleResult>> {
              TermsConditionsRule,
              AgeRule
          };

      public RuleResult TermsConditionsRule(ClusterRuleCtx ctx)
      {

enRose

public class ClusterRuleCtx
{
    public Application App { get; set; }

    public List<Reference> References { get; set; }
}

enRose

static async Task ProcessTaskAsTheyCompleteAsyncAndProcessingInOneUnit()
{
    var resultContext = new Result();

    Func<Task> t1 = async () =>
    {
        var r = await APICall1();

        resultContext.Result1 = ProcessResult1(r);
    };

enRose

static async Task ProcessTasksAsTheyCompleteV1()
{
    var result = new Result();

    async Task<Action> t1()
    {
        var r = await APICall1();

        return () => result.Result1 = ProcessResult1(r);
    }