[Suggestion] Explicit Required Named Arguments

[masters3d]

I'd like to require certain arguments to be called with a name argument label.

Currently I can sort of fake this requirement by providing a dummy optional parameter as the first parameter when all the arguments are optional.

        // I want to force the caller to use a named paramerter label so please excuse the __paramLabelRequired__
        public void UpdateScreen(int __paramLabelsRequired__ = 0, bool showingTitle = true)
        {...}

This is how I must call this now.

view.UpdateScreen(showingTitle: false);

The below will not work because of the dummy first optional argument and this is intentional.

view.UpdateScreen(false);

This would work though:

view.UpdateScreen();

It would be awesome if I could require a name argument like this:

        public void UpdateScreen( bool @required showingTitle)
        {...}

or something like this.

        public void UpdateScreen( bool showingTitle showingTitle)
        {...}

alternatively if could be added to the method.

        @requiredNameArguments
        public void UpdateScreen( bool showingTitle)
        {...}

Currently I am not able to require it in non optional arguments which is where I would want this to work.

The advantage is that the named argument would be required at the call site thus giving more meaningful information to the caller on what the parameters do at a glance.

This could work after this is implemented: #518

[svick]

This sounds like it could easily be accomplished by an analyzer. The parameter or the method would have an attribute, e.g.:

public void UpdateScreen([RequireNamedArguments] bool showingTitle)

// or

[RequireNamedArguments]
public void UpdateScreen(bool showingTitle)

The analyzer would then find all calls of methods with the attribute and produce a diagnostic if the call didn't use named arguments.

[smoothdeveloper]

Just to point that there is similar suggestion and prototype for F#:

fsharp/fslang-suggestions#414

Such solution should be understood by the different compilers targetting the CLR.

Thanks to @charlesroddie for pointing it out.

[CyrusNajmabadi]

We would not do this for C#. Whether or not you use named parameters is decision the user makes. If you want such a restriction for your own code, you can always write an analyzer that requires this for you.

[smoothdeveloper]

Thanks @CyrusNajmabadi, for context, in F#, there is the precedent of two other "Require" attributes that enforce similar stuff at call sites, and this being part of the F# language and the design of API consumed in it.

If in the context of C# it doesn't make sense to honour it, I agree an analyser would be suitable to pick up the attribute.

Does it still make some sense that there is possible interest to investigate in having the attribute be part of BCL?

One thing with analyser is that you'd need one per particular implementation of the attribute, or somehow, make one that would pickup on some convention rather than a canonical attribute in the BCL. (similar with not null and tooling like jetbrains, which is akin to analyser, and basically paved the way for nullable reference types to land in C# as prior art)

It doesn't really consolidate some idioms that may be important in some API designs but leave it to everyone to do their own dialect, recommending their own flavour of analyser/attribute.

[CyrusNajmabadi]

Does it still make some sense that there is possible interest to investigate in having the attribute be part of BCL?

Sure. But that would then go to a discussion on dotnet/runtime if there is any interest on their side in producing such an api and owning such an analyzer. Thanks! :)

[smoothdeveloper]

Thanks, dotnet/runtime#51451 (I wish the links would show the same way they happen in PR and issues)