Expressões de objeto (F#)
Um expressão de objeto é uma expressão que cria uma nova instância de um tipo de objeto criado dinamicamente e anônimo que se baseia em um tipo de base existente, uma interface ou um conjunto de interfaces.
// 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 ]
}
Comentários
Na sintaxe anterior, o typename representa uma existente classe tipo ou a interface tipo. type-paramsDescreve os parâmetros opcionais de tipo genérico. O arguments são usados somente para tipos de classe, que exigem parâmetros do construtor. O member-definitions são substituições dos métodos da classe base, ou implementações de métodos abstratos da classe base ou uma interface.
O exemplo a seguir ilustra os vários tipos diferentes de expressões 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() = ()
}
Usando expressões de objeto
Você pode usar expressões de objeto quando você quiser evitar o código extra e a sobrecarga é necessário para criar um novo tipo de chamada. Se você usar expressões de objeto para minimizar o número de tipos criados em um programa, você pode reduzir o número de linhas de código e impedir a proliferação desnecessária de tipos. Em vez de criar muitos tipos apenas para lidar com situações específicas, você pode usar uma expressão de objeto que personaliza um tipo existente ou que fornece uma implementação adequada de uma interface para o caso específico em mãos.