F # - Interfaces

Les interfaces fournissent une manière abstraite d'écrire les détails d'implémentation d'une classe. C'est un modèle qui déclare les méthodes que la classe doit implémenter et exposer publiquement.

Syntaxe

Une interface spécifie les ensembles de membres associés que d'autres classes implémentent. Il a la syntaxe suivante -

// Interface declaration:
[ attributes ]
type interface-name =
   [ interface ]
      [ inherit base-interface-name ...]
      abstract member1 : [ argument-types1 -> ] return-type1
      abstract member2 : [ argument-types2 -> ] return-type2
      ...
   [ end ]
	
// Implementing, inside a class type definition:
interface interface-name with
   member self-identifier.member1 argument-list = method-body1
   member self-identifier.member2 argument-list = method-body2
// Implementing, by using an object expression:
[ attributes ]
let class-name (argument-list) =
   { new interface-name with
      member self-identifier.member1 argument-list = method-body1
      member self-identifier.member2 argument-list = method-body2
      [ base-interface-definitions ]
   }
member-list

Veuillez noter -

Dans une déclaration d'interface, les membres ne sont pas implémentés.
Les membres sont abstraits, déclarés par le abstractmot-clé. Cependant, vous pouvez fournir une implémentation par défaut en utilisant ledefault mot-clé.
Vous pouvez implémenter des interfaces en utilisant des expressions d'objet ou en utilisant des types de classe.
Dans l'implémentation de classe ou d'objet, vous devez fournir des corps de méthode pour les méthodes abstraites de l'interface.
Les mots clés interface et end, qui marquent le début et la fin de la définition, sont facultatifs.

Par exemple,

type IPerson =
   abstract Name : string
   abstract Enter : unit -> unit
   abstract Leave : unit -> unit

Appel des méthodes d'interface

Les méthodes d'interface sont appelées via l'interface, et non via l'instance de l'interface d'implémentation de classe ou de type. Pour appeler une méthode d'interface, vous transtypez vers le type d'interface à l'aide du:> opérateur (opérateur upcast).

Par exemple,

(s :> IPerson).Enter()
(s :> IPerson).Leave()

L'exemple suivant illustre le concept -

Exemple

type IPerson =
   abstract Name : string
   abstract Enter : unit -> unit
   abstract Leave : unit -> unit

type Student(name : string, id : int) =
   member this.ID = id
   interface IPerson with
      member this.Name = name
      member this.Enter() = printfn "Student entering premises!"
      member this.Leave() = printfn "Student leaving premises!"

type StuffMember(name : string, id : int, salary : float) =
   let mutable _salary = salary

   member this.Salary
      with get() = _salary
      and set(value) = _salary <- value

   interface IPerson with
      member this.Name = name
      member this.Enter() = printfn "Stuff member entering premises!"
      member this.Leave() = printfn "Stuff member leaving premises!"

let s = new Student("Zara", 1234)
let st = new StuffMember("Rohit", 34, 50000.0)

(s :> IPerson).Enter()
(s :> IPerson).Leave()
(st :> IPerson).Enter()
(st :> IPerson).Leave()

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Student entering premises!
Student leaving premises!
Stuff member entering premises!
Stuff member leaving premises!

Héritage d'interface

Les interfaces peuvent hériter d'une ou plusieurs interfaces de base.

L'exemple suivant montre le concept -

type Interface1 =
   abstract member doubleIt: int -> int

type Interface2 =
   abstract member tripleIt: int -> int

type Interface3 =
   inherit Interface1
   inherit Interface2
   abstract member printIt: int -> string

type multiplierClass() =
   interface Interface3 with
      member this.doubleIt(a) = 2 * a
      member this.tripleIt(a) = 3 * a
      member this.printIt(a) = a.ToString()

let ml = multiplierClass()
printfn "%d" ((ml:>Interface3).doubleIt(5))
printfn "%d" ((ml:>Interface3).tripleIt(5))
printfn "%s" ((ml:>Interface3).printIt(5))