C#重构注意事项

我有以下疑问

对于重构，我已经读到创建具有特定职责的方法是一个好主意，因此如果可能的话，将一个复杂的方法拆分为其他小方法是一个好主意

但是想象一下我有这样一个案例：

我必须创建一个对象列表，在创建这些对象时，我必须创建另一个对象。诸如此类：

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 myComplexMethod（List paramObjectsA）
{
foreach（paramObjectsA中的MyTypeA iteratorA）
{
//创建类型为B的myObjectB
//创建类型为C的MyObject 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;
    }
}

public void myMethodCreateB（列表参数objectsa）
{
foreach（paramObjectsA中的MyTypeA iteratorA）
{
//创建类型为B的myObjectB
}
}
public void myMethodCreateB（列表参数objectsb）
{
foreach（paramObjectsB中的MyTypeB迭代器）
{
//创建类型为C的MyObject C
iteratorB.PropertyC=myObjectC；
}
}

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

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

---

非常感谢。

我通常把可读性放在比性能更高的优先级上，除非另有证明。我现在有点泛化了，但根据我的经验，当人们过于关注代码级别的性能时，结果是代码的可维护性较差，这会分散他们创建功能正确的代码的注意力，需要更长的时间（=更多的钱），并且可能会导致代码的性能更低

所以不用担心，使用更具可读性的方法。如果你的应用程序最终真的太慢了，那么通过一个分析器运行它，找出（并证明）需要优化的一两个地方。我可以向你保证不会是这个密码

---

早期在体系结构级别做出正确的选择更为关键，因为一旦你的应用程序构建完成，你将无法轻松地在该级别进行更改。

我通常将可读性放在比性能更高的优先级上，除非有其他证明。我现在有点泛化了，但根据我的经验，当人们过于关注代码级别的性能时，结果是代码的可维护性较差，这会分散他们创建功能正确的代码的注意力，需要更长的时间（=更多的钱），并且可能会导致代码的性能更低

所以不用担心，使用更具可读性的方法。如果你的应用程序最终真的太慢了，那么通过一个分析器运行它，找出（并证明）需要优化的一两个地方。我可以向你保证不会是这个密码

---

早期在架构级别做出正确的选择更为关键，因为一旦你的应用程序构建完成，你将无法轻松地在该级别进行更改。

在这种情况下，我通常会继续使用一个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);
    }
}

public void myComplexMethod（List paramObjectsA）
{
foreach（paramObjectsA中的MyTypeA iteratorA）
{
MyTypeB myObjectB=MyTypeB.Create（迭代器）；
}
}

在这种情况下，我通常会继续使用一个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);
    }
}

public void myComplexMethod（List paramObjectsA）
{
foreach（paramObjectsA中的MyTypeA iteratorA）
{
MyTypeB myObjectB=MyTypeB.Create（迭代器）；
}
}

目前尚不清楚myComplexMethod和myMethodCreateB重载1和2之间的关系（即，两个备选方案的交付方式不同）。请更好地解释您的具体情况（=编写一段代码，说明所有这些方法实际上是如何连接的）。目前尚不清楚myComplexMethod和myMethodCreateB重载1和2之间的关系（即，两个备选方案的效果并不相同）。请更好地解释您的具体情况（=编写一段代码，说明所有这些方法实际上是如何连接的）。您如何知道第二种方法的性能是更好还是更差？这些代码根本不相关。据推测，第一个备选方案有两个嵌套循环，它们在第二个方案中转换为两个不同的函数，但这只是一个猜测。无论如何，循环的数量似乎保持不变（否则第二个版本将如何提供相同的结果？）。名称略有不同，在我看来，可以通过以下方式加以改进：足够清楚。第一个示例有一个循环，该循环创建两个对象并在该循环中执行父子赋值。第二个示例有两个循环：第一个循环创建父循环，第二个循环创建子循环，第二个循环分配父子循环。对不起，Christoph，这是不可能的：如果第一个代码可以用一个循环创建所有内容（即paramObjectsB不是集合），那么第二个备选方案中的两个循环就没有意义了。唯一合乎逻辑的解释是有两个集合（paramObjectsA和paramObjectsB）。在第一个备选方案中，有两个嵌套循环（未显示；它应该是//Create myObjectB of type B part），在第二个备选方案中，通过调用具有两个重载的函数实现相同的循环。在任何情况下，OP都应该发布一个实际可测试的代码（与这里的情况相差很远）。给出的例子没有意义。在任何情况下，我都坚持我的普遍观点，即选择可维护性和可读性比过早优化更好。@Christoph-尽管OP的代码没有太多意义，但我认为您的