Question

^{注意：此问题是在C＃尚未支持可选参数时（即在C＃4之前）提出的。}

我们正在构建一个从C＃类以编程方式生成的Web API。该类具有方法GetFooBar(int a, int b)，并且API具有方法GetFooBar，其使用&a=foo &b=bar之类的查询参数。

这些类需要支持可选参数，C＃语言不支持这些参数。什么是最好的方法？

Answer 1

惊讶没有人提到C＃4.0可选参数的工作原理如下：

public void SomeMethod(int a, int b = 0)
{
   //some code
}

编辑：我知道在提出问题时，C＃4.0不存在。但是这个问题在Google中仍然排在“C＃可选参数”的第一位，所以我想 - 这个答案值得在这里。遗憾。

Answer 2

另一种选择是使用params关键字

public void DoSomething(params object[] theObjects)
{
  foreach(object o in theObjects)
  {
    // Something with the Objects…
  }
}

被称为......

DoSomething(this, that, theOther);

Answer 3

在C＃中，我通常会使用多种形式的方法：

void GetFooBar(int a) { int defaultBValue;  GetFooBar(a, defaultBValue); }
void GetFooBar(int a, int b)
{
 // whatever here
}

更新：上面提到的就是我用C＃2.0做默认值的方式。我现在正在使用的项目是使用C＃4.0，它现在直接支持可选参数。这是我在我自己的代码中使用的一个例子：

public EDIDocument ApplyEDIEnvelop(EDIVanInfo sender, 
                                   EDIVanInfo receiver, 
                                   EDIDocumentInfo info,
                                   EDIDocumentType type 
                                     = new EDIDocumentType(EDIDocTypes.X12_814),
                                   bool Production = false)
{
   // My code is here
}

Answer 4

从这个网站：

http://www.tek-tips.com/viewthread.cfm?qid=1500861&page=1

C＃允许使用[Optional]属性（来自VB，但在C＃中不起作用）。所以你可以有这样的方法：

using System.Runtime.InteropServices;
public void Foo(int a, int b, [Optional] int c)
{
  ...
}

在我们的API包装器中，我们检测可选参数（ParameterInfo p.IsOptional）并设置默认值。目标是将参数标记为可选参数，而不是像参数名称中的“可选”那样使用kludges。

Answer 5

您可以使用方法重载...

GetFooBar()
GetFooBar(int a)
GetFooBar(int a, int b)

这取决于方法签名，我给出的示例缺少“int b”only方法，因为它与“int a”方法具有相同的签名。

你可以使用Nullable类型......

GetFooBar(int? a, int? b)

然后，您可以使用a.HasValue检查是否已设置参数。

另一种选择是使用'params'参数。

GetFooBar(params object[] args)

如果您想使用命名参数，则需要创建一个类型来处理它们，尽管我认为Web应用程序已经存在这样的类型。

Answer 6

您可以在C＃4.0中使用可选参数而无需担心。如果我们有这样的方法：

int MyMetod(int param1, int param2, int param3=10, int param4=20){....}

当你调用方法时，你可以跳过这样的参数：

int variab = MyMethod(param3:50; param1:10);

C＃4.0实现了一个名为“命名参数”的功能，您实际上可以按名称传递参数，当然您可以按照您想要的顺序传递参数:)

Answer 7

Hello Optional World

如果希望运行时提供默认参数值，则必须使用反射来进行调用。不像这个问题的其他建议那么好，但与VB.NET兼容。

using System;
using System.Runtime.InteropServices;
using System.Reflection;

namespace ConsoleApplication1
{
    class Class1
    {
        public static void sayHelloTo(
            [Optional,
            DefaultParameterValue("world")] string whom)
        {
            Console.WriteLine("Hello " + whom);
        }

        [STAThread]
        static void Main(string[] args)
        {
            MethodInfo mi = typeof(Class1).GetMethod("sayHelloTo");
            mi.Invoke(null, new Object[] { Missing.Value });
        }
    }
}

Answer 8

允许您在任意位置中省略任何参数的简单方法，正在利用nullable types，如下所示：

public void PrintValues(int? a = null, int? b = null, float? c = null, string s = "")
{
    if(a.HasValue)
        Console.Write(a);
    else
        Console.Write("-");

    if(b.HasValue)
        Console.Write(b);
    else
        Console.Write("-");

    if(c.HasValue)
        Console.Write(c);
    else
        Console.Write("-");

    if(string.IsNullOrEmpty(s)) // Different check for strings
        Console.Write(s);
    else
        Console.Write("-");
}

字符串已经是可以为空的类型，因此它们不需要？。

使用此方法后，以下调用全部有效：

PrintValues (1, 2, 2.2f);
PrintValues (1, c: 1.2f);
PrintValues(b:100);
PrintValues (c: 1.2f, s: "hello");
PrintValues();

当您定义方法时，您可以通过命名自由设置所需的参数。有关命名参数和可选参数的详细信息，请参阅以下链接：

Named and Optional Arguments (C# Programming Guide) @ MSDN

Answer 9

我同意斯蒂芬巴尔。但由于它是一个Web服务，最终用户只使用一种形式的web方法比使用同一方法的多个版本更容易。我认为在这种情况下，Nullable Types非常适合可选参数。

public void Foo(int a, int b, int? c)
{
  if(c.HasValue)
  {
    // do something with a,b and c
  }
  else
  {
    // do something with a and b only
  }  
}

Answer 10

可选参数用于方法。如果你需要一个类的可选参数，那么你是：

使用c＃4.0：在类的构造函数中使用可选参数，这是我更喜欢的解决方案，因为它更接近于使用方法所做的操作，因此更容易记住。这是一个例子：

class myClass
{
    public myClass(int myInt = 1, string myString =
                           "wow, this is cool: i can have a default string")
    {
        // do something here if needed
    }
}

使用c＃4.0之前的c＃版本：你应该使用构造函数链接（使用：this关键字），其中更简单的构造函数导致“主构造函数”。例如：

class myClass
{
    public myClass()
    {
    // this is the default constructor
    }

    public myClass(int myInt)
        : this(myInt, "whatever")
    {
        // do something here if needed
    }
    public myClass(string myString)
        : this(0, myString)
    {
        // do something here if needed
    }
    public myClass(int myInt, string myString)
    {
        // do something here if needed - this is the master constructor
    }
}

Answer 11

如上所述，在C＃中处理这种方法的典型方法是重载该方法。通过使用不同参数创建方法的多个版本，您可以有效地创建可选参数。在参数较少的表单中，通常会调用方法的形式，所有参数都在调用该方法时设置默认值。

Answer 12

您可以重载方法。一种方法包含一个参数GetFooBar(int a)，另一种方法包含两个参数GetFooBar(int a, int b)

Answer 13

使用重载或使用C＃4.0或更高版本

 private void GetVal(string sName, int sRoll)
 {
   if (sRoll > 0)
   {
    // do some work
   }
 }

 private void GetVal(string sName)
 {
    GetVal("testing", 0);
 }

Answer 14

对于大量可选参数，可以将ContainsKey方法与Dictionary的单个参数一起使用。我喜欢这种方法，因为它允许我单独传递List或T，而不必创建其他方法（例如，将参数用作过滤器，则很好）。

示例（如果不需要可选参数，则将传递新的Dictionary （））：

public bool Method(string ParamA, Dictionary<string,Object> AddlParams) {
    if(ParamA == "Alpha" && (AddlParams.ContainsKey("foo") || AddlParams.ContainsKey("bar"))) {
        return true;
    } else {
        return false;
    }
}

Answer 15

在没有默认值的情况下，添加可选参数的方法是使用.NET OptionalAttribute类-https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.optionalattribute?view=netframework-4.8

代码示例如下：

storm jar ... --artifacts "org.clojure:clojure:1.10.0"

Answer 16

您可以使用默认值。

public void OptionalParameters(int requerid, int optinal = default){}

Answer 17

可选参数不过是默认参数！我建议你给他们两个默认参数。 GetFooBar（int a = 0，int b = 0）如果没有任何重载方法，将导致a = 0，b = 0，如果您不传递任何值，如果传递1个值，将导致，则将a的值传递为0，如果您传递2的值，则将1st分配给a，将第二个分配给b。

希望能回答您的问题。

Answer 18

如果有人想要将回调（或delegate）作为可选参数传递，可以这样做。

可选回拨参数：

public static bool IsOnlyOneElement(this IList lst, Action callbackOnTrue = (Action)((null)), Action callbackOnFalse = (Action)((null)))
{
    var isOnlyOne = lst.Count == 1;
    if (isOnlyOne && callbackOnTrue != null) callbackOnTrue();
    if (!isOnlyOne && callbackOnFalse != null) callbackOnFalse();
    return isOnlyOne;
}

Answer 19

我必须在VB.Net 2.0 Web服务中执行此操作。我最终将参数指定为字符串，然后将它们转换为我需要的任何内容。使用空字符串指定了可选参数。不是最干净的解决方案，但它起作用了。请注意，您可以捕获可能发生的所有异常。

Answer 20

我有一个需要7个参数的Web服务。每个都是此Web服务包装的sql语句的可选查询属性。因此，我想到了非可选参数的两种解决方法......两者都很差：

method1（param1，param2，param 3，param 4，param 5，param 6，param7） method1（param1，param2，param3，param 4，param5，param 6）方法1（param1，param2，param3，param4，param5，param7）......开始看图片。这种方式就是疯狂。方式太多了。

现在以更简单的方式看起来很尴尬但应该有效： method1（param1，bool useParam1，param2，bool useParam2等...）

这是一个方法调用，所有参数的值都是必需的，它将处理其中的每个案例。它也清楚如何从界面中使用它。

这是一个黑客，但它会起作用。

Answer 21

派对有点晚了，但我一直在寻找这个问题的答案，并最终想出了另一种方法。将Web方法的可选args的数据类型声明为XmlNode类型。如果省略了可选的arg，则将其设置为null，如果它存在，则可以通过调用arg.Value获得字符串值，即

[WebMethod]
public string Foo(string arg1, XmlNode optarg2)
{
    string arg2 = "";
    if (optarg2 != null)
    {
        arg2 = optarg2.Value;
    }
    ... etc
}

这种方法的优点还在于，生成的.NET主页仍会显示参数列表（尽管你确实丢失了方便的文本输入框进行测试）。

Answer 22

为什么不从传递的查询字符串构造一个字典类而不是默认参数，这个实现几乎与asp.net表单与查询字符串一起使用的方式相同。

即。 Request.QueryString [“a”]

这将使叶子类与工厂/样板代码分离。

您也可以查看Web Services with ASP.NET。 Web服务是通过C＃类上的属性自动生成的Web API。

Answer 23

你也可以试试这个类型1 public void YourMethod(int a=0, int b = 0) { //some code }

类型2
public void YourMethod(int? a, int? b) { //some code }

如何在C＃中使用可选参数？

23 个答案:

Hello Optional World