[Proposal]: Params Collections (VS 17.10, .NET 9)

[MadsTorgersen]

Params Collections

• Proposed: https://github.com/dotnet/csharplang/blob/main/proposals/params-collections.md
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

In C# 12 language added support for creating instances of collection types beyond just arrays.
See collection expressions.
This proposal extends params support to all such collection types.

This is a placeholder issue for this proposal: https://github.com/dotnet/csharplang/blob/main/proposals/params-collections.md

The proposal subsumes earlier proposals for params spans (#1757) and params IEnumerables (#179).

Design meetings

• https://github.com/dotnet/csharplang/blob/main/meetings/2023/LDM-2023-11-15.md#params-improvements
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-01-29.md#params-collections
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-01-31.md#params-collections-evaluation-orders
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-02-21.md#params-collections
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-06-12.md#params-span-breaks
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-06-17.md#params-span-breaks
• https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-09-11.md#better-conversion-from-collection-expression-and-params-collections

[TonyValenti]

Great proposal.

It would be great if we could include ranges at the call site via ..list notation.

[Daxode]

Something I would love for this proposal to consider too is unmanaged implements. (especially important with game engines like Unity for interop, and e.g. Burst requires it).

Specifically implementing a params into multiple types of a generic should be possible. Here's an example of one way it could work:

// Library code
ref struct SystemState {}
interface ISystem {
  public void Update<multi T>(ref SystemState state, params Span<T> values) where T : IComponent {}
}

// User Code
struct MyGameSystem : ISystem {
  // This part has to be able to be fully unmanaged
  public void Update(ref SystemState state, ComponentA a, ComponentB b, ComponentC c){}
}

// Managed code can call it like:
ComponentA a = default; 
ComponentB b = default; 
ComponentC c = default; 
ISystem mySystem = new MyGameSystem(); 
mySystem.Update(ref state, stackalloc IComponent[]{ a, b, c }); // managed and upon resolve checks length == 3

// Unmanaged code can of course only do
ComponentA a = default; // unmanaged struct
ComponentB b = default; // unmanaged struct
ComponentC c = default; // unmanaged struct
MyGameSystem mySystem = new MyGameSystem(); 
mySystem.Update(ref state, a, b, c );

// note: in Unity most cases will have reflection finding the bursted/native function pointers that actually calls the specified methods from an unmanaged context.

Today we are sadly forced to fake multiple type params. Examples for projects I work on:
Entities.ForEach we generate all possible combinations: https://github.com/needle-mirror/com.unity.entities/blob/master/Unity.Entities/LambdaJobConstruction/UniversalDelegates.gen.cs
SystemAPI.Query<T...> we only support 7 args: https://github.com/needle-mirror/com.unity.entities/blob/master/Unity.Entities/SystemAPI.cs#L32-L153

[HaloFour]

@Daxode

I think that would fall under variadic type parameters: dotnet/roslyn#5058

I don't understand how your example would work. The contract stipulates that you can pass 0..x parameters of any IComponent , but the implementation requires 3 of specific types?

[Artromskiy]

@Daxode
Not sure that this will work
mySystem.Update(ref state, stackalloc IComponent[]{ a, b, c }); // managed and upon resolve checks length == 3
stackalloc of IComponent span containing ComponentA, ComponentB, ComponentC is impossible. Components could have different size - so you wil get cs0208 trying to stackallock interface span. Also to be used as IComponent they will be boxed anyway.
If you are interrested in generics case - C# ECS frameworks mostly use code generation for functions like Update with many parameters (take a look at Arch ECS)

[MovGP0]

It should also be possible to follow a params variable with an CancellationToken:

public Task<int> FooAsync(params int[] values, CancellationToken ct)

[Sander-Brilman]

I like the proposal, makes the language feel more natural and complete in my opinion

[heischo]

params should be usable in the beginning of the parameter list, too. @MovGP0 already mentioned the CancellationToken, but I think it should be more flexible:
public Task<int> FooAsync(params List<int> numbers, int base, string something, CancellationToken ct)
-->
var fooResult = FooAsync(10, 20, 40, 6, "something", ct)
This special example with an Integer following on an Integer-List requires a certain care in use, but should not be a problem for the compiler.

[HaloFour]

I could see supporting that via optional parameters, in that they must be named at the callsite. Otherwise, that sounds like that would make overload resolution infinitely more complicated.

var fooResult = FooAsync(10, 20, 40, base: 6, something: "something", ct: ct);

With collection expressions, it also feels unnecessary since you could wrap the params in brackets:

var fooResult = FooAsync([10, 20, 40], 6, "something", ct);