Allow a tuple of const types to be a const

[seanblue]

In short, I'd like to be able to take types that can individually be const and wrap them up in a tuple, then treat that tuple as a const as well. For example, in addition to

const int a = 5;
const string b = "foo";

The following would be allowed

const (int, string) c = (5, "foo");

The above example is obviously contrived and fairly useless, so that's just to make clear what I mean. My main use case would be in unit testing. Let's say I have a test with some combinatorial testing via the NUnit Values attribute.

[Test]
public void Test([Values] SomeEnum param1, [Values] bool param2) { ... }

There are times when I want to add another test parameter, but it's actually two values coupled together, e.g. an input of some decimal and then the rounded value as the test expectation. If these were the only parameters I would do

[TestCase(5.99, 5)]
[TestCase(6.01, 6)]
public void Test(decimal inputValue, decimal expectedRoundedValue) { ... }

But if I want to do this along with the previous combinatorial cases, it quickly blows up in size using TestCase. It also results in a lot of data duplication, not to mention the loss of automatically testing enum values added later which Values gives for free.

[TestCase(SomeEnum.A, false, 5.99, 5)]
[TestCase(SomeEnum.A, false, 6.01, 6)]
[TestCase(SomeEnum.A, true, 5.99, 5)]
[TestCase(SomeEnum.A, true, 6.01, 6)]
[TestCase(SomeEnum.B, false, 5.99, 5)]
[TestCase(SomeEnum.B, false, 6.01, 6)]
[TestCase(SomeEnum.B, true, 5.99, 5)]
[TestCase(SomeEnum.B, true, 6.01, 6)]
[TestCase(SomeEnum.C, false, 5.99, 5)]
[TestCase(SomeEnum.C, false, 6.01, 6)]
[TestCase(SomeEnum.C, true, 5.99, 5)]
[TestCase(SomeEnum.C, true, 6.01, 6)]
public void Test(SomeEnum param1, bool param2, decimal inputValue, decimal expectedRoundedValue) { ... }

Of course, another way to do this currently would be using TestCaseSource, but this can also be combersome.

[TestCaseSource(nameof(SourceMethod)]
public void Test(SomeEnum param1, bool param2, decimal inputValue, decimal expectedRoundedValue) { ... }

// Some pseudo-code in here
public IEnumerable<(SomeEnum, bool, decimal, decimal)> SourceMethod()
{
    foreach (var param1 in Enum.GetValues<SomeEnum>())
        foreach (var param2 in [true, false])
            foreach (var valPair in [(5.99, 5), (6.01, 6)])
                yield return (param1, param2, valPair.Item1, valPair.Item2);
}

Instead, I'd like to be able to use const tuples to do the following

[Test]
public void Test([Values] SomeEnum param1, [Values] bool param2, [Values((5.99, 5), (6.01, 6))] (decimal inputValue, decimal expectedRoundedValue) param3) { ... }

(It would be more convenient if the tuple could immediately be deconstructed into multiple named params like JavaScript allows, but even without this the main goal would be achieved.)

This is currently not possible since tuples cannot be treated as constants. I'm honestly not sure of any use cases outside of unit testing, but if anyone has another use case please mention. Besides that, does anyone know how feasible/complex this would be to implement into C#?

[HaloFour]

See: #1979

[seanblue]

I swear I looked around before posting this 🙈

@HaloFour Would my proposal of allowing tuples to be consts effectively be one possible implementation of that previous issue "Allow tuples as attribute parameters"? I did expect changes outside of C# language to be needed (as you mentioned in that other issue), but do you have any thoughts on the complexity?