Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Espressioni di oggetto (F#)

Un'espressione di oggetto è un'espressione che consente di creare una nuova istanza di un tipo di oggetto anonimo creato dinamicamente basato su un'interfaccia, un set di interfacce o un tipo di base esistente.

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

Nella sintassi precedente typename rappresenta un tipo di interfaccia o di classe esistente. type-params descrive i parametri di tipo generico facoltativi. Gli elementi arguments vengono utilizzati solo per i tipi di classi che richiedono parametri dei costruttori. Gli elementi member-definitions sono override di metodi della classe di base o implementazioni di metodi astratti di un'interfaccia o una classe di base.

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


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


È possibile utilizzare le espressioni di oggetto quando si desidera evitare il codice aggiuntivo e il sovraccarico necessari per la creazione di un nuovo tipo denominato. Se si utilizzano espressioni di oggetto per ridurre il numero di tipi creati in un programma, è possibile ridurre il numero di righe di codice e impedire la proliferazione non necessaria di tipi. Anziché creare numerosi tipi solo per gestire situazioni specifiche, è possibile utilizzare un'espressione di oggetto per personalizzare un tipo esistente o fornire un'implementazione appropriata di un'interfaccia per il case specifico.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft