Freigeben über


Objektausdrücke (F#)

Ein Objektausdruck ist ein Ausdruck, der eine neue Instanz eines dynamisch erstellten anonymen Objekttyps erzeugt, der auf einem vorhandenen Basistyp, einer vorhandenen Schnittstelle oder einem vorhandenen Satz von Schnittstellen basiert.

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

Hinweise

In der vorherigen Syntax stellt typename einen vorhandenen Klassen- oder Schnittstellentyp dar. type-params beschreibt die optionalen generischen Typparameter. Die arguments werden nur für Klassentypen verwendet, die Konstruktorparameter erfordern. Die member-definitions sind Überschreibungen von Basisklassenmethoden oder Implementierungen abstrakter Methoden entweder einer Basisklasse oder einer Schnittstelle.

Im folgenden Beispiel werden mehrere unterschiedliche Typen von Objektausdrücken veranschaulicht.

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

Verwenden von Objektausdrücken

Objektausdrücke werden verwendet, wenn Sie den zusätzlichen Code und den Mehraufwand vermeiden möchten, die zum Erstellen eines neuen benannten Typs erforderlich sind. Wenn Sie die Anzahl der in einem Programm erstellten Typen mithilfe von Objektausdrücken minimieren, können Sie die Anzahl der Codezeilen verringern und die unnötige Anhäufung von Typen verhindern. Statt viele Typen zu erstellen, um bestimmte Situationen zu behandeln, können Sie einen Objektausdruck verwenden, der einen vorhandenen Typ anpasst oder eine geeignete Implementierung einer Schnittstelle für den spezifischen Fall bereitstellt.

Siehe auch

Weitere Ressourcen

F#-Sprachreferenz