-2

在Clean Code book 中有一种观点认为，最佳实践是使用没有传入和传出参数的函数。所以我的问题是，使用相互传递 args 的函数或共享和操作静态对象的 void 函数更有意义？

例子：

选项1。

public List<MyThing> FunctionA(List <MyThing> myThings){

myThings.Add(SomeBlah);

return myThings;     
}

public void FunctionB(){

List<MyThing> myThings = new List<MyThing>();

myThings = InitiateThingsOrWhatever();

List<MyThing> myChangedThings = FunctionA(myThings);  
}

选项 2：

private static List<MyThing> _myThings = new List<MyThing>();

public static List<MyThing> MyThings{
get { return _myThing; }
set { _myThing = value; }
}

public void SomeFunction(){

FunctionA();
FunctionB();
}

public void FunctionA(){

MyThings = YadaYadaStuff();     
}

public void FunctionB(){

var showMyChangedThings = MyThings; 
}
4

3 回答 3

4

传递参数比使用共享静态数据要好得多。

我相信您误解了（或直接阅读）该建议。据我所知，没有建议使用静态共享数据而不是在那本书中传递参数。

建议是尽量减少传递给成员函数的参数数量。通常，您可以将“很多参数”转​​换为一个类，而不是提供没有参数的方法来执行原始函数。

将一些参数转换为对象的示例：

int MultiplySome(int arg1, int arg2, int arg3) 
{ 
   return arg1 * arg2 * arg3;
}

可以转换为具有较少参数的方法的对象：

class MultiplySomeClass
{  
   public int First;
   public int Second;

   int MultiplyBy(int arg3) { return First * Second * arg3;}
}

并调用从：

var result = MultiplySome(4,5,6);

var multiplyHelper = new MultiplySomeClass { First = 4, Second = 5 };
var result = multiplyHelper.MultiplyBy(6);
于 2013-04-05T17:50:05.480 回答
1

在您引用的文章中，鲍勃叔叔正在讨论单个类中函数之间的交互。他建议您将通常在这些函数之间传递的数据移动到对象的私有属性中。所以这不是创建全局数据，而是全部封装在类中。静态数据/函数方法正在污染全局命名空间。

于 2013-04-05T17:52:15.113 回答
0

static 从来都不好，选项 2 中的设计在几乎任何软件中都无法使用，如果您有两个必须保持不同状态的同一类的对象怎么办？

于 2013-04-05T17:54:23.387 回答