Allow discards as default in out argument.

[ChanyaKushima]

I want to use discards like following.
Example:

class NowTime
{
    public void Deconstruct(
        out int hour, out int minute = _, 
        out int second = _, out int millisecond = _)
    {
        DateTime now = DateTime.Now;
        hour = now.Hour;
        minute = now.Minute;
        second = now.Second;
        millisecond = now.Millisecond;
    }
}

The above code behaves the same as below.

class NowTime
{
    public void Deconstruct(
        out int hour, out int minute, 
        out int second, out int millisecond)
    {
        DateTime now = DateTime.Now;
        hour = now.Hour;
        minute = now.Minute;
        second = now.Second;
        millisecond = now.Millisecond;
    }
    public void Deconstruct(out int hour, out int minute, out int second)
    {
        Deconstruct(out hour, out minute, out second, out _);
    }
    public void Deconstruct(out int hour, out int minute)
    {
        Deconstruct(out hour, out minute, out _, out _);
    }
    public void Deconstruct(out int hour)
    {
        Deconstruct(out hour, out _, out _, out _);
    }
}

This syntax can use normal method.
Example:

class Foo
{
      public void _Foo(out int foo = _) => foo = 100;
}

This code is ...

class Foo
{
      public void _Foo(out int foo) => foo = 100;
      public void _Foo() => Foo(out _);
}

This syntax is discards used optional arguments. So the following code throws compilation error.

class Foo
{
      public void _Foo(out int foo = _) => foo = 100;
      public void _Foo(out string foo = _) => foo = "Foo";      // Compilation Error
}

[HaloFour]

Are you suggesting that optional parameters should generate overloads for the permutations of the different values that may be passed? Optional parameters don't do that today. This also implies that you'd always want to pass the parameters in a specific order and not optionally discard a parameter in the middle, which is also not the behavior of optional parameters today. For example, how could you do this?

var nowTime = new NowTime();
nowTime.Deconstruct(out var hour, second: out var second);

Whether or not the value is discarded is a matter for the consumer of the method, not the method itself. These methods still need to assign a valid value to that argument.

[ChanyaKushima]

@HaloFour
In the following cases:

public class Sample {
    public void M1(int a=10,int b=20,int c=30,int d=40) {
    }
}

In the class, M1(1, c:2) is M1(1, 20, 2).
(https://sharplab.io/#v2:EYLgtghgzgLgpgJwDQBMQGoA+ABAzAAmwCZ8BlCMABwBs58BvAWACh83CDsAWfAWQEYAFAEsAdjHwQAvPwAMSMROBSi8xfgDGU3GvH4UUrrICUDFu3wBfc+xts8hHryKDjTVhfYDB/JBpBExgDcdlYslkA==)
In other words that is M1(1,20,2,40).
Then your code should be like ...

var nowTime = new NowTime();
nowTime.Deconstruct(out var hour, out _, out var second, out _);

[HaloFour]

@ChanyaKushima

Yes, because the optional arguments are resolved by the compiler and inserted into the method call. There are no overloads.

I get that the desire here is to enable positional deconstruction using a smaller number of elements without having to write out all of the Deconstruct methods. My opinion is that it would be a fairly niche desire to want to overload deconstruction in such a manner. Positional deconstruction should really only apply to a handful of elements otherwise it gets too cumbersome, and writing 2-3 extra Deconstruct methods once is a minor burden, one that I think the vast majority of developers will never need or want to do. If you have so many of these classes each with so many elements I think that recursive property patterns are a better fit, especially since they enable you to specify as few or as many elements at the call site as you want.

[agocke]

I agree with @HaloFour, this doesn't seem like a straightforward use for deconstruction. @ChanyaKushima Have you seen the new property pattern in C# 8?

What you would write is something like

class NowTime
{
    public int Hour => ...
    public int Minute => ...
    public int Second => ...
    public int Millisecond => ...
}

object o;
if (o is NowTime { Hour: var hour, Second: var second })
{
...
}

[john-h-k]

I like this, prevent me having to write additional overloads for out values