C# OOP约定-单函数方法

在OOP和所有编程中，我知道一个方法应该只执行一个特定任务是一条明确的规则，如果需要执行另一个任务，那么应该创建另一个方法。我的问题是，在我的情况下，这似乎毫无意义，因为它只是使用了更多的代码，而不是一个大方法

下面是我的代码的两种结构方式（一种遵循标准惯例，另一种不遵循标准惯例，但保存代码）

情景1（2种方法）

递增统计法

public void increaseStat(short value, string stat)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   stamina += value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       }

public void decreaseStat(short value, string stat)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   stamina -= value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       } 

递减统计法

public void increaseStat(short value, string stat)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   stamina += value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       }

public void decreaseStat(short value, string stat)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   stamina -= value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       } 

正如您所看到的，除了1个操作是+而不是-，代码是完全相同的。因此，我决定这样做，而不是为了惯例而将所有代码复制到另一个方法中

场景2（1个处理增加和减少的大方法）

这样，通过添加一个简单的if语句，我在每个案例中添加了两行额外的代码，但节省了大量被复制的代码

我只是想听听大家对这是否被视为良好编程实践的看法

感谢您抽出时间。

您可以执行以下操作：

public void Change(string stat, bool decrease)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   if(decrease)
                      stamina -= value;
                   else
                      stamina += value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       }
}

因此，创建一种方法，通过收费来减少或增加传递的值。它所做的是基于

bool

参数

这可能是第二种情况下的一种“形状”，但解决方案略有不同

可以执行以下操作：

public void Change(string stat, bool decrease)
{
       switch (stat)
       {
           case "stamina":
               if (staminaCheck.Checked == true)
               {
                   if(decrease)
                      stamina -= value;
                   else
                      stamina += value;
                   staminaText.Text = Convert.ToString(stamina);
               }
               staminaCheck.Checked = false;
               break;

//There are 5 other similar cases for different stats but to save time I removed them
       }
}

因此，创建一种方法，通过收费来减少或增加传递的值。它所做的是基于

bool

参数

这可能是第二种情况下的一种“形状”，但解决方案略有不同

由于C#有lambdas，这两种解决方案都不理想。相反，我会尝试将操作作为函数传入：

public void modStat(string stat, Func<short, short> op)
{
   switch (stat)
   {
       case "stamina":
           if (staminaCheck.Checked == true)
           { 
               stamina = op(stamina)

               staminaText.Text = Convert.ToString(stamina);
           }
           staminaCheck.Checked = false;
           break;

      // more cases
   }

public void modStat（字符串stat，Func op）
{
开关（stat）
{
案例“耐力”：
if（staminaCheck.Checked==true）
{ 
耐力=op（耐力）
staminaText.Text=Convert.ToString（耐力）；
}
staminaCheck.Checked=false；
打破
//更多案例
}

这也比以前更一般了。理想情况下，我们也可以用同样的方法对属性进行抽象，但这要困难得多（它需要镜头，而C#对镜头没有太多的支持）.

由于C#有lambdas，这两种解决方案都不理想。相反，我会尝试将操作作为函数传递：

public void modStat(string stat, Func<short, short> op)
{
   switch (stat)
   {
       case "stamina":
           if (staminaCheck.Checked == true)
           { 
               stamina = op(stamina)

               staminaText.Text = Convert.ToString(stamina);
           }
           staminaCheck.Checked = false;
           break;

      // more cases
   }

public void modStat（字符串stat，Func op）
{
开关（stat）
{
案例“耐力”：
if（staminaCheck.Checked==true）
{ 
耐力=op（耐力）
staminaText.Text=Convert.ToString（耐力）；
}
staminaCheck.Checked=false；
打破
//更多案例
}

---

这也比以前更一般了。理想情况下，我们也可以用同样的方法对属性进行抽象，但这要困难得多（它需要镜头，而C#对镜头没有太多的支持）在我看来，减少重复代码的好处显然远远超过了分离关注点的规则，尤其是在代码维护方面

类似的场景是使用

Enum

作为对象的状态标志。正确的OOP方法是将每个状态建模为状态层次结构中的一个单独类。后者的缺点是您必须编写代码来找出对象的状态，特别是如果您使用访问者模式（使用OOP时应该这样做）

---

如果您提到的规则涉及到类的接口，则特别有用。如果（对于您的类的用户）更清楚地使用

IncreaseStat（）

和

decresestat（）

操作，而不是使用常规的

ChangeStat（）

，那么没有人会阻止您实现

私有ChangeStat（）

方法，该方法由相应的

public

方法调用，用于增加和减少统计数据。通过这种方式，您可以同时利用两个优点：在内部没有重复代码的情况下，为特定任务执行特定操作。

从我的角度来看，减少重复代码的好处显然远远大于规则关注点的分离，特别是在代码维护方面

类似的场景是使用

Enum

作为对象的状态标志。正确的OOP方法是将每个状态建模为状态层次结构中的一个单独类。后者的缺点是您必须编写代码来找出对象的状态，特别是如果您使用访问者模式（使用OOP时应该这样做）

---

如果您提到的规则涉及到类的接口，则特别有用。如果（对于您的类的用户）更清楚地使用

IncreaseStat（）

和

decresestat（）

操作，而不是使用常规的

ChangeStat（）

，那么没有人会阻止您实现

私有ChangeStat（）

方法，由相应的

public

方法调用，用于增加和减少统计数据。这样，您可以同时利用两个优点：在内部没有重复代码的情况下，为特定任务执行特定操作。

最佳解决方案是，如果您可以从两个世界保留好的东西，因为您需要这两个世界m、 关键是要将公开的公共接口和内部实现（OOP中的基本概念之一）分离开来。如何做到这一点

您仍然可以使用这两个方法，即增加和减少方法，然后将公共代码重构为私有方法，每个增加和减少方法使用适当的标志调用该方法

public void increaseStat(short value, string stat){
    alterStat(value, stat, true);
}

public void decreaseStat(short value, string stat){
    alterStat(value, stat, false);
}


private void alterStat(short value, string stat, bool operator){
    // do the actual work here.
}

在设计类时，这是一个非常重要的模式。同样，我们的想法是将作为类接口公开的内容与如何