Private optional parameters

[zms9110750]

Can add modifiers to optional parameters (just like the accessor in a property, only allowing lower access permissions than the property).
Currently, overloading methods often involves a combination of parameter arrangements. They are either logically similar or simply working parameters and then calling another overload.
I am currently facing a problem where I need to recurse a method. The call of this method cannot allow external modifications to the parameters I use for iteration.
So, I created a new method that doesn't have parameters for iteration. But I think this method is more than enough. It would be great if they could merge together.

class Program
{
    readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
    async Task Entry(bool limitation = true)
    {
        if (limitation)
        {
            try
            {
                await semaphore.WaitAsync();
                await Task.Delay(1000);
            }
            finally
            {
                semaphore.Release();
            }
        }
        else
        {
            await Task.Delay(1000);
        }
    } 
    public async Task Entry()
    {
        await Entry(true);
    }
}

class Program
{
    readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
    async Task Entry(private bool limitation = true)//If the caller does not have access permissions, this parameter cannot be filled in.
    {
        if (limitation)
        {
            try
            {
                await semaphore.WaitAsync();
                await Task.Delay(1000);
            }
            finally
            {
                semaphore.Release();
            }
        }
        else
        {
            await Task.Delay(1000);
        }
    }  
}

[HaloFour]

Sounds like something better accomplished through overloads. Optional parameters don't affect the signature of the method and it doesn't make sense to have an "optional" parameter that cannot be provided by a caller.

[CyrusNajmabadi]

i agree. we've never had a concept of "there are two views of this exact symbol, based on if you're internal or external". At that point, have two members.

[zms9110750]

The declaration class can be filled in. Just like public int Arg {get; private set;}

[HaloFour]

Each accessor of a property is its own member and is permitted to have its own accessibility (although that wasn't added in C# 2.0). In this case, you'd only have one method, which can only have one signature.

[zms9110750]

What if multiple members are really declared? When using this grammar, treat it as a grammar sugar.Leave complex tasks to the compiler.

[HaloFour]

Optional parameters don't create overloads. That's quite intentional as you would easily end up with combinatorial explosion and signature collisions in any non-trivial scenario.