Comment utiliser l'implémentation de base d'un membre abstrait surchargé?

Question

Il existe une interface (disons IA), une implémentation (disons Base) de l'interface IA, et une classe dérivée de Base (disons Derived) qui remplace un membre abstrait de IA. Maintenant, dans l'implémentation du membre surchargé, je veux utiliser l'implémentation du membre de Base. Cependant, je ne sais pas comment écrire pour le faire.

Ce code illustre ma question:

type Flag = 
    | F1 = 1 
    | F2 = 2 

type IA = 
    abstract member A: Flag 

type Base() = 
    interface IA with 
    member this.A = F1 

type Derived() = 
    inherit Base() 

    interface IA with 
    override this.A = (* ? *) 
     // base.A ||| F2    // NG (Compile error that `A` isn't a member of `base`) 
     // (base :> IA).A ||| F2  // NG (Syntax error) 
     // (this :> IA).A ||| F2  // NG (Infinite recursion) 

Answer 1

Je pense en fait il n'y a aucun moyen de le faire. Les implémentations d'interface F # sont similaires aux implémentations d'interface explicites en C# et you cannot call base implementation of an explicitly implemented interface in C#.

La solution consiste à modifier la classe de base pour qu'il soit plus comme C# implémentation d'interface implicite (qui est malheureusement un peu lourd):

type Base() = 
    // Define virtual property in class Base 
    abstract A : Flag 
    default this.A = Flag.F1 
    // Implement IA via the virtual property 
    interface IA with 
    member this.A = this.A 

type Derived() = 
    inherit Base() 
    // Override the virtual property 
    override this.A = base.A ||| Flag.F2 

qui suit retourne maintenant 3 comme prévu:

(Derived() :> IA).A