Come posso chiamare il metodo predefinito invece dell'implementazione concreta

Perché il comportamento dei metodi di interfaccia predefiniti è cambiato in C # 8? In passato il seguente codice (quando non sono stati rilasciati i metodi dell'interfaccia predefinita):

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();
    }
}

ha il seguente output:

Uscita console:

Sono un metodo predefinito nell'interfaccia!
Sono un metodo predefinito ignorato!

Ma con l'ultima versione di C # 8 il codice sopra sta producendo il seguente output:

Uscita console:

Sono un metodo predefinito ignorato!
Sono un metodo predefinito ignorato!

Qualcuno può spiegarmi perché questo comportamento è cambiato?

Nota:

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

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

Ho il sospetto che una domanda migliore sarebbe:

Come posso chiamare il metodo predefinito invece dell'implementazione concreta?

La funzionalità è stata pianificata ma è stata tagliata da C # 8 nell'aprile 2019 , poiché un'implementazione efficiente richiederebbe il supporto del runtime. Questo non può essere aggiunto in tempo prima del rilascio. La funzione dovrebbe funzionare bene sia per C # che per VB.NET - Ad F # non piacciono comunque le interfacce.

se BM non è presente in fase di esecuzione, verrà chiamato AM (). Per base () e interfacce, questo non è supportato dal runtime, quindi la chiamata genererà un'eccezione. Vorremmo aggiungere il supporto per questo in fase di esecuzione, ma è troppo costoso realizzare questa versione.

Abbiamo alcune soluzioni alternative, ma non hanno il comportamento che vogliamo e non sono il codegen preferito.

La nostra implementazione per C # è in qualche modo praticabile, sebbene non esattamente quello che vorremmo, ma l'implementazione di VB sarebbe molto più difficile. Inoltre, l'implementazione per VB richiederebbe che i metodi di implementazione dell'interfaccia siano di superficie API pubblica.

Funzionerà attraverso una base()chiamata simile a come funzionano le classi. Cooping dell'esempio di 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?
    }
}