Partager via


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.

Voir aussi

Autres ressources

Référence du langage F#