Expressions d'objet (F#)
Une expression d'objet est une expression qui crée une instance d'un type d'objet créé dynamiquement et anonyme qui est basé sur un type de base, une interface ou un jeu d'interfaces existant.
// When typename is a class:
{ new typename [type-params] arguments with
member-definitions
[ additional-interface-definitions ]
}
// When typename is not a class:
{ new typename [generic-type-args] with
member-definitions
[ additional-interface-definitions ]
}
Notes
Dans la syntaxe précédente, le typename représente un type de classe ou d'interface existant. type-params décrit les paramètres de type générique facultatifs. Les arguments sont uniquement utilisés pour les types de classe qui nécessitent des paramètres de constructeur. Les member-definitions sont des substitutions de méthodes de classe de base, ou des implémentations de méthodes abstraites d'une classe de base ou d'une interface.
L'exemple suivant illustre différents types d'expressions d'objet.
// This object expression specifies a System.Object but overrides the
// ToString method.
let obj1 = { new System.Object() with member x.ToString() = "F#" }
printfn "%A" obj1
// This object expression implements the IFormattable interface.
let Delimiter(delim1 : string, delim2 : string ) = { new System.IFormattable with
member x.ToString(format : string, provider : System.IFormatProvider) =
if format = "D" then delim1 + x.ToString() + delim2
else x.ToString()
}
let obj2 = Delimiter("{","}");
printfn "%A" (System.String.Format("{0:D}", obj2))
// This object expression implements multiple interfaces.
type IFirst =
abstract F : unit -> unit
abstract G : unit -> unit
type ISecond =
inherit IFirst
abstract H : unit -> unit
abstract J : unit -> unit
// This object expression implements an interface chain.
let Implementer() = { new ISecond with
member this.H() = ()
member this.J() = ()
interface IFirst with
member this.F() = ()
member this.G() = ()
}
Utilisation d'expressions d'objet
Les expressions d'objet vous permettent d'éviter la création de code supplémentaire et la surcharge liées à la création d'un type nommé. Si vous utilisez des expressions d'objet pour minimiser le nombre de types créés dans un programme, vous pouvez réduire le nombre de lignes de code et empêcher la prolifération inutile de types. Au lieu de créer de nombreux types pour gérer seulement des situations spécifiques, vous pouvez utiliser une expression d'objet qui personnalise un type existant ou qui fournit une implémentation appropriée d'une interface pour le cas spécifique à traiter.