Suggestion: hidden/implicit tuple to ctor operator.

[Redageddon]

OK, so every class that has a ctor with more than 1 argument should contain a hidden implicit conversion from a tupple matching every ctor. See image for example.

This would allow for many different things (this idea i got from the implicit new from c# 9, i was just thinking i could take it a step further) such as,

or

But wait, you might be saying, what if i want to define my own ctor that takes in a tuple.
Answer: That is why the operator should be hidden.

This would be like if you had a child class override a virtual method. But, you don't actually call override on the operator or anything like that, it just would use the implemented one instead of the default hidden one. What i mean by hidden is that you dont actually see and cant edit it, the only way to change what it is, is to provide an implementation yourself. That is, yet again, the same as how a child class could use a virtual method from a parent class without actually having to override or implement it.

[HaloFour]

C# 9.0 will bring target-typed new expressions which I think make a lot of this proposal unnecessary:

using System;

public class TestClass {
    public TestClass(int x, string y) { }
}

public static class Program {
    public static void Main() {
        TestClass single = new(0, "zero");
        var asd = new TestClass[] {
            new(1, "one"),
            new(2, "two"),
            new(3, "three"),    
            new(4, "four"),
            new(5, "five")
        };
    }
}

Beyond that I think I'd rather have a way to "splat" a tuple into arguments to a constructor or method rather than something specific to implicitly convert from a tuple to a constructor of a type.

[Redageddon]

I stated that because of people like you who would bring up c#9 new, this was a feature suggestion to have you type even less than the new

[CyrusNajmabadi]

I think the point is that this doesn't provide enough value on top of hte value we're already getting here. i.e. something new is being created. It's intentional that we like that 'new' is very explicit here to call that out. The savings then dont' seem substantial enough, and the clarity seems concerning, so i would not have this be done by default.

Note: you could always do something similar with source-generators if you wanted :)

[Redageddon]

I still think that calling new for every single item in an array creation is a waste, and that this covers more than it.

[HaloFour]

I disagree. I think that the new is the most important part of that expression. If you want implicit conversion from a tuple you can add such a conversion operator, or write a source generator to write them for you.

[marksmeltzer]

I still think that calling new for every single item in an array creation is a waste, and that this covers more than it.

In all of the millions of lines of code I've written in my career, code initializing lists and arrays accounts for a tiny, tiny percentage of that.

The few times I would benefit from a succinct way to init arrays/lists/collections is typically in automated tests where I want the tests to use canned data. However, if I really need to init many items, I just load them from a file instead (CSV, JSON, etc.) which has a succinct syntax.