Compartilhar via


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.

Consulte também

Outros recursos

Referência de linguagem do F#