C# 最佳实践：创建方法、不同重载

比如说，我们有一个方法，为了便于讨论，我们将其称为MethodOne

public void MethodOne()
    {
      //do stuff. 
    }

现在让我们假设我们想要创建一个可选的peramater，我们可能会决定创建另一个同名的方法，例如，使用不同的重载

public void MethodOne()
    {
       //do stuff.
    }

public void MethodOne(bool checkVar)
    {
       if(checkVar)
        {
           //do stuff
        }
       else
        {
          //do other stuff
        }
    }

 public void MethodOne(int? testVar)
     {
        if(testVar != null)
         { 
           //do stuff
         }
     }

现在我们有了一个方法，它有两种不同的重载组合。在实践中，这是否比使用一个方法更好，例如，只检查可选重载是否为null或是否包含信息

public void MethodOne()
    {
       //do stuff.
    }

public void MethodOne(bool checkVar)
    {
       if(checkVar)
        {
           //do stuff
        }
       else
        {
          //do other stuff
        }
    }

 public void MethodOne(int? testVar)
     {
        if(testVar != null)
         { 
           //do stuff
         }
     }

仅使用一个重载似乎很简单，但假设我有5个变量要传递，我会创建5个方法，使用不同的重载使用相同的名称，还是只创建一个方法并检查传递的变量？

您可以使用：

您可以做的是使用：

---

有一些解决办法。例如，您可以使用一个枚举数和一个对象数组作为第二个参数，其中包含真实的参数值，这样您就可以通过切换枚举数知道如何处理数据。。。或者您可以只声明5个对象参数，然后在开关中检查它们的类型，相应地将它们框起来，然后继续。但这两种选择都是非常糟糕的做法

我建议您坚持使用不同的重载：

public void MethodOne(Boolean value)
{
    // Process the value...
}

public void MethodOne(Int32 value)
{
    // Process the value...
}

public void MethodOne(Int32 value, String text)
{
    // Process the value and the text...
}

// And so on...

或参数声明中的默认数据：

public void MethodOne(Int32 integer = 1, String text = "hello", ...)
{
    // Process everything inside the method...
}

或参数化方法，如果每个对象类型都有一个公共处理：

public void MethodOne(params Object[] parameters)
{
    for (int i = 0; i < parameters.Length; ++i)
        // Check type of parameter and process the value...
}

---

有一些解决办法。例如，您可以使用一个枚举数和一个对象数组作为第二个参数，其中包含真实的参数值，这样您就可以通过切换枚举数知道如何处理数据。。。或者您可以只声明5个对象参数，然后在开关中检查它们的类型，相应地将它们框起来，然后继续。但这两种选择都是非常糟糕的做法

我建议您坚持使用不同的重载：

public void MethodOne(Boolean value)
{
    // Process the value...
}

public void MethodOne(Int32 value)
{
    // Process the value...
}

public void MethodOne(Int32 value, String text)
{
    // Process the value and the text...
}

// And so on...

或参数声明中的默认数据：

public void MethodOne(Int32 integer = 1, String text = "hello", ...)
{
    // Process everything inside the method...
}

或参数化方法，如果每个对象类型都有一个公共处理：

public void MethodOne(params Object[] parameters)
{
    for (int i = 0; i < parameters.Length; ++i)
        // Check type of parameter and process the value...
}

---

您通常会遇到如下重载：

public void MethodOne()
{
    MethodOne(1)
}
public void MethodOne(int testVar)
{
    MethodOne(testVar, "test")
}
public void MethodOne(int testVar, string testString)
{
    MethodOne(testVar, testString, null)
}
public void MethodOne(int testVar, string testString, object testObject)
{
    // Do your actual code here
}

这相当于

public void MethodOne(int testVar = 1, string testString = "test", object testObject = null)
{
    // Do your actual code here
}

---

但通常您应该在默认参数上预先设置重载。此外，通过像我的示例中那样的“冒泡”，您可以避免冗余代码或冗余的“默认参数”

您通常会遇到如下重载：

public void MethodOne()
{
    MethodOne(1)
}
public void MethodOne(int testVar)
{
    MethodOne(testVar, "test")
}
public void MethodOne(int testVar, string testString)
{
    MethodOne(testVar, testString, null)
}
public void MethodOne(int testVar, string testString, object testObject)
{
    // Do your actual code here
}

这相当于

public void MethodOne(int testVar = 1, string testString = "test", object testObject = null)
{
    // Do your actual code here
}

---

但通常您应该在默认参数上预先设置重载。此外，通过像我的示例中那样“冒泡”，可以避免随着参数数量的增加而出现冗余代码或冗余的“默认参数”

，我不想查看方法的嵌套if/else逻辑来确定使用了哪些参数。它很难阅读、理解和维护，并可能导致错误。使用重载并保持方法简洁、精简和可维护。

随着参数数量的增加，我不想查看方法的嵌套if/else逻辑来确定使用了哪些参数。它很难阅读、理解和维护，并可能导致错误。使用重载并保持方法简洁、精简和可维护。

事实上，如果你有五个参数，并且它们都是可选的，那么你最终可能会得到最多2^5=32个重载。这不是重点：p但是是的，我明白了。如果你有一个有五个参数的方法，而其中任何一个或所有参数都可以为null，那么你就有一个不同的问题：你的方法可能做得太多了，应该分成更小的方法，每个方法都有一个责任。@Shane.C这正是问题的关键。如果您需要使用32个构造函数重载，那么您就做错了：正如Daniel指出的，您可能需要检查方法的内聚性。您所描述的内容听起来像是通信衔接：您所编写的代码是为了对相同的数据进行操作。通常建议努力实现更高的内聚性，比如函数内聚性，方法中的所有代码都参与到一个定义良好的任务中。通过努力实现函数内聚，你的耦合自然会下降。你的参数不会有太大的问题。实际上，如果你有五个参数，并且它们都是可选的，那么你可能会得到最多2^5=32个重载。这是除此之外的一点：P，但是是的，我明白了。如果你有一个有五个参数的方法，而其中任何一个或所有参数都可以为null，那么你就有一个不同的问题：你的方法可能做得太多了，应该分成更小的方法，每个方法都有一个责任。@Shane.C这正是问题的关键。如果您需要使用32个构造函数重载，那么您就做错了：正如Daniel指出的，您可能需要检查方法的内聚性。您所描述的内容听起来像是通信衔接：您所编写的代码是为了对相同的数据进行操作。通常建议争取更高的内聚性，比如函数内聚性，方法中的所有代码都参与到sin中

---

定义明确的任务。通过努力实现函数内聚，你的耦合自然会下降。你的参数不会有太大的问题。我们做了一个int？，错过了那个。好了，我们做了一个int？，错过了那个。我敢打赌，这将是大多数人的想法，特别是如果你接管了别人的代码。我敢打赌，这将是大多数人的想法，特别是如果你接管了别人的代码。