.NET中如何避免使用switch语句？角色场景优化方案

针对根据角色执行不同逻辑的场景，替代switch的核心思路是将分支逻辑分散到各自的职责单元，避免集中式的条件判断导致代码臃肿难维护。以下是几种适合C#场景的实现方案：

1. 策略模式（Strategy Pattern） #

把每个角色对应的业务逻辑封装成独立的策略类，通过工厂类统一分发，完全符合开闭原则——新增角色时只需添加新的策略类，无需修改原有逻辑。

实现步骤： #

1. 定义策略接口：

public interface IRoleStrategy
{
    void Execute();
}

2. 为每个角色实现策略类：

public class AdminStrategy : IRoleStrategy
{
    public void Execute()
    {
        // 执行Admin角色专属逻辑
    }
}

public class AgentStrategy : IRoleStrategy
{
    public void Execute()
    {
        // 执行Agent角色专属逻辑
    }
}

public class ResponsibleStrategy : IRoleStrategy
{
    public void Execute()
    {
        // 执行Responsible角色专属逻辑
    }
}

3. 编写工厂类获取对应策略：

public static class RoleStrategyFactory
{
    public static IRoleStrategy GetStrategy(Role role)
    {
        return role switch
        {
            Role.admin => new AdminStrategy(),
            Role.agent => new AgentStrategy(),
            Role.responsible => new ResponsibleStrategy(),
            _ => throw new ArgumentOutOfRangeException(nameof(role), "未知角色类型")
        };
    }
}

4. 调用方式：

IRoleStrategy strategy = RoleStrategyFactory.GetStrategy(value);
strategy.Execute();

2. 枚举扩展方法 #

直接给Role枚举扩展专属方法，把所有分支逻辑集中到一个扩展类中，既保留枚举的简洁性，又避免switch散落在业务代码里。

实现代码： #

public enum Role
{
    admin = 1,
    agent = 2,
    responsible = 3
}

public static class RoleExtensions
{
    public static void ExecuteAction(this Role role)
    {
        switch (role)
        {
            case Role.admin:
                // Admin角色逻辑
                break;
            case Role.agent:
                // Agent角色逻辑
                break;
            case Role.responsible:
                // Responsible角色逻辑
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(role));
        }
    }
}

调用方式： #

value.ExecuteAction();

这种方案适合逻辑相对简单、角色扩展频率不高的场景，代码量少且易维护。

3. 字典映射委托 #

用Dictionary将枚举值直接映射到对应的委托方法，通过字典查找快速执行逻辑，代码简洁直观。

实现代码： #

// 建议放到静态类中初始化，确保只加载一次
private static readonly Dictionary<Role, Action> _roleActionMap = new Dictionary<Role, Action>
{
    { Role.admin, () => { /* Admin角色逻辑 */ } },
    { Role.agent, () => { /* Agent角色逻辑 */ } },
    { Role.responsible, () => { /* Responsible角色逻辑 */ } }
};

// 调用逻辑
if (_roleActionMap.TryGetValue(value, out var action))
{
    action.Invoke();
}
else
{
    throw new ArgumentOutOfRangeException(nameof(value), "未定义该角色的处理逻辑");
}

如果需要传递参数，可以把Action换成Action<T>或自定义委托类型，灵活性很高。

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