检查内部方法是否传递了一些可选参数

Question

如何检查是否将可选参数传递给方法？

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint = 10)
{

    if (optionalint was passed)
       return;
}

另一种方法是使用Nullable<T>.HasValue（MSDN definitions，MSDN examples）：

int default_optionalint = 0;

public void ExampleMethod(int required, int? optionalint,
                            string optionalstr = "default string")
{
    int _optionalint = optionalint ?? default_optionalint;
}

Answer 1

使用 nullable 是一个很好的解决方案。请参见下面的示例

public static void ExampleMethod(bool? optionalBool = null)
{
    Console.WriteLine(optionalBool == null ? "Value not passed" : "Value passed");
}


public static void Main()
{
    ExampleMethod();
    ExampleMethod(true);
    ExampleMethod(false);
}

Answer 2

死灵一个旧线程，但我想我会添加一些东西。

您可以使用default(int) 或new int()

对于某些情况，默认值可用于检查参数的传递位置。这适用于多种数据类型。 https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table

public void ExampleMethod(int optionalInt = default(int))
{
    if (optionalInt == default(int)) //no parameter passed
       //do something
    else  //parameter was passed
       return;
}

这在传递数据库 id 时特别有效，其中记录包含大于 0 的无符号整数。因此您知道 0 将始终为空，并且任何 id 都不能为负数。换句话说，除了 default(datatype) 之外的所有内容都将被接受为传递参数。

---

我个人会使用重载方法，但另一种方法（可能超出此问题的范围）是将输入参数放入模型中。然后使用模型力边界（比如 10 是默认参数），这让 模型处理参数，而不是方法。

public class Example
{
    //...other properties

    private int _optionalInt;
    public int OptionalInt {
        get => _optionalInt;
        set {
            if (value <= default(int))
                throw new ArgumentOutOfRangeException("Value cannot be 0 or less");
            else if (value == 10)
                throw new ArgumentOutOfRangeException("Value cannot be 10");
            else
                _initValue = value;
        } 
    }

    public Example(int optionalInt)
    {
        OptionalInt = optionalInt; //validation check in constructor
    }
}

这会在行为到达您的方法之前强制执行。

希望这对某人有所帮助。

Answer 3

判断一个参数是否已经传递给可选参数

1. 定义一个极不可能的值作为参数的默认值。
2. 如果可选参数是 String 等引用类型，则可以使用 null 作为默认值，前提是这不是参数的预期值。
3. 在过程代码中，将参数与默认值进行比较并采取适当的措施。

https://msdn.microsoft.com/en-us/library/849zff9h(v=vs.100).aspx

Answer 4

另一种方法是使用Nullable<T>.HasValue（MSDN definitions，MSDN examples）：

int default_optionalint = 0;

public void ExampleMethod(int required, int? optionalint,
                            string optionalstr = "default string")
{
    int _optionalint = optionalint ?? default_optionalint;
}

Answer 5

您不能，因此您需要找到一种不同的方法来检查“可选”参数。如果参数没有被使用，你可以传入一个null，然后检查

if (optionalstr != null)
{
    // do something
}

您也可以重载该方法，一个采用可选参数，一个不采用可选参数。此外，您可以使不带可选参数的方法将空值传递给重载方法之一。

public void ExampleMethod(int required)
{
    ExampleMethod(required, null, 0);
}

public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
{

}

Answer 6

你不能在 C# 中做到这一点。

但是，您可以重载该函数以采用不同的参数。顺便说一句，这是您在 Java 中可以采用的唯一方法，因此如果您采用它，您将是一个很好的伙伴。

Answer 7

您不能直接检查，但可以默认检查。 例如：

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint = 10)
{

    if (optionalint == 10)
       return;
}

或

public void ExampleMethod(int required, string optionalstr = "default string",
    int? optionalint)
{

    if (required.HasValue==false)
       return;
}

方法2：

你也可以使用覆盖方法：

public void ExampleMethod(int required, string optionalstr = "default string")
{
     //When this method called, means optionalint was NOT passed
}

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint)
{
    //When this method called, means optionalint was passed
}

Answer 8

嗯，参数总是被传递的。默认参数值只是确保用户在调用函数时不必显式指定它们。

当编译器看到这样的调用时：

ExampleMethod(1);

它默默地将其转换为：

ExampleMethod(1, "default string", 10);

因此，在技术上无法确定参数是否在运行时传递。你能得到的最接近的是：

if (optionalstr == "default string")
   return;

但是如果用户像这样显式调用它，它的行为会相同：

ExampleMethod(1, "default string");

如果您真的想根据是否提供参数来获得不同的行为，另一种方法是摆脱默认参数并使用重载，如下所示：

public void ExampleMethod(int required)
{
    // optionalstr and optionalint not provided
}

public void ExampleMethod(int required, string optionalstr)
{
    // optionalint not provided
}

public void ExampleMethod(int required, string optionalstr, int optionalint)
{
    // all parameters provided
}

Answer 9

你不能，基本上。为这些调用生成的 IL 完全相同相同：

ExampleMethod(10);
ExampleMethod(10, "default string");
ExampleMethod(10, "default string", 10);

编译器在调用站点执行默认设置。

如果您真的希望这两个调用都有效但可区分，则可以使用重载：

// optionalint removed for simplicity - you'd need four overloads rather than two
public void ExampleMethod(int required)
{
    ExampleMethodImpl(required, "default string", false);
}

public void ExampleMethod(int required, string optionalstr)
{
    ExampleMethodImpl(required, optionalstr, true);
}

private void ExampleMethodImpl(int required, int optionalstr, bool optionalPassed)
{
    // Now optionalPassed will be true when it's been passed by the caller,
    // and false when we went via the "int-only" overload
}

Answer 10

您无法检查，因为带有可选参数的方法是带有所有参数的常规方法，包括具有默认值的参数。所以，你的方法会被编译成：

public void ExampleMethod(int required, string optionalstr, int optionalint)
{

}

编译器在调用点插入默认值。如果你会写

ExampleMethod(42);

然后编译器会生成调用

ExampleMethod(42, "default string", 10);

您可以比较 optionalstr 或 optionalint 的值是否等于默认值，但您无法确定它是由编译器还是开发人员提供的。