有没有办法重构C#独有的switch语句？

我是C#（.NET4.0）项目的新员工，但我有C/C++背景。我被指示“总体上改进我们的产品”，并遇到了一种甚至1000行长的方法，它主要由一个switch语句组成，其中包含15个案例，每个案例大约60行代码

在此之前，我会保持相同的通用格式，但提取了15个函数，然后根据需要研究如何共享/指向局部变量/类数据成员。然而，我现在可以接触到各种各样神秘的新工具，我无法动摇有一种“C#smart”方法可以做到这一点的感觉

是否有一种方法来重构C++中的这个转换语句（4），这是不能在C++中完成的？p> 编辑：这里是一个经过清理和总结的代码形式：

private void DeviceRequest(List<OpRequest> currentOp, double adjTime) {
     //local variables

    while (/*condition*/)
    {
        //Some setup
        //Some initialization

        try
        {
            switch (OperationType)
            {
                case Setup:
                    //Message header setup through 'if-else' statements
                    //Message sending
                    //Many nested 'if' checks, a few less 'else's
                    break;

                case Initiate:
                    //Message header setup through 'if-else' statements
                    //Message sending
                    //Many nested 'if' checks, a few less 'else's
                    break;

                case Acquire:
                    //Message header setup through 'if-else' statements
                    //Message sending
                    //Many nested 'if' checks, a few less 'else's
                    break;

                case Measure:
                    //Message header setup through 'if-else' statements
                    //Message sending
                    //Many nested 'if' checks, a few less 'else's
                    break;

                case Reset:
                    //Message header setup through 'if-else' statements
                    //Message sending
                    //Many nested 'if' checks, a few less 'else's
                    break;

                //12 more cases, all fairly similar.
            }
        }

        catch (RunTimeError err)
        {
            //A few lines of code
        }

        finally
        {
          //Objective measure of time passage
        }
    }
}

private void DeviceRequest（列出当前操作，双调整时间）{
//局部变量
而（/*条件*/）
{
//一些设置
//一些初始化
尝试
{
开关（操作型）
{
案例设置：
//通过“if-else”语句设置消息头
//消息发送
//许多嵌套的“如果”检查，少一些“其他”检查
打破
个案发起人：
//通过“if-else”语句设置消息头
//消息发送
//许多嵌套的“如果”检查，少一些“其他”检查
打破
案例获取：
//通过“if-else”语句设置消息头
//消息发送
//许多嵌套的“如果”检查，少一些“其他”检查
打破
个案措施：
//通过“if-else”语句设置消息头
//消息发送
//许多嵌套的“如果”检查，少一些“其他”检查
打破
案例重置：
//通过“if-else”语句设置消息头
//消息发送
//许多嵌套的“如果”检查，少一些“其他”检查
打破
//还有12起案件，都相当相似。
}
}
捕获（运行时错误）
{
//几行代码
}
最后
{
//时间推移的客观度量
}
}
}

在

枚举

上的

开关

通常可以被操作的

字典

替换。为了做好准备，每个操作必须处理相同的输入

如果可以将代码重构为15个具有相同签名的方法的集合，则可以将它们放入

字典

，其中

DelegateType

是具有方法签名的委托

例如，如果15个方法中的每一个都有下面的签名

private void SetupAction(double adjTime) {
    ...
}
void InitiateAction(double adjTime) {
    ...
}

你可以建立一个行动字典

private readonly IDictionary<OpRequest,Action<double>> OpActions = new Dictionary<OpRequest,Action<double>> {
    {OperationType.Setup, SetupAction}
,   {OperationType.Initiate, InitiateAction}
,   ... // and so on
};

private readonly IDictionary OpActions=新字典{
{OperationType.Setup，SetupAction}
，{OperationType.Initiate，InitiateAction}
，…/等等
};

使用此词典，您可以按如下方式重写循环：

while (/*condition*/) {
    //Some setup
    //Some initialization
    try {
        Action<double> action;
        if (OpActions.TryGetValue(opType, out action)) {
            action(adjTime);
        } else {
            ... // Report an error: unknown OpRequest
        }
    } catch (RunTimeError err) {
        ... //A few lines of code
    }
    finally {
        ... //Objective measure of time passage
    }
}

while（/*条件*/）{
//一些设置
//一些初始化
试一试{
行动；
if（OpActions.TryGetValue（opType，out操作））{
行动（时间）；
}否则{
…//报告错误：未知的OpRequest
}
}捕获（运行时错误）{
…//几行代码
}
最后{
…//时间流逝的客观度量
}
}

告诉我们更多关于开关箱的信息。对于案例之间的重复，您的一般看法是什么？每次看到

switch

语句时，您就知道错过了一次细分的机会。不幸的是，这个问题太宽泛了，无法提出具体的重构。@dasblinkenlight我不是在寻找具体的重构，我很好奇是否有任何C#特有的功能/关键字，如我所述，用于重构一种情况。它与任何其他OO语言几乎相同。拉出方法或重构为继承或分派表。无需寻找使用语言功能的机会-这些机会将在下次使用函数指针时出现（例如）。C#并没有从根本上改变OO设计，它只是让某些场景变得更简单。（+1 b/c此问题远不够糟糕，不能保证得负分。）添加代码的编辑使此问题足够具体，可以重新打开。