[Proposal]: Allow specifying default values for struct method arguments

[aaronfranke]

Default values for structs in method arguments

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

I would like to provide default arguments for structs in my methods. However, C# does not support this feature, currently only types that can be declared const are supported as default values for method arguments, and structs cannot be const.

Motivation

I would like to write code that looks like this:

public Color Clamp(Color min = new Color(0, 0, 0, 0), Color max = new Color(1, 1, 1, 1))
{
    // stuff
}

However. C# does not support structs as arguments with default values. Currently I can use this as a work-around:

public Color Clamp(Color? min = null, Color? max = null)
{
    Color minimum = min ?? new Color(0, 0, 0, 0);
    Color maximum = max ?? new Color(1, 1, 1, 1);
    // stuff
}

Or this would also work (possibly faster because it doesn't involve nullability...?):

public Color Clamp()
{
    return Clamp(new Color(0, 0, 0, 0), new Color(1, 1, 1, 1));
}

public Color Clamp(Color min)
{
    return Clamp(min, new Color(1, 1, 1, 1));
}

public Color Clamp(Color min, Color max)
{
    // stuff
}

Or a third work-around would be to just always specify the arguments when calling, but this isn't ideal.

Detailed design

The design of this proposal does not have much more detail than already stated. The feature would allow the first code example to compile, and have the same behavior as the two work-arounds (except likely with better performance).

One concern is with the reason that structs can't be declared const in C# which is that a struct constructor is evaluated at runtime and can have potentially complex logic in it. However, in the use cases I'm thinking of, this is not the case, the constructors I'm using are very simple and only serve to populate the fields. Depending on how this is implemented, we would likely need to guarantee that the struct constructor doesn't do anything fancy, or we can provide some other way to populate the fields of the struct (or if you just give me a way to specify the raw bytes that would work too I guess). Or, even better, would it be possible to allow default method arguments that aren't const values, such that when calling Clamp() it would act just like if you included the arguments like Clamp(new Color(0, 0, 0, 0), new Color(1, 1, 1, 1))?

Drawbacks

There aren't any drawbacks that I'm aware of aside from the concern above. People not using this feature wouldn't be affected.

Alternatives

See the work-arounds in the "Motivation" section and the ideas for how to fix the above concern.

Unresolved questions

There is the question of what do about the above concern.

Design meetings

None so far.

[yaakov-h]

There has been discussion previously about blittable defaults, but I don't think that went anywhere.

[YairHalberstadt]

I think the chief issue here is how this would be implemented.

The current status is that default parameters encode the default value in an attribute. Attributes can only store a small set of data. Thus it's not obvious how this would be implemented.

If the CLR expanded the set of things which can be stored in attributes, my guess is that the LDM would very likely expand the set of things that can be used as default arguments.