Expressions d'objet

Une expression d’objet est une expression qui crée une nouvelle instance d’un type d’objet généré par compilateur, anonyme et basé sur un type de base, une interface ou un jeu 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 ]
}

Notes

Dans la syntaxe précédente, le typename représente un type de classe ou un type d’interface existant. type-params décrit les paramètres de type génériques facultatifs. Les arguments sont utilisés uniquement pour les types de classe, qui nécessitent des paramètres de constructeur. Les member-definitions sont des remplacements de méthodes de classe de base ou des 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érents.

// 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 pouvez utiliser des expressions d’objet lorsque vous souhaitez éviter le code et la surcharge supplémentaires requis pour créer un 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 des types. Au lieu de créer de nombreux types uniquement 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.

Voir aussi

• Informations de référence du langage F#