Expanded functions

[TheCelticGuy]

Hello

I was wondering if it would ever be possible to implement keywords for virtual functions that contractually require you to call the base virtual method.

Something like this:

public required virtual void DoSomething() {}

Then for overrides there are two keywords to define the order of the override (pre and post):

public pre override void DoSomething() {}   // this calls base.DoSomething() last for you.
public post override void DoSomething() {} // this calls base.DoSomething() first for you.

This can be expanded further by having the base function determine the priority order:

public pre required virtual void DoSomething() {} // you can only have **post override**
public post required virtual void DoSomething() {}  // you can only have **pre override**

With this you never have to remember having to call the base function.

The normal virtual/override behaviour still exists if you simply don't include the required keyword, so you lose nothing ultimately, it just gives you the ability to be more strict on the usage of the function.

The reason I suggest this is because I make virtual methods with certain logic that all derived classes use so I need to call the base anyway, but if you forget or some one else uses your library and is unaware that they need to call base function then it breaks very easily and isn't always obvious on why the logic not working - I think it would make the code more rigorous.

If we have abstract methods that force functions to be defined in derived classes I don't see why we can't have the feature of enforcement for calling base virtual functions.

[HaloFour]

Sounds like something solvable relatively easily with an analyzer. You could denote which virtual methods should require invocation by an override and where that base call should occur.

[TheCelticGuy]

Possibly but I would rather focus on working on my projects than having to detour and use an analyser.. I'm sure your answer could apply to other aspects of C# features that have been implemented over the years anyway...but then still ended being added.

[HaloFour]

Possibly but I would rather focus on working on my projects than having to detour and use an analyser..

I understand, but it's significantly less time and effort for you to write an analyzer once than it is for any language proposal to be implemented.

I'm sure your answer could apply to other aspects of C# features that have been implemented over the years anyway...

It's pretty much the standard answer that if your request involves a narrowing of legal syntax (such as enforcing specific call patterns) that an analyzer would be the appropriate solution. You'd need to demonstrate that such a feature would be of benefit to a large audience. Given this has been the behavior of virtual functions and overrides since C# 1.0 and this is not a commonly requested feature it would seem that this is not much of a pain point.

[theunrepentantgeek]

Possibly but I would rather focus on working on my projects than having to detour and use an analyser.

I suspect, from the wording of your reply, that you may be thinking of a static analyser that’s run as a separate step.

Source Analysers integrate with the compiler and were designed for exactly this kind of scenario. No separate step required, just run your build.

See for more info - https://docs.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/tutorials/how-to-write-csharp-analyzer-code-fix

[TheCelticGuy]

You'd need to demonstrate that such a feature would be of benefit to a large audience.

Fair point though that is kind've hard to prove, but can't rule out the fact that some times people don't realise they need it until they its given to them !
But I would say it enforces stronger robust code and shows clear intent of what the function should be doing, regardless of audience this does add to making C# a better language over others.

I assumed features for C# would also regardless of audience need's be considered for ways to write more robust code in general.

It's pretty much the standard answer that if your request involves a narrowing of legal syntax

What do you mean by narrowing ? This was not suggested to replace the original behaviour it was an added optional feature to expand upon it. It doesn't remove the original override/virtual behaviour if you choose not to use the required keyword then nothing changes and will not break anything.

[Joe4evr]

What do you mean by narrowing?

In this context it means making something that is currently legal syntax illegal, which is what you're trying to achieve.

[TheCelticGuy]

In this context it means making something that is currently legal syntax illegal, which is what you're trying to achieve.

I don't see what would suddenly become illegal? You can still use the default override and virtual design without the added keywords.

[CyrusNajmabadi]

The idea here is that hte need for new syntax is too niche. Instead, you could just write:

[Pre] public override void DoSomething() { ... }
[Post] public post override void DoSomething() { ... }

You'd hten have an analyzer that ensures the user code called base.DoSomething() first or last depending on the attribute. It would literally be about 5 minutes to whip up, and you could start using that today. In my opinion, this is an ideal area for an analyzer instead of having to rev the language.

[theunrepentantgeek]

@PixelSir, it's currently legal to not call the base virtual method, and the whole point of your proposed feature is to make that illegal.

That's practically a textbook definition of narrowing - and exactly the situation for which the team implemented analyzers, to allow you to force the behavior you want without imposing those views on others.

[Joe4evr]

Aside from writing an analyzer, this is much better served using the Template Method Pattern:

public void DoTheThing() //Note: NOT virtual
{
    //pre-execution checks

    LetsDoIt();

    //post-execution checks
}

protected virtual void LetsDoIt()
{
    //default logic
}