Compartir a través de


Expresiones de objeto (F#)

Una expresión de objeto es una expresión que crea una nueva instancia de un tipo de objeto anónimo creado dinámicamente que se basa en un tipo base, una interfaz o un conjunto de interfaces existente.

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

Comentarios

En la sintaxis anterior, typename representa un tipo de clase o tipo de interfaz existente. type-params describe los parámetros de tipo genérico opcionales. El parámetro arguments se usa únicamente para los tipos de clase, que requieren parámetros de constructor. El parámetro member-definitions representa reemplazos de métodos de clase base o implementaciones de métodos abstractos de una clase base o una interfaz.

En el ejemplo siguiente se muestran diferentes tipos de expresiones de objeto.

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

Uso de expresiones de objeto

Las expresiones de objeto se usan cuando se desean evitar el código adicional y la sobrecarga que se requieren para crear un nuevo tipo con nombre. El uso de expresiones de objeto para minimizar el número de tipos creados en un programa permite reducir el número de líneas de código y evitar la proliferación innecesaria de tipos. En lugar de crear muchos tipos simplemente para hacer frente a situaciones concretas, se puede usar una expresión de objeto que personalice un tipo existente o proporcione una implementación apropiada de una interfaz para el caso en cuestión.

Vea también

Otros recursos

Referencia del lenguaje F#