Question

我有以下疑问。

对于重构，我读过这是一个很好的创建方法，具有非常特定的响应性，所以如果可能的话，最好将复杂的方法拆分成其他小方法。

但想象一下我有这个案子：

我必须创建一个对象列表，并且insdie这个对象，我必须创建另一个对象。这样的事情：

public void myComplexMethod(List<MyTypeA> paramObjectsA)
{
    foreach(MyTypeA iteratorA in paramObjectsA)
    {
        //Create myObjectB of type B

        //Create myObjectC of type C

        myObjectB.MyPorpertyTpyeC = myObjectC;
    }
}

我可以用两种方法分割这个方法。

public void myMethodCreateB(List<MyTypeA> paramObjectsA)
{
    foreach(MyTypeA iteratorA in paramObjectsA)
    {
        //Create myObjectB of type B
    }
}



public void myMethodCreateB(List<MyTypeB> paramObjectsB)
{
    foreach(MyTypeB iteratorB in paramObjectsB)
    {
        //Create myObjectC of type C
        iteratorB.PropertyC = myObjectC;
    }
}

在第二个选项中，当我使用两个方法而不是一个时，单元测试不那么复杂，但问题是我使用了两个foreach循环，因此它比仅使用第一个选项中的一个循环效率低。

那么，至少在一般情况下，使用更复杂的方法来提高效率或使用更多方法的最佳做法是什么？

非常感谢。

Answer 1

我通常将可读性放在比性能更高的优先级，直到证明不是这样。我现在稍微概括一下，但根据我的经验，当人们在代码级别过多地关注性能时，结果是代码可维护性较差，它会分散他们创建功能正确的代码，需要更长时间（=更多钱），并且可能导致性能更低的代码。

所以不要担心它并使用更易读的方法。如果您的应用程序最终太慢，请通过分析器运行它并精确定位（并证明）需要优化的一两个位置。我可以保证你不会成为这个代码。

尽早在架构层面做出正确的选择更为重要，因为一旦您的应用程序构建完成，您将无法在该级别轻松进行更改。

Answer 2

在这种情况下，我通常会继续使用一个for循环。看起来你只是创建和装饰MyTypeB的对象。我更喜欢在MyTypeB类中创建一个工厂方法：

static MyTypeB Create(MyTypeA a) { // if the creation of MyTypeB depends on A
    //Create myObjectB of type B
    //Create myObjectC of type C
    myObjectB.MyPorpertyTpyeC = myObjectC;
    return myObjectB;
}

然后您的复杂方法将成为：

public void myComplexMethod(List<MyTypeA> paramObjectsA)
{
    foreach(MyTypeA iteratorA in paramObjectsA)
    {
        MyTypeB myObjectB = MyTypeB.Create(iteratorA);
    }
}

C＃重构注意事项

2 个答案: