Default Interface Methods should be callable from implementing types

[MgSam]

Currently, Default Interface Methods cannot be called directly from an implementing type.

interface I { string Foo() => "foo"; }
class C : I 
{ 
    public string Foo() { 
        get { 
            //Do some extra business logic here
            //Now delegate to I's implementation of Foo
            return ((I)this).Foo(); //Whoops - this doesn't work. It'll cause a stack overflow
        }
    }
}

This seriously limits the usefulness of DIMs. It means that what you put inside them always has to itself delegate to another method or else you have siloed logic in a method that cannot be useful to any of its implementers.

As a motivating example in my own usage, I have a framework where we have abstract base classes that do very little and would be better served replacing them with interfaces (so users are not forced into our inheritance hierarchy). But the small amount of logic they do have would be lost if its put in DIMs as implementers have no way to call it.

You can sort-of workaround this situation today using statics. But doing so is extremely clunky and repetitive. It's also such a strange looking pattern that I am hesitant to use it as future maintainers of the code may not understand the reason for it and remove it.

interface I { string Foo() => I.Foo(); static void Foo() => "foo"; }
class C : I { public string Foo() => I.Foo(); }

I propose to implement the syntax that was in the draft solution for C#:

interface I { string Foo() => I.Foo(); }
class C : I { public string Foo() => base(I).Foo(); }

[FaustVX]

In your 1st example, C.Foo property shouldn't have parenthesis.
But if you correct it, it works well

interface I { string Foo() => "foo"; }
class C : I 
{ 
    public string Foo { 
        get { 
            //Do some extra business logic here
            //Now delegate to I's implementation of Foo
            return ((I)this).Foo(); // It works well
        }
    }
}

sharplab.io

[MgSam]

If C.Foo doesn't have parenthesis it's no longer implementing the interface. It's now declaring a property of the same name.

[FaustVX]

But it shouldn't be a property but a method
Properties can't have argument-list (except indexer but it's with square brackets C.Foo[])

[HaloFour]

Wasn't this supposed to be a part of a phase 2 for DIM that included a syntax like base.Foo() or base(I).Foo()?

[CyrusNajmabadi]

Yup. We put that on pause a bit because we thought the runtime side might be very complex. But, from recent discussions, it sounds like this might have just fallen out from work in the last few years, or may just be much less complex now. So we can def look back at this, esp. if there's enough community feedback of wanting things like this.

[MgSam]

I was talking with the C# team at Build and though the original proposal had these features they weren't implemented because of runtime complexity. There also hasn't been progress since then because of the runtime complexity. However, @tannergooding indicated that some of the runtime issues may have been solved in the last release so implementing this now isn't as big a lift as it was in 2019.

[MgSam]

@CyrusNajmabadi beat me to it! 😆

[MadsTorgersen]

Thanks @MgSam for bringing this to the forefront and confirming that it is still important! Your scenario is certainly compelling to me.

It turns out that there is an issue for this on the backlog: #2337. I've added myself as a champion, and will put it on the LDM agenda to triage - i.e., see what the interest level is. If they agree it's time to look at it again, let's take a look at implementation complexity; it sounds like there may have been some beneficial changes since this was first proposed.

[huoshan12345]

This is also a feature that I was really looking forward to. I implemented it myself about 1 year ago cause I had to use it asap.

• Implementation with pure C#: https://gist.github.com/huoshan12345/c42de446a23aa9a17fb6abf905479f25
• Implementation with fody: https://github.com/huoshan12345/InterfaceBaseInvoke.Fody

I hope these will be useful until the C# team implements the feature,

[TonyValenti]

+1 for this feature.

[westy]

Agree that this is badly needed, since could be a massive source of bugs in years to come when interfaces are used without detailed knowledge of their implementation!

I'll go and follow the issue in the backlog too.