Expressions d’objet

Une expression d’objet est une expression qui crée une nouvelle instance d’un compilateur généré, un type d’objet anonyme basé sur un type de base, une interface ou un ensemble d’interfaces existant.

Syntaxe

// 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 ]
}

Remarques

Dans la syntaxe précédente, le nom de type représente un type de classe ou un type d’interface existant. les paramètres de type-params décrivent les paramètres de type générique facultatifs. Les arguments sont utilisés uniquement pour les types de classes, qui nécessitent des paramètres de constructeur. Les définitions membres sont des remplacements de méthodes de classe de base ou d’implémentations de méthodes abstraites à partir d’une classe de base ou d’une interface.

L’exemple suivant illustre plusieurs types d’expressions d’objet différentes.

// This object expression specifies a System.Object but overrides the
// ToString method.
let obj1 = { new System.Object() with member x.ToString() = "F#" }
printfn $"{obj1}"

// This object expression implements the IFormattable interface.
let delimiter(delim1: string, delim2: string, value: string) =
    { new System.IFormattable with
        member x.ToString(format: string, provider: System.IFormatProvider) =
            if format = "D" then
                delim1 + value + delim2
            else
                value }

let obj2 = delimiter("{","}", "Bananas!");

printfn "%A" (System.String.Format("{0:D}", obj2))

// Define two 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 both interfaces.
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

Vous utilisez des expressions d’objet lorsque vous souhaitez éviter le code supplémentaire et la surcharge requises pour créer un nouveau type nommé. Si vous utilisez des expressions d’objet pour réduire 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 simplement pour gérer des situations spécifiques, vous pouvez utiliser une expression d’objet qui personnalise un type existant ou fournit une implémentation appropriée d’une interface pour le cas spécifique à la main.

Voir aussi

• Référence du langage F#