Delen via


Objectexpressies

Een objectexpressie is een expressie waarmee een nieuw exemplaar wordt gemaakt van een gegenereerd, anoniem objecttype dat is gebaseerd op een bestaand basistype, interface of set interfaces.

Syntaxis

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

Opmerkingen

In de vorige syntaxis vertegenwoordigt de typenaam een bestaand klassetype of interfacetype. type-params beschrijven de optionele algemene typeparameters. De argumenten worden alleen gebruikt voor klassetypen, waarvoor constructorparameters zijn vereist. De liddefinities zijn onderdrukkingen van basisklassemethoden of implementaties van abstracte methoden van een basisklasse of een interface.

In het volgende voorbeeld ziet u verschillende typen objectexpressies.

// 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() = () }

Objectexpressies gebruiken

U gebruikt objectexpressies als u de extra code en overhead wilt vermijden die nodig is om een nieuw benoemd type te maken. Als u objectexpressies gebruikt om het aantal typen dat in een programma is gemaakt, te minimaliseren, kunt u het aantal regels code verminderen en onnodige verspreiding van typen voorkomen. In plaats van veel typen te maken om specifieke situaties af te handelen, kunt u een objectexpressie gebruiken die een bestaand type aanpast of een geschikte implementatie van een interface biedt voor het specifieke geval.

Zie ook