Interfaces (F#)
Les interfaces spécifient des jeux de membres connexes que d'autres classes implémentent.
// 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
Notes
Les déclarations d'interface ressemblent aux déclarations de classe, à ceci près qu'aucun membre n'est implémenté. Au lieu de cela, tous les membres sont abstraits, comme indiqué par le mot clé abstract. Vous ne fournissez pas de corps de méthode pour les méthodes abstraites. Toutefois, vous pouvez fournir une implémentation par défaut en incluant une définition séparée du membre comme méthode avec le mot clé default. Cela revient à créer une méthode virtuelle dans une classe de base dans d'autres langages .NET. Une telle méthode virtuelle peut être substituée dans les classes qui implémentent l'interface.
Vous pouvez implémenter des interfaces de deux manières : à l'aide d'expressions d'objet ou à l'aide de types de classe. Dans les deux cas, le type de classe ou l'expression d'objet fournit des corps de méthode pour les méthodes abstraites de l'interface. Les implémentations sont spécifiques à chaque type qui implémente l'interface. Par conséquent, des méthodes d'interface sur des types différents peuvent être différentes les unes des autres.
Les mots clés interface et end, qui marquent le début et la fin de la définition, sont facultatifs lorsque vous utilisez la syntaxe simplifiée. Si vous n'utilisez pas ces mots clés, le compilateur tente de déduire si le type est une classe ou une interface en analysant les constructions que vous utilisez. Si vous définissez un membre ou utilisez une autre syntaxe de classe, le type est interprété comme une classe.
Selon le style de codage .NET, toutes les interfaces doivent commencer par un I majuscule.
Implémentation d'interfaces à l'aide de types de classe
Vous pouvez implémenter une ou plusieurs interfaces dans un type de classe en utilisant le mot clé interface, le nom de l'interface et le mot clé with, suivis des définitions des membres d'interface, comme indiqué dans le code suivant.
type IPrintable =
abstract member Print : unit -> unit
type SomeClass1(x: int, y: float) =
interface IPrintable with
member this.Print() = printfn "%d %f" x y
Les implémentations d'interface sont héritées, donc les classes dérivées n'ont pas besoin de les réimplémenter.
Appel de méthodes d'interface
Les méthodes d'interface peuvent être uniquement appelées par l'intermédiaire de l'interface, et non par l'intermédiaire du type qui implémente l'interface. Vous devrez donc peut-être effectuer un upcast vers le type d'interface à l'aide de l'opérateur :> ou upcast pour appeler ces méthodes.
Pour appeler la méthode d'interface lorsque vous avez un objet de type SomeClass, vous devez effectuer un upcast de l'objet vers le type d'interface, comme indiqué dans le code suivant.
let x1 = new SomeClass1(1, 2.0)
(x1 :> IPrintable).Print()
Vous avez également la possibilité de déclarer une méthode sur l'objet qui effectue un upcast et qui appelle la méthode d'interface, comme dans l'exemple suivant.
type SomeClass2(x: int, y: float) =
member this.Print() = (this :> IPrintable).Print()
interface IPrintable with
member this.Print() = printfn "%d %f" x y
let x2 = new SomeClass2(1, 2.0)
x2.Print()
Implémentation d'interfaces à l'aide d'expressions d'objet
Les expressions d'objet constituent une méthode rapide pour implémenter une interface. Elles sont utiles lorsque vous n'avez pas besoin de créer un type nommé et que vous voulez simplement un objet qui prend en charge les méthodes d'interface, sans méthodes supplémentaires. Une expression d'objet est illustrée dans le code suivant.
let makePrintable(x: int, y: float) =
{ new IPrintable with
member this.Print() = printfn "%d %f" x y }
let x3 = makePrintable(1, 2.0)
x3.Print()
Héritage de l'interface.
Des interfaces peuvent hériter d'une ou de plusieurs interfaces de base.
type Interface1 =
abstract member Method1 : int -> int
type Interface2 =
abstract member Method2 : int -> int
type Interface3 =
inherit Interface1
inherit Interface2
abstract member Method3 : int -> int
type MyClass() =
interface Interface3 with
member this.Method1(n) = 2 * n
member this.Method2(n) = n + 100
member this.Method3(n) = n / 10