Compartilhar via

Atributos (F#)

  • Artigo

Os atributos permitem que os metadados sejam aplicados a um constructo de programação.

Sintaxe

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

Observações

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

O nome do atributo 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 atributos do tipo. Por exemplo, o tipo ObsoleteAttribute pode ser reduzido para apenas Obsolete nesse contexto.

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

property-name = property-value

Essas inicializações de propriedade podem estar em qualquer ordem, mas devem seguir quaisquer argumentos posicionais. Veja a seguir 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 na forma abreviada. O primeiro argumento é um parâmetro posicional e o segundo é uma propriedade.

Os atributos são um constructo de programação do .NET que permite que um objeto conhecido como atributo ser associado a um tipo ou outro elemento de programa. O elemento de programa ao qual um atributo é aplicado é conhecido como o destino de atributo . O atributo geralmente contém metadados sobre seu destino. Nesse contexto, os metadados podem ser qualquer dado sobre o tipo além de seus campos e membros.

Os atributos em F# podem ser aplicados aos seguintes constructos 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. Atributos não são permitidos em associações let dentro de classes, expressões ou expressões de fluxo de trabalho.

Normalmente, a declaração de atributo é exibida diretamente antes da declaração do destino do atributo. Várias declarações de atributo podem ser usadas em conjunto, da seguinte maneira:

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

Você pode consultar atributos em tempo de execução usando a reflexão 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 e construtores individuais, da seguinte maneira:

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

Os atributos normalmente encontrados incluem o atributo Obsolete, atributos para considerações de segurança, atributos para suporte com 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 atributo Obsolete.

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 de atributo assembly e module, você aplica os atributos a uma associação do de nível 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 de atributo para um atributo aplicado a uma associação de do, o compilador F# tentará determinar o destino de atributo que faz sentido para esse atributo. Muitas classes de atributo têm um atributo de tipo System.AttributeUsageAttribute que inclui informações sobre os possíveis destinos com suporte para esse atributo. Se o System.AttributeUsageAttribute indicar que o atributo dá suporte a funções como destinos, o atributo será usado para se aplicar ao ponto de entrada principal do programa. Se o atributo System.AttributeUsageAttribute indicar que o atributo dá suporte a assemblies como destinos, o compilador usará o atributo a ser aplicado ao assembly. A maioria dos atributos não se aplica a funções e assemblies, mas nos casos em que o fazem, o atributo é usado para se aplicar à função principal do programa. Se o destino do atributo for especificado explicitamente, o atributo será aplicado ao destino especificado.

Embora geralmente você não precise especificar explicitamente o atributo "target", valores válidos para e no atributo, juntamente com exemplos de uso, são mostrados na tabela a seguir:

Destino do atributo Exemplo
assembleia 
[<assembly: AssemblyVersion("1.0.0.0")>]
módulo 
[<``module``: MyCustomAttributeThatWorksOnModules>]
método 
[<MyCustomAttributeThatWorksOnMethods>]
let someFunction() = 42
classe 
[<MyCustomAttributeThatWorksOnClasses>]
type MyClass(myValue: int) =
    member _.MyValue = myValue
struct 
[<MyCustomAttributeThatWorksOnStructs>]
[<Struct>]
type MyStruct(myValue: int) =
    member _.MyValue = myValue
interface 
[<MyCustomAttributeThatWorksOnInterfaces>]
type MyInterface =
    abstract member Prop: string
enum 
[<MyCustomAttributeThatWorksOnEnums>]
type Color =
    | Red = 0
    | Green = 1
    | Blue = 2
construtor 
type MyClass(myValue: int) =
    member _.MyValue = myValue

    [<MyCustomAttributeThatWorksOnCtors>]
    new () = MyClass 42
return 
let function1 x : [<return: MyCustomAttributeThatWorksOnReturns>] int = x + 1
field 
[<DefaultValue>] val mutable x: int
property 
[<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