Atributos (F#)
Atributos permitem que os metadados a serem aplicadas a uma construção de programação.
[<target:attribute-name(arguments)>]
Comentários
Na sintaxe anterior, o target é opcional e, se presente, especifica o tipo de entidade do programa que o atributo se aplica a. Os valores válidos para target são mostrados na tabela que aparece mais adiante neste documento.
O attribute-name refere-se ao nome do (possivelmente qualificado com espaços para nomes) 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 de ObsoleteAttribute pode ser reduzida para apenas Obsolete neste contexto.
O arguments são os argumentos para o construtor para o tipo de atributo. Se um atributo tem um construtor padrão, a lista de argumentos e parênteses podem ser omitidos. Atributos oferecem suporte a argumentos posicionais e argumentos nomeados. Argumentos posicionais são argumentos usados na ordem em que aparecem. Argumentos nomeados podem ser usados se o atributo tem propriedades públicas. Você pode definir essas configurações usando a seguinte sintaxe na lista de argumentos.
property-name = property-value
Tais inicializações de propriedade podem estar em qualquer ordem, mas eles devem seguir quaisquer argumentos posicionais. 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, usado aqui na forma abreviada. O primeiro argumento é um parâmetro posicional e o segundo é uma propriedade.
Atributos são um.NET construção de programação que permite que um objeto conhecido como um atributo a ser associado um tipo ou outro elemento de programa. O elemento de programa ao qual um atributo é aplicado é conhecido como o atributo de destino. O atributo geralmente contém metadados sobre seu destino. Nesse contexto, os metadados poderiam ser quaisquer dados sobre o tipo diferente de seus campos e membros.
Atributos de F# podem ser aplicados para as 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. Atributos não são permitidos em let ligações dentro de classes, expressões ou expressões de fluxo de trabalho.
Normalmente, a declaração de atributo será exibida diretamente antes da declaração do atributo de destino. Várias declarações de atributo podem ser usadas em conjunto, da seguinte forma.
[<Owner("Jason Carlson")>]
[<Company("Microsoft")>]
type SomeType1 =
Você pode consultar os atributos em tempo de execução usando.NET reflexão.
Você pode declarar vários atributos individualmente, como no exemplo de código anterior, ou você pode declará-los em um conjunto de colchetes se você usar um ponto e vírgula para separar os atributos individuais e construtores, conforme mostrado aqui.
[<Owner("Darren Parker"); Company("Microsoft")>]
type SomeType2 =
Atributos encontrados normalmente incluem o Obsolete atributos de atributo, atributos, as considerações de segurança, COM suporte, atributos relacionados à propriedade de código e atributos que indica se um tipo pode ser serializado. O exemplo a seguir demonstra o uso de 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 do atributo assembly e module, aplicar os atributos para um nível superior do a ligação de assembly. Você pode incluir a palavra assembly ou module na declaração de atributo, como segue:
open System.Reflection
[<assembly:AssemblyVersionAttribute("1.0.0.0")>]
do
printfn "Executing..."
Se você omitir o atributo de destino para um atributo aplicado a uma do de vinculação, o compilador F# tenta determinar o destino de atributo que faça sentido para o atributo. Muitas classes de atributo tem um atributo do tipo AttributeUsageAttribute que inclui informações sobre os possíveis alvos, suportada para esse atributo. Se o AttributeUsageAttribute indica que o atributo oferece suporte a funções como destinos, o atributo é levado para aplicar o ponto de entrada principal do programa. Se o AttributeUsageAttribute indica que o atributo oferece suporte a assemblies como destinos, o compilador usa o atributo a ser aplicado ao assembly. A maioria dos atributos não se aplicam a assemblies e funções, mas em casos onde eles fazem, o atributo é levado para aplicar a função principal do programa. Se o atributo de destino for especificado explicitamente, o atributo é aplicado ao destino especificado.
Embora você normalmente precisa especificar o atributo explicitamente, direcione os valores válidos para target em um atributo são mostrados na tabela a seguir, junto com exemplos de uso.
Atributo de destino |
Exemplo |
|---|---|
Assembly |
[<assembly: AssemblyVersionAttribute("1.0.0.0")>] |
Retornar |
let function1 x : [<return: Obsolete>] int = x + 1 |
campo |
[<field: DefaultValue>] val mutable x: int |
propriedade |
[<property: Obsolete>] this.MyProperty = x |
param |
member this.MyMethod([<param: Out>] x : ref<int>) = x := 10 |
tipo |
[<type: StructLayout(Sequential)>] type MyStruct = struct x : byte y : int end |