Attributs (F#)

  • Article

Les attributs activent les métadonnées à appliquer à une construction de programmation.

Syntaxe

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

Notes

Dans la syntaxe précédente, la cible est facultative et, le cas échéant, spécifie le type d’entité de programme à laquelle l’attribut s’applique. Les valeurs valides pour la cible sont affichées dans le tableau qui apparaît plus loin dans ce document.

Le nom-attribut fait référence au nom (éventuellement qualifié avec des espaces de noms) d’un type d’attribut valide, avec ou sans le suffixe Attribute qui est généralement utilisé dans les noms de types d’attributs. Par exemple, le type ObsoleteAttribute peut être raccourci à juste Obsolete dans ce contexte.

Les arguments sont les arguments du constructeur pour le type d’attribut. Si un attribut a un constructeur sans paramètre, la liste d’arguments et les parenthèses peuvent être omises. Les attributs prennent en charge les arguments positionnels et les arguments nommés. Les arguments positionnels sont des arguments utilisés dans l’ordre dans lequel ils apparaissent. Les arguments nommés peuvent être utilisés si l’attribut a des propriétés publiques. Vous pouvez les définir à l’aide de la syntaxe suivante dans la liste d’arguments.

property-name = property-value

Ces initialisations de propriété peuvent être dans n’importe quel ordre, mais elles doivent suivre tous les arguments positionnels. Voici un exemple d’attribut qui utilise des arguments positionnels et des initialisations de propriétés :

open System.Runtime.InteropServices

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

Dans cet exemple, l’attribut est DllImportAttribute, ici utilisé sous forme abrégée. Le premier argument est un paramètre positionnel et le second est une propriété.

Les attributs sont une construction de programmation .NET qui permet à un objet appelé attribut d’être associé à un type ou à un autre élément de programme. L’élément de programme auquel un attribut est appliqué est appelé cible d’attribut. L’attribut contient généralement des métadonnées sur sa cible. Dans ce contexte, les métadonnées peuvent être n’importe quelle donnée sur le type autre que ses champs et ses membres.

Les attributs en F# peuvent être appliqués aux constructions de programmation suivantes : fonctions, méthodes, assemblies, modules, types (classes, enregistrements, structures, interfaces, délégués, énumérations, unions, et ainsi de suite), constructeurs, propriétés, champs, paramètres, paramètres de type et valeurs de retour. Les attributs ne sont pas autorisés sur les liaisons let à l’intérieur de classes, d’expressions ou d’expressions de flux de travail.

En règle générale, la déclaration d’attribut apparaît directement avant la déclaration de la cible d’attribut. Plusieurs déclarations d’attribut peuvent être utilisées ensemble, comme suit :

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

Vous pouvez interroger des attributs au moment de l’exécution à l’aide de la réflexion .NET.

Vous pouvez déclarer plusieurs attributs individuellement, comme dans l’exemple de code précédent, ou les déclarer entre crochets si vous utilisez un point-virgule pour séparer les attributs et constructeurs individuels, comme suit :

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

En règle générale, les attributs rencontrés incluent l’attribut Obsolete, les attributs pour les considérations de sécurité, les attributs pour la prise en charge COM, les attributs liés à la propriété du code et les attributs indiquant si un type peut être sérialisé. L’exemple suivant illustre l’utilisation de l’attribut 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

Pour les cibles d’attribut assembly et module, vous appliquez les attributs à une liaison do de niveau supérieur dans votre assembly. Vous pouvez inclure le mot assembly ou ``module`` dans la déclaration d’attribut, comme suit :

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

Si vous omettez la cible d’attribut pour un attribut appliqué à une liaison do, le compilateur F# tente de déterminer la cible d’attribut qui est logique pour cet attribut. De nombreuses classes d’attributs ont un attribut de type System.AttributeUsageAttribute qui inclut des informations sur les cibles possibles prises en charge pour cet attribut. Si le System.AttributeUsageAttribute indique que l’attribut prend en charge les fonctions en tant que cibles, l’attribut est pris pour s’appliquer au point d’entrée principal du programme. Si le System.AttributeUsageAttribute indique que l’attribut prend en charge les assemblies en tant que cibles, le compilateur accepte l’attribut à appliquer à l’assembly. La plupart des attributs ne s’appliquent pas à la fois aux fonctions et aux assemblies, mais dans les cas où ils le font, l’attribut est pris pour s’appliquer à la fonction principale du programme. Si la cible d’attribut est spécifiée explicitement, l’attribut est appliqué à la cible spécifiée.

Bien que vous n’ayez généralement pas besoin de spécifier explicitement la cible d’attribut, les valeurs valides pour la cible dans un attribut, ainsi que des exemples d’utilisation, sont indiquées dans le tableau suivant :

Cible d’attribut Exemple
assembly 
[<assembly: AssemblyVersion("1.0.0.0")>]
module 
[<``module``: MyCustomAttributeThatWorksOnModules>]
return 
let function1 x : [<return: MyCustomAttributeThatWorksOnReturns>] int = x + 1
field 
[<DefaultValue>] val mutable x: int
propriété 
[<Obsolete>] this.MyProperty = x
param 
member this.MyMethod([<Out>] x : ref<int>) = x := 10
type 
[<type: StructLayout(LayoutKind.Sequential)>]
type MyStruct =
  struct
    val x : byte
    val y : int
  end

Voir aussi