Comment puis-je appeler la méthode par défaut au lieu de l'implémentation concrète

Pourquoi le comportement des méthodes d'interface par défaut est-il modifié en C # 8? Dans le passé, le code suivant (lorsque la démonstration des méthodes d'interface par défaut n'était pas publiée):

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

a la sortie suivante:

Sortie console:

Je suis une méthode par défaut dans l'interface!
Je suis une méthode par défaut remplacée!

Mais avec la dernière version C # 8, le code ci-dessus produit la sortie suivante:

Sortie console:

Je suis une méthode par défaut remplacée!
Je suis une méthode par défaut remplacée!

N'importe qui peut m'expliquer pourquoi ce comportement a changé?

Remarque:

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

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

Je soupçonne qu'une meilleure question serait:

Comment puis-je appeler la méthode par défaut au lieu de l'implémentation concrète?

La fonctionnalité a été planifiée mais a été coupée de C # 8 en avril 2019 , car une implémentation efficace nécessiterait le support du runtime. Cela n'a pas pu être ajouté à temps avant la sortie. La fonctionnalité devrait bien fonctionner à la fois pour C # et VB.NET - F # n'aime pas les interfaces de toute façon.

si BM n'est pas présent au moment de l'exécution, AM () sera appelé. Pour base () et les interfaces, cela n'est pas pris en charge par le runtime, donc l'appel lèvera une exception à la place. Nous aimerions ajouter un support pour cela dans le runtime, mais c'est trop cher pour faire cette version.

Nous avons quelques solutions de contournement, mais ils n'ont pas le comportement que nous voulons et ne sont pas le codegen préféré.

Notre implémentation pour C # est quelque peu réalisable, bien que ce ne soit pas exactement ce que nous aimerions, mais l'implémentation VB serait beaucoup plus difficile. De plus, l'implémentation de VB nécessiterait que les méthodes d'implémentation de l'interface soient une surface API publique.

Cela fonctionnera par le biais d'un base()appel similaire au fonctionnement des classes. Coopérer l'exemple de proposition:

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?
    }
}