How to assign TimeSpan with a default value when using it as an argument?

time and space

This does not work:

public void DoStuff(TimeSpan interval = TimeSpan.FromSeconds(5))

The compiler error is: "Error 1 Default parameter value for 'interval' must be a compile-time constant".

I have tried making a const field in the class but still no luck.

13 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
It's not an object, it's just a value.

So, the memory location for TimeSpan.Zero actually contains an 8 byte value - it doesn't contain a reference (i.e. a pointer) to where an instance is stored on the heap which would be the case if TimeSpan were a class rather than a struct.

By always calling TimeSpan.Zero, you're re-using the value stored at its memory location. This value will persist throughout the application's lifetime and will never be garbage collected.
time and space14y ago
Isn't it generally considered bad to be creating objects during a game loop though? I thought it was best practice to reuse a pool of objects that had been created before hand?
Vulpes14y ago
There would be no point.

You'd just be copying the values to another location and it would be no shorter to write.
time and space14y ago
I use TimeSpan.Zero and Vector2.Zero quite a lot in my main game loop. I'm just wondering if I should create instances of them as static globals in my globals class and refer to them that way.
Vulpes14y ago
TimeSpan is actually a struct (i.e. a value type) rather than a class.

I think that it uses a long integer (8 bytes) to represent TimeSpan values internally, so TimeSpan.Zero will be repesented by a long with a value of 0.

TimeSpan.Zero is a static readonly field which creates a single TimeSpan instance. The same instance is used each time the field is accessed.

Vector2 is also a struct though for some reason Vector2.Zero is a static readonly property rather than a field.
time and space14y ago
Sorry to bump this old topic, but I just wanted to check something. With regards to TimeSpan.Zero, does that create a new instance of a TimeSpan object? I guess this question applies to all objects with Zero properties (e.g. Vector2.Zero).
time and space15y ago
Thanks for all the suggestions. Plenty of solutions for me to use.
Vulpes15y ago
Incidentally, whilst it's not appropriate here, if you wanted a TimeSpan parameter with a default value of 0 seconds, you could simply do this:

public static void DoStuff(TimeSpan interval = default(TimeSpan))
{
// code
}

This works because default(TimeSpan) sets all bits to zero and so is equivalent to TimeSpan.Zero. However, the former is regarded as a constant but the latter is not.
Vulpes15y ago
Although it's not possible to produce a TimeSpan value which is a compile-time constant, you can get around this by using a nullable TimeSpan instead which can take the constant value 'null':

public void DoStuff(TimeSpan? interval = null)
{
if (interval == null) interval = TimeSpan.FromSeconds(5);
TimeSpan ts = (TimeSpan)interval; // convert to non-nullable TimeSpan
// rest of code
}

So this call will set 'interval' (and hence 'ts') to 5 seconds:

DoStuff();

A similar technique can be used for other structs which lack constant values such as DateTime.
Guest User15y ago
You could pass the interval to DoStuff(), and then DoStuff could create the TimeSpan instance internally.
Zoran Horvat15y ago
That's what I said :) Damn and blast concurrent edit.
Benjamin Kemner15y ago
Hm, that's tricky but I think the only way is to use the constructor argument for default value like this:

public void DoStuff(int initvalue=5){
TimeSpan interval = TimeSpan.FromSeconds(initvalue);
}

Or the "old-school" way:

public void DoStuff(){
DoStuff(TimeSpan.FromSeconds(5));
}

public void DoStuff(TimeSpan interval){
}
Zoran Horvat15y ago
First solution:
Do not use TimeSpan as argument but integer which receives seconds, then declare the method like this:
public void DoStuff(int seconds=5)
{
        TimeSpan interval = TimeSpan.FromSeconds(seconds);
        ...
}

Second solution:
Do it old style C# - define two methods, one receiving interval, another without arguments:
public void DoStuff(TimeSpan interval)
{
        ...
}

public void DoStuff()
{
        DoStuff(TmeSpan.FromSeconds(5));
}

Zoran