Como posso chamar o método padrão em vez da implementação concreta

Por que o comportamento dos Métodos de Interface Padrão foi alterado no C # 8? No passado, o código a seguir (quando os métodos de interface padrão foram demo não lançados):

interface IDefaultInterfaceMethod
{
    // By default, this method will be virtual, and the virtual keyword can be here used!
    virtual void DefaultMethod()
    {
        Console.WriteLine("I am a default method in the interface!");
    }

}

interface IOverrideDefaultInterfaceMethod : IDefaultInterfaceMethod
{
    void IDefaultInterfaceMethod.DefaultMethod()
    {
        Console.WriteLine("I am an overridden default method!");
    }
}

class AnyClass : IDefaultInterfaceMethod, IOverrideDefaultInterfaceMethod
{
}

class Program
{
    static void Main()
    {
        IDefaultInterfaceMethod anyClass = new AnyClass();
        anyClass.DefaultMethod();

        IOverrideDefaultInterfaceMethod anyClassOverridden = new AnyClass();
        anyClassOverridden.DefaultMethod();
    }
}

tem a seguinte saída:

Saída do console:

Eu sou um método padrão na interface!
Eu sou um método padrão substituído!

Mas com a última versão do C # 8, o código acima está produzindo a seguinte saída:

Saída do console:

Eu sou um método padrão substituído!
Eu sou um método padrão substituído!

Alguém pode me explicar por que esse comportamento mudou?

Nota:

IDefaultInterfaceMethod anyClass = new AnyClass(); anyClass.DefaultMethod();

((IDefaultInterfaceMethod) anyClass).DefaultMethod(); // STILL the same problem!??

Eu suspeito que uma pergunta melhor seria:

Como posso chamar o método padrão em vez da implementação concreta?

O recurso foi planejado, mas foi cortado do C # 8 em abril de 2019 , porque uma implementação eficiente exigiria suporte do tempo de execução. Isso não pôde ser adicionado antes do lançamento. O recurso teria que funcionar bem para C # e VB.NET - F # não gosta de interfaces de qualquer maneira.

se BM não estiver presente no tempo de execução, AM () será chamado. Para base () e interfaces, isso não é suportado pelo tempo de execução; portanto, a chamada lançará uma exceção. Gostaríamos de adicionar suporte para isso no tempo de execução, mas é muito caro fazer esse lançamento.

Temos algumas soluções alternativas, mas elas não têm o comportamento que queremos e não são o codegen preferido.

Nossa implementação para C # é algo viável, embora não seja exatamente o que gostaríamos, mas a implementação do VB seria muito mais difícil. Além disso, a implementação do VB exigiria que os métodos de implementação da interface fossem uma superfície pública da API.

Ele funcionará através de uma base()chamada semelhante à forma como as aulas funcionam. Copiando o exemplo da proposta:

interface I1
{ 
    void M(int) { }
}

interface I2
{
    void M(short) { }
}

interface I3
{
    override void I1.M(int) { }
}

interface I4 : I3
{
    void M2()
    {
        base(I3).M(0) // What does this do?
    }
}