C# 4.0：我可以使用 TimeSpan 作为具有默认值的可选参数吗？

Question

这两个都会生成一个错误，指出它们必须是编译时常量：

void Foo(TimeSpan span = TimeSpan.FromSeconds(2.0))
void Foo(TimeSpan span = new TimeSpan(2000))

首先，有人可以解释为什么这些值不能在编译时确定吗？有没有办法为可选的 TimeSpan 对象指定默认值？

Answer 1

您可以通过更改签名来轻松解决此问题。

void Foo(TimeSpan? span = null) {

   if (span == null) { span = TimeSpan.FromSeconds(2); }

   ...

}

我应该详细说明 - 您的示例中的这些表达式不是编译时常量的原因是因为在编译时，编译器不能简单地执行 TimeSpan.FromSeconds(2.0) 并将结果的字节粘贴到编译后的代码中。

例如，考虑一下您是否尝试改用 DateTime.Now。 DateTime.Now 的值每次执行时都会发生变化。或者假设 TimeSpan.FromSeconds 考虑了重力。这是一个荒谬的例子，但编译时常量的规则不会仅仅因为我们碰巧知道 TimeSpan.FromSeconds 是确定性的而产生特殊情况。

Answer 2

我的 VB6 传统让我对将“空值”和“缺失值”视为等价的想法感到不安。在大多数情况下，这可能没问题，但可能会产生意想不到的副作用，或者可能会陷入异常情况（例如，如果 span 的源是一个不应该为 null 的属性或变量，但是是）。

因此我会重载该方法：

void Foo()
{
    Foo(TimeSpan.FromSeconds(2.0));
}
void Foo(TimeSpan span)
{
    //...
}

Answer 3

这工作正常：

void Foo(TimeSpan span = default(TimeSpan))

注意：default(TimeSpan) == TimeSpan.Zero

Answer 4

可用作默认值的值集与可用于属性参数的值集相同。原因是默认值被编码到 DefaultParameterValueAttribute 内部的元数据中。

至于为什么不能在编译时确定。编译时允许的值集和此类值的表达式在官方 C# 语言规范：

C# 6.0 - 属性参数类型：

属性类的位置参数和命名参数的类型仅限于属性参数类型，它们是：

• 以下类型之一：bool、byte、char、double、float< /code>、int、long、sbyte、short、字符串、<代码>uint、ulong、ushort。
• 类型对象。
• 类型System.Type。
• 枚举类型。
  ^{（前提是它具有公共可访问性，并且它嵌套的类型（如果有）也具有公共可访问性）}
• 上述类型的一维数组。

TimeSpan 类型不适合任何这些列表，因此不能用作常量。

Answer 5

void Foo(TimeSpan span = default(TimeSpan))
{
    if (span == default(TimeSpan)) 
        span = TimeSpan.FromSeconds(2); 
}

提供的 default(TimeSpan) 不是该函数的有效值。

或者

//this works only for value types which TimeSpan is
void Foo(TimeSpan span = new TimeSpan())
{
    if (span == new TimeSpan()) 
        span = TimeSpan.FromSeconds(2); 
}

提供的 new TimeSpan() 不是有效值。

或者

void Foo(TimeSpan? span = null)
{
    if (span == null) 
        span = TimeSpan.FromSeconds(2); 
}

考虑到 null 值作为函数有效值的机会很少，这应该更好。

Answer 6

TimeSpan 是 DefaultValueAttribute 的特殊情况，并使用可通过 TimeSpan.Parse 方法解析的任何字符串指定。

[DefaultValue("0:10:0")]
public TimeSpan Duration { get; set; }

Answer 7

我的建议：

void A( long spanInMs = 2000 )
{
    var ts = TimeSpan.FromMilliseconds(spanInMs);

    //...
}

顺便说一句
TimeSpan.FromSeconds(2.0) 不等于 new TimeSpan(2000) - 构造函数需要刻度。

Answer 8

其他答案对于为什么可选参数不能是动态表达式给出了很好的解释。但是，回顾一下，默认参数的行为类似于编译时常量。这意味着编译器必须能够评估它们并给出答案。有些人希望 C# 添加对编译器在遇到常量声明时评估动态表达式的支持 - 这种功能与将方法标记为“纯”有关，但这现在还不是现实，也可能永远不会成为现实。

对于此类方法使用 C# 默认参数的一种替代方法是使用 XmlReaderSettings。在此模式中，定义一个具有无参数构造函数和公共可写属性的类。然后用该类型的对象替换方法中所有默认选项。甚至可以通过指定默认值 null 来使该对象可选。例如：

public class FooSettings
{
    public TimeSpan Span { get; set; } = TimeSpan.FromSeconds(2);

    // I imagine that if you had a heavyweight default
    // thing you’d want to avoid instantiating it right away
    // because the caller might override that parameter. So, be
    // lazy! (Or just directly store a factory lambda with Func<IThing>).
    Lazy<IThing> thing = new Lazy<IThing>(() => new FatThing());
    public IThing Thing
    {
        get { return thing.Value; }
        set { thing = new Lazy<IThing>(() => value); }
    }

    // Another cool thing about this pattern is that you can
    // add additional optional parameters in the future without
    // even breaking ABI.
    //bool FutureThing { get; set; } = true;

    // You can even run very complicated code to populate properties
    // if you cannot use a property initialization expression.
    //public FooSettings() { }
}

public class Bar
{
    public void Foo(FooSettings settings = null)
    {
        // Allow the caller to use *all* the defaults easily.
        settings = settings ?? new FooSettings();

        Console.WriteLine(settings.Span);
    }
}

要调用，请使用一种奇怪的语法在一个表达式中实例化和分配属性：

bar.Foo(); // 00:00:02
bar.Foo(new FooSettings { Span = TimeSpan.FromDays(1), }); // 1.00:00:00
bar.Foo(new FooSettings { Thing = new MyCustomThing(), }); // 00:00:02

缺点

这是解决此问题的一种非常重量级的方法。如果您正在编写一个快速而肮脏的内部接口，并且使TimeSpan可以为空并将null视为您想要的默认值 可以正常工作，请改为这样做。

此外，如果您有大量参数或在紧密循环中调用该方法，这将产生类实例化的开销。当然，如果在紧密循环中调用这样的方法，那么重用 FooSettings 对象的实例可能是自然的，甚至非常容易。

好处

正如我在示例的评论中提到的，我认为这种模式非常适合公共 API。向类添加新属性是一项不间断的 ABI 更改，因此您可以添加新的可选参数，而无需使用此模式更改方法的签名 - 为最近编译的代码提供更多选项，同时继续支持旧的编译代码，无需额外工作。

此外，由于 C# 的内置默认方法参数被视为编译时常量并烘焙到调用站点中，因此默认参数只有在重新编译后才会被代码使用。通过实例化设置对象，调用者在调用您的方法时动态加载默认值。这意味着您只需更改设置类即可更新默认值。因此，此模式允许您更改默认值，而无需重新编译调用者即可查看新值（如果需要）。

Answer 9

我意识到这已经很老了，很久以前就回答了，但我发现自己在读它并且......

这似乎是“假装”这是超载的最好方法。

void Foo(TimeSpan span = new TimeSpan(2000))

如果是“想要”，您可以提供 2 个重载：

void Foo(int ticks = 2000) => Foo(new TimeSpan(ticks));
void Foo(TimeSpan span) => [implementation]

这允许干净地调用 Foo() 来执行您想要的操作。 int 重载通常看起来也不错。如果愿意，您可以将 int 重载更改为以秒为单位/任何单位。

如果您已经有复杂的参数列表，这可能不可行，但在许多情况下，这似乎是 C# 中的“最佳”方式。

Answer 10

要指定结构类型参数的默认值，我建议使用重载：

void Foo() 
{
    Foo(TimeSpan.FromSeconds(2.0));
}

void Foo(TimeSpan time)
{
    // ...
}