Partilhar via

Atributos (F#)

  • Artigo

Os atributos permitem que os metadados sejam aplicados a uma construção de programação.

Sintaxe

[<target:attribute-name(arguments)>]

Observações

Na sintaxe anterior, o destino é opcional e, se presente, especifica o tipo de entidade de programa à qual o atributo se aplica. Os valores válidos para o destino são mostrados na tabela que aparece posteriormente neste documento.

O atributo-nome refere-se ao nome (possivelmente qualificado com namespaces) de um tipo de atributo válido, com ou sem o sufixo Attribute que geralmente é usado em nomes de tipo de atributo. Por exemplo, o tipo ObsoleteAttribute pode ser encurtado apenas Obsolete neste contexto.

Os argumentos são os argumentos para o construtor para o tipo de atributo. Se um atributo tiver um construtor sem parâmetros, a lista de argumentos e os parênteses podem ser omitidos. Os atributos suportam argumentos posicionais e argumentos nomeados. Argumentos posicionais são argumentos que são usados na ordem em que aparecem. Os argumentos nomeados podem ser usados se o atributo tiver propriedades públicas. Você pode defini-los usando a sintaxe a seguir na lista de argumentos.

property-name = property-value

Tais inicializações de propriedade podem estar em qualquer ordem, mas devem seguir quaisquer argumentos posicionais. A seguir está um exemplo de um atributo que usa argumentos posicionais e inicializações de propriedade:

open System.Runtime.InteropServices

[<DllImport("kernel32", SetLastError=true)>]
extern bool CloseHandle(nativeint handle)

Neste exemplo, o atributo é DllImportAttribute, aqui usado de forma abreviada. O primeiro argumento é um parâmetro posicional e o segundo é uma propriedade.

Atributos são uma construção de programação .NET que permite que um objeto conhecido como um atributo seja associado a um tipo ou outro elemento de programa. O elemento de programa ao qual um atributo é aplicado é conhecido como o destino do atributo. O atributo geralmente contém metadados sobre seu destino. Neste contexto, os metadados podem ser quaisquer dados sobre o tipo que não sejam os seus campos e membros.

Os atributos em F# podem ser aplicados às seguintes construções de programação: funções, métodos, assemblies, módulos, tipos (classes, registros, estruturas, interfaces, delegados, enumerações, uniões e assim por diante), construtores, propriedades, campos, parâmetros, parâmetros de tipo e valores de retorno. Os atributos não são permitidos em let associações dentro de classes, expressões ou expressões de fluxo de trabalho.

Normalmente, a declaração de atributo aparece diretamente antes da declaração do destino do atributo. As declarações de múltiplos atributos podem ser usadas juntas, da seguinte forma:

[<Owner("Jason Carlson")>]
[<Company("Microsoft")>]
type SomeType1 =

Você pode consultar atributos em tempo de execução usando o reflexo do .NET.

Você pode declarar vários atributos individualmente, como no exemplo de código anterior, ou pode declará-los em um conjunto de colchetes se usar um ponto-e-vírgula para separar os atributos individuais e construtores, da seguinte maneira:

[<Owner("Darren Parker"); Company("Microsoft")>]
type SomeType2 =

Os atributos normalmente encontrados incluem o Obsolete atributo, atributos para considerações de segurança, atributos para suporte COM, atributos relacionados à propriedade do código e atributos que indicam se um tipo pode ser serializado. O exemplo a seguir demonstra o uso do Obsolete atributo.

open System

[<Obsolete("Do not use. Use newFunction instead.")>]
let obsoleteFunction x y =
  x + y

let newFunction x y =
  x + 2 * y

// The use of the obsolete function produces a warning.
let result1 = obsoleteFunction 10 100
let result2 = newFunction 10 100

Para os destinos assembly de atributo e module, você aplica os atributos a uma associação de nível do superior em seu assembly. Você pode incluir a palavra assembly ou ``module`` na declaração de atributo, da seguinte maneira:

open System.Reflection
[<assembly:AssemblyVersionAttribute("1.0.0.0")>]
[<``module``:MyCustomModuleAttribute>]
do
   printfn "Executing..."

Se você omitir o destino do atributo para um atributo aplicado a uma do associação, o compilador F# tentará determinar o destino do atributo que faz sentido para esse atributo. Muitas classes de atributo têm um atributo do tipo System.AttributeUsageAttribute que inclui informações sobre os possíveis destinos suportados para esse atributo. Se o System.AttributeUsageAttribute indica que o atributo suporta funções como destinos, o atributo é tomado para aplicar ao ponto de entrada principal do programa. Se o System.AttributeUsageAttribute indica que o atributo suporta assemblies como destinos, o compilador usa o atributo para aplicar ao assembly. A maioria dos atributos não se aplica a funções e montagens, mas nos casos em que o fazem, o atributo é considerado para se aplicar à função principal do programa. Se o destino do atributo for especificado explicitamente, o atributo será aplicado ao destino especificado.

Embora normalmente não seja necessário especificar explicitamente o destino do atributo, os valores válidos para o destino em um atributo, juntamente com exemplos de uso, são mostrados na tabela a seguir:

Destino do atributo Exemplo
assemblagem 
[<assembly: AssemblyVersion("1.0.0.0")>]
módulo 
[<``module``: MyCustomAttributeThatWorksOnModules>]
regressar 
let function1 x : [<return: MyCustomAttributeThatWorksOnReturns>] int = x + 1
campo 
[<DefaultValue>] val mutable x: int
propriedade 
[<Obsolete>] this.MyProperty = x
param 
member this.MyMethod([<Out>] x : ref<int>) = x := 10
tipo 
[<type: StructLayout(LayoutKind.Sequential)>]
type MyStruct =
  struct
    val x : byte
    val y : int
  end

Consulte também