Espressioni di oggetto

Un'espressione oggetto è un'espressione che crea una nuova istanza di un compilatore generato, un tipo di oggetto anonimo basato su un tipo di base, un'interfaccia o un set di interfacce esistente.

Sintassi

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

Osservazioni:

Nella sintassi precedente il nometipo rappresenta un tipo di classe o un tipo di interfaccia esistente. type-params descrive i parametri di tipo generico facoltativi. Gli argomenti vengono usati solo per i tipi di classe, che richiedono parametri del costruttore. Le definizioni dei membri sono sostituzioni dei metodi della classe base o implementazioni di metodi astratti da una classe di base o da un'interfaccia.

Nell'esempio seguente vengono illustrati diversi tipi di espressioni oggetto.

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

Uso di espressioni di oggetto

Usare espressioni di oggetto quando si desidera evitare il codice aggiuntivo e il sovraccarico necessari per creare un nuovo tipo denominato. Se si usano espressioni di oggetto per ridurre al minimo il numero di tipi creati in un programma, è possibile ridurre il numero di righe di codice e impedire la proliferazione non necessaria di tipi. Invece di creare molti tipi solo per gestire situazioni specifiche, è possibile usare un'espressione oggetto che personalizza un tipo esistente o fornisce un'implementazione appropriata di un'interfaccia per il caso specifico.

Vedi anche

• Riferimenti per il linguaggio F#