How to call/use the interface default implementation?

[TheBlueSky]

Let's assume that I have the following:

internal interface IService
{
    void DoSomething(string text);

    void DoSomethingDefault(string text) => Console.WriteLine($"Default: {text}");
}

internal sealed class MyService : IService
{
    public void DoSomething(string text)
    {
        Console.WriteLine(text);

        // Calling the method as is
        // DoSomethingDefault(text);

        // Casting to the interface
        (this as IService).DoSomethingDefault(text);
    }

    // Or using the default implementation
    // public void DoSomethingDefault(string text) => ???
}

Also, let's assume that I like the default implementation of DoSomethingDefault() and I want to use it as is. Is there away to call the method from the interface or use the default implementation without casting? If not, is this kind of casting expensive?

[colejohnson66]

Casts are required to call default interface methods (DIMs), as per the specification. To call DIMs, one must be interacting with an interface object, not directly with a class/struct.

Also, casts are free when you're going "up" the inheritance tree (and not boxing); They only "cost" something if you're going "down" the tree (such as from an IService to MyService) as type checking must be performed. In addition, "constrained calls" like you're doing will not box if the original object is a value-type (struct); The JIT will optimize out the boxing in such situations.

https://andrewlock.net/understanding-default-interface-methods/

If you're asking to "forward" the default implementation to remove the constrained call requirement, you can do so by overriding the interface method in the derived type, but just have it forward to the default:

public class MyService : IService
{
    public void DoSomething(string text)
    { ... }

    public void DoSomethingDefault(string text) =>
        (this as IService).DoSomethingDefault(text);
}

[TheBlueSky]

Thanks, @colejohnson66, for the helpful answer. I did not know about the specification part. I ended up implementing the casting, as in my example.

If you're asking to "forward" the default implementation to remove the constrained call requirement, you can do so by overriding the interface method in the derived type, but just have it forward to the default:

I tried this before asking the question here. Unfortunately, it did not work. It is treated as a recursive method, and I ended up with stack overflow. Here is the code in .NET Fiddle.

[colejohnson66]

Ah, yes. I see I was wrong about forwarding DIMs. Looking at the IL, the compiler is indeed calling IService.DoSomethingDefault, but the runtime is resolving it to the class method, not the (virtual) interface one.

    .method public final hidebysig newslot virtual 
        instance void DoSomethingDefault (
            string text
        ) cil managed 
    {
        .custom instance void [System.Runtime]System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
            01 00 01 00 00
        )
        // Method begins at RVA 0x2096
        // Code size 9 (0x9)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldarg.1
        IL_0002: callvirt instance void IService::DoSomethingDefault(string)
        IL_0007: nop
        IL_0008: ret
    } // end of method MyService::DoSomethingDefault