Interfacce e proprietà F #

Question

Sto provando a prendere confidenza con F # e nel processo sto convertendo un codice C#. Ho qualche problema con la definizione delle proprietà in un'interfaccia e l'implementazione in un tipo.

Si consideri il seguente codice:

module File1 

type IMyInterface = 
    abstract member MyProp : bool with get, set 
    abstract member MyMethod : unit -> unit 

type MyType() = 
    interface IMyInterface with 
     member val MyProp = true with get, set 
     member self.MyMethod() = if MyProp then() else() 

The documentation for F# properties sembra affermare che la mia realizzazione di MyProp in MyType è corretto, tuttavia, il compilatore si lamenta che "il valore o il costruttore 'MyProp' non è definita". Qualche idea?

Answer 1

per accedere alla proprietà all'interno di un'interfaccia (esplicito) è necessario per lanciare al riferimento self per il tipo di interfaccia:

type MyType() = 
    interface IMyInterface with 
     member val MyProp = true with get, set 
     member self.MyMethod() = if (self :> IMyInterface).MyProp then() else() 

si ottiene lo stesso errore in C#, se si implementa l'interfaccia in modo esplicito, e un cast è necessaria anche per accedere al membro:

interface IMyInterface 
{ 
    bool MyProp { get; set; } 
    void MyMethod(); 
} 

class MyType : IMyInterface 
{ 
    bool IMyInterface.MyProp { get; set; } 

    void IMyInterface.MyMethod() 
    { 
     if (((IMyInterface)this).MyProp) { } 
    } 
} 

Answer 2

Ecco una versione di lavoro:

type IMyInterface = 
    abstract member MyProp : bool with get, set 
    abstract member MyMethod : unit -> unit 

type MyType() = 
    member val MyProp = true with get, set 
    member self.MyMethod() = if self.MyProp then() else() 
    interface IMyInterface with 
     member self.MyProp with get() = self.MyProp and set v = self.MyProp <- v 
     member self.MyMethod() = self.MyMethod() 

si prega di notare che ho incluso i membri espliciti come sicuramente avrebbe perso loro;)

Answer 3

Se sei solo l'accesso all'interfaccia, allora non c'è bisogno di definire i membri del tipo stesso. La risposta di Phil è buona se vuoi il minimalismo, ma un altro approccio Mi piace usare i valori "let-bound" piuttosto che i membri - per codice più complesso, l'inferenza di tipo è migliore e sono generalmente più facili da gestire rispetto ai membri .

type MyType() = 
    let mutable myProp = true 
    let myMethod() = if myProp then() else() 

    interface IMyInterface with 
     member __.MyProp with get() = myProp and set v = myProp <- v 
     member __.MyMethod() = myMethod() 

il codice è un po 'più pulito rispetto alle versioni membri così, imo, perché il tag self in type MyType() as self è necessaria solo per accedere membri - Valori let-bound è accessibile direttamente dall'interfaccia.