如何摆脱大量if/switch，处理多输入组合的交易状态判断逻辑？

针对你提到的4个bool输入映射TransactionStatus的场景，以下几种方案可以彻底摆脱嵌套if/switch，且扩展性更强：

1. 键值对映射字典（最直接方案） #

把输入的bool组合封装成可哈希的类型（比如C#的ValueTuple），作为字典的键，对应值为目标TransactionStatus。新增规则只需往字典里加条目，无需修改核心逻辑。

// 假设已定义TransactionStatus枚举
public enum TransactionStatus
{
    Pending,
    Success,
    Failed,
    Retry,
    Cancelled
}

public class TransactionStatusResolver
{
    // 初始化规则字典：键是4个bool的组合，值是对应的状态
    private static readonly Dictionary<(bool, bool, bool, bool), TransactionStatus> _statusMap = new()
    {
        {(true, true, false, false), TransactionStatus.Success},
        {(true, false, true, false), TransactionStatus.Retry},
        {(false, true, false, true), TransactionStatus.Failed},
        // 其他组合规则...
    };

    public TransactionStatus GetStatus(bool input1, bool input2, bool input3, bool input4)
    {
        // 匹配规则，无匹配时返回默认状态（比如Pending）
        return _statusMap.TryGetValue((input1, input2, input3, input4), out var status) 
            ? status 
            : TransactionStatus.Pending;
    }
}

适用场景：输入是固定数量的布尔值/枚举值，规则都是明确的输入组合匹配，新增规则只需添加字典条目。

2. 规则类+Predicate列表（支持复杂条件） #

如果后续规则不止是简单的bool组合，需要更复杂的判断逻辑（比如结合数值范围、其他对象属性），可以定义规则类，用Predicate封装判断逻辑，遍历规则列表找到第一个匹配项。

public class StatusRule
{
    public Predicate<(bool, bool, bool, bool)> Condition { get; set; }
    public TransactionStatus TargetStatus { get; set; }
}

public class TransactionStatusResolver
{
    private static readonly List<StatusRule> _rules = new()
    {
        new StatusRule
        {
            Condition = inputs => inputs.Item1 && inputs.Item2 && !inputs.Item3 && !inputs.Item4,
            TargetStatus = TransactionStatus.Success
        },
        new StatusRule
        {
            Condition = inputs => inputs.Item1 && !inputs.Item2 && inputs.Item3,
            TargetStatus = TransactionStatus.Retry
        },
        // 新增规则直接加在这里
    };

    public TransactionStatus GetStatus(bool input1, bool input2, bool input3, bool input4)
    {
        var inputTuple = (input1, input2, input3, input4);
        // 找到第一个满足条件的规则
        var matchedRule = _rules.FirstOrDefault(r => r.Condition(inputTuple));
        return matchedRule?.TargetStatus ?? TransactionStatus.Pending;
    }
}

适用场景：规则需要复杂逻辑判断，或者未来可能扩展非布尔类型的输入条件，灵活性更强。

3. 轻量规则引擎（适合大规模规则场景） #

如果后续规则数量极多、需要动态加载/修改规则（比如从配置文件读取），可以使用轻量规则引擎，比如利用C#的System.ComponentModel.Composition实现规则插件化，或者用表达式树动态解析配置中的规则表达式。

示例（简化版配置驱动规则）：

// 从配置文件读取规则（比如JSON）
public class ConfigRule
{
    public string ConditionExpression { get; set; } // 比如"input1 && input2"
    public TransactionStatus TargetStatus { get; set; }
}

// 运行时编译表达式树匹配规则（省略具体编译逻辑）
public TransactionStatus GetStatusFromConfig(bool input1, bool input2, bool input3, bool input4)
{
    var configRules = LoadRulesFromConfig();
    foreach(var rule in configRules)
    {
        // 动态编译ConditionExpression为委托，判断是否匹配
        if(EvaluateExpression(rule.ConditionExpression, input1, input2, input3, input4))
        {
            return rule.TargetStatus;
        }
    }
    return TransactionStatus.Pending;
}

适用场景：规则需要动态配置、热更新，或者规则数量达到数十条以上，便于统一管理。

内容的提问来源于stack exchange，提问作者marcuthh