Minimum number of parameters for params

[TahirAhmadov]

Can we introduce an attribute or a keyword which stipulates that params receives a minimum number of items?

void Foo([MinimumCount(1)] params string[] list) { ... }

Foo(); // compilation error

string[] arr = Array.Empty<string>();
Foo(arr); // compiles, but runtime exception: ArgumentInsufficientCountException

Foo("abc"); // compiles and runs
Foo("abc", "def"); // compiles and runs

Motivation: this is useful for methods like MakeGenericType and all the other similar methods, as well as custom code which utilizes these reflection methods; it's impossible to make a generic type/method without at least one type argument.

Workaround:

void Foo(string a, params string[] extra)
{
  var list = new string[extra.Count+1];
  list[0]=a;
  Array.Copy(extra, list, 1);
}

You can see how the workaround has an ugly signature and overhead of allocating another array internally (assuming it's usually needed to have the complete list).

[jnm2]

This can be implemented as an analyzer package that defines the attribute and enforces the usage.

[jnm2]

I don't see Type[] being better than object[] as anything other than a practical issue, backed by quite some evidence. I'd have a hard time defining what "logical" would mean in the absence of the practical. Does it mean some particular person's intuition? Then you'd better hope everybody already has that intuition.

(If someone showed me evidence that writing more kinds of unit tests was more productive than strong typing, and I could reproduce this effect for myself, I'd switch eagerly.)

[TahirAhmadov]

I don't see Type[] being better than object[] as anything other than a practical issue, backed by quite some evidence. I'd have a hard time defining what "logical" would mean in the absence of the practical. Does it mean some particular person's intuition? Then you'd better hope everybody already has that intuition.

(If someone showed me evidence that writing more kinds of unit tests was more productive than strong typing, and I could reproduce this effect for myself, I'd switch eagerly.)

Ultimately, it boils down to what works best, but some "theorems" are proven once and can be relied on going forward. We don't need to re-evaluate strong typing over and over - it's a waste of time - we know strong typing is better. There is a "mathematical" truth to it, IMO. It's like saying, 2+2=4 is a statement we have to evaluate for its practicality. Yes we could do that, but then we'll spend all of our time questioning everything - not a very practical thing, you know.

[jnm2]

I disagree that the value of MinimumCountAttribute can be automatically equated with the value of existing strong typing, though, certainly not with the clarity of a mathematical expression. The tradeoffs involved in reading and writing this particular syntax are unique to this question (even if it's a new keyword). It wouldn't be a re-evaluation.

[TahirAhmadov]

I disagree that the value of MinimumCountAttribute can be automatically equated with the value of existing strong typing, though, certainly not with the clarity of a mathematical expression. The tradeoffs involved in reading and writing this particular syntax are unique to this question (even if it's a new keyword). It wouldn't be a re-evaluation.

Oh yes, I never said it was equivalent. But it is similar in the sense that the min # (in the MakeGenericType case) is part of the signature, and so are strong types.

[Joe4evr]

How many BCL methods use params and have a requirement to pass a minimum number of arguments? I can't recall encountering one and I would argue that such is a terrible design choice.

The API committee reviewed such APIs for the BCL last month, and they decided to do the exact thing that OP lists as a "workaround". I'd regard that as a good argument to consider that to be the canonical solution to this problem.

[CyrusNajmabadi]

These are well known symbols. I feel like we don't even need an attribute. One could just write a basic analyzer here. That said, I'm skeptical of the value. How often does one call this method and pass no Params? Fellas like it would be caught immediately.

[TahirAhmadov]

That's what the thread arrived at, too - a Nuget package with the attribute type and an analyzer.

[Richiban]

I have also needed this in the past (enough times to make it worth mentioning), at least a way of saying "You can pass in as many arguments as you like, but you must pass at least one". I have also implemented the workaround of having a regular parameter for the first element and a params array for the rest and but this is very unsatisfactory for two reasons:

1. If the caller already has an array they now can't pass it straight to your method any more; they must split the array into head and tail and pass them separately which is wasteful
2. In the method implementation, if what you needed was actually to store an array of items, you've now got to recreate it yourself from the head and tail which is, again, wasteful

I'm not really sure what the correct answer is here, so maybe an analyzer really is the best approach since it's the least invasive to implement. Having said that, I could go on a slightly separate rant about how I so often wish there were types to represent "non-empty" collections in the BCL.