Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Attributs (C# et Visual Basic)

Les attributs fournissent une méthode performante pour associer des métadonnées, ou des informations de déclaration, au code (assemblies, types, méthodes, propriétés, etc.). Une fois qu'il est associé à une entité de programme, l'attribut peut être interrogé au moment de l'exécution au moyen d'une technique appelée réflexion. Pour plus d’informations, consultez Réflexion (C# et Visual Basic).

Les attributs ont les propriétés suivantes :

  • Les attributs ajoutent des métadonnées à votre programme. Les métadonnées sont des informations sur les types définis dans un programme. Tous les assemblys .NET contiennent un ensemble spécifique de métadonnées décrivant les types et les membres de type définis dans l'assembly. Vous pouvez ajouter des attributs personnalisés pour spécifier toutes les informations supplémentaires nécessaires. Pour plus d'informations, consultez Création d'attributs personnalisés (C# et Visual Basic).

  • Vous pouvez appliquer un ou plusieurs attributs à des modules ou à des assemblys tout entiers, ou à des éléments de programme plus petits, comme les classes et les propriétés.

  • Les attributs peuvent accepter des arguments, de la même façon que les méthodes et les propriétés.

  • Votre programme peut examiner ses propres métadonnées ou celles dans d'autres programmes au moyen de la réflexion. Pour plus d’informations, consultez Accès à des attributs à l'aide de la réflexion (C# et Visual Basic).

Les attributs peuvent être placés dans la plupart des déclarations (même si un attribut particulier peut restreindre les types de déclaration dans lesquels il est valide). En C#, vous pouvez spécifier un attribut en plaçant son nom entre crochets ([]) au-dessus de la déclaration de l'entité à laquelle il s'applique. En Visual Basic, un attribut est placé entre les signes « inférieur à » et « supérieur à » (< >). Il doit figurer immédiatement avant l'élément auquel il s'applique, sur la même ligne.

Dans cet exemple, l'attribut SerializableAttribute est utilisé pour appliquer une caractéristique spécifique à une classe :


[System.Serializable]
public class SampleClass
{
    // Objects of this type can be serialized.
}


Une méthode utilisant l'attribut DllImportAttribute est déclarée de la manière suivante :


using System.Runtime.InteropServices;


...


[System.Runtime.InteropServices.DllImport("user32.dll")]
extern static void SampleMethod();


Plusieurs attributs peuvent être placés dans une déclaration :


using System.Runtime.InteropServices;


...


void MethodA([In][Out] ref double x) { }
void MethodB([Out][In] ref double x) { }
void MethodC([In, Out] ref double x) { }


Certains attributs peuvent être spécifiés plusieurs fois pour une entité donnée. ConditionalAttribute est un exemple d'attribut à usages multiples :


[Conditional("DEBUG"), Conditional("TEST1")]
void TraceMethod()
{
    // ...
}


Remarque Remarque

Par convention, tous les noms d'attributs se terminent par le mot « Attribute » de façon à les distinguer des autres éléments du .NET Framework. Cependant, vous n'êtes pas obligé de spécifier le suffixe d'attribut lorsque vous employez des attributs dans le code. Par exemple, [DllImport] équivaut à [DllImportAttribute], mais DllImportAttribute est le véritable nom de l'attribut dans le .NET Framework.

z0w1kczw.collapse_all(fr-fr,VS.120).gifParamètres d'attribut

De nombreux attributs sont dotés de paramètres qui peuvent être positionnels, sans nom ou nommés. Les paramètres positionnels doivent être spécifiés dans un certain ordre et ne peuvent pas être omis ; les paramètres nommés sont facultatifs et peuvent être spécifiés dans n'importe quel ordre. Les paramètres positionnels sont spécifiés en premier. Par exemple, ces trois attributs sont équivalents :

[DllImport("user32.dll")]
[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]

Le premier paramètre, le nom de la DLL, est positionnel et se place toujours en premier ; les autres sont nommés. Dans ce cas, les paramètres nommés prennent par défaut la valeur false pour pouvoir être omis. Consultez la documentation des attributs individuels pour plus d'informations sur les valeurs par défaut des paramètres.

z0w1kczw.collapse_all(fr-fr,VS.120).gifCibles d'attribut

La cible d'un attribut est l'entité à laquelle il s'applique. Par exemple, un attribut peut s'appliquer à une classe, une méthode particulière ou un assembly entier. Par défaut, un attribut s'applique à l'élément qu'il précède. Toutefois, vous pouvez aussi identifier la cible de façon explicite en indiquant par exemple si un attribut s'applique à une méthode, à son paramètre ou à sa valeur de retour.

Pour identifier de façon explicite la cible d'un attribut, utilisez la syntaxe suivante :

[target : attribute-list]

La liste de valeurs target possibles est présentée dans le tableau suivant.

C#

Visual Basic

S'applique à

assembly

Assembly

Assembly entier

module

Module

Module d'assembly actuel (qui est différent d'un module Visual Basic)

field

Non pris en charge

Champ dans une classe ou un struct

event

Non pris en charge

Événement

method

Non pris en charge

Méthode ou accesseurs de propriété get et set

param

Non pris en charge

Paramètres de méthode ou paramètres d'accesseur de propriété set

property

Non pris en charge

Property

return

Non pris en charge

Valeur de retour d'une méthode, d'un indexeur de propriété ou d'un accesseur de propriété get

type

Non pris en charge

Struct, class, interface, enum ou delegate

L'exemple suivant indique comment appliquer des attributs aux assemblys et aux modules. Pour plus d’informations, consultez Attributs courants (C# et Visual Basic).


using System;
using System.Reflection;
[assembly: AssemblyTitleAttribute("Production assembly 4")]
[module: CLSCompliant(true)]


L'exemple suivant indique comment appliquer des attributs aux méthodes, ainsi qu'aux paramètres et aux valeurs de retour des méthodes en C#.


// default: applies to method
[SomeAttr]
int Method1() { return 0; }

// applies to method
[method: SomeAttr]
int Method2() { return 0; }

// applies to return value
[return: SomeAttr]
int Method3() { return 0; }


RemarqueRemarque

Indépendamment des cibles sur lesquelles SomeAttr est défini comme valide, la cible return doit être spécifiée, même si SomeAttr a été défini pour s'appliquer uniquement aux valeurs de retour. En d'autres termes, le compilateur n'utilise pas les informations relatives à AttributeUsage pour lever l'ambiguïté des cibles des attributs. Pour plus d’informations, consultez AttributeUsage (C# et Visual Basic).

La liste suivante décrit certaines des utilisations courantes des attributs dans le code :

  • Marquer les méthodes à l'aide de l'attribut WebMethod des services Web pour indiquer qu'elles doivent pouvoir être appelées à l'aide du protocole SOAP. Pour plus d’informations, consultez WebMethodAttribute.

  • Décrire la manière dont il faut marshaler les paramètres de méthode en cas d'interopérabilité avec du code natif Pour plus d’informations, consultez MarshalAsAttribute.

  • Décrire des propriétés COM de classes, méthodes et interfaces

  • Appeler du code non managé à l'aide de la classe DllImportAttribute.

  • Décrire un assembly au moyen d'un titre, d'une version, d'une description ou d'une marque

  • Désigner des membres d'une classe à sérialiser en vue de leur persistance

  • Décrire comment mapper des membres de classe et des nœuds XML dans le cadre de la sérialisation XML

  • Définir les conditions requises en matière de sécurité des méthodes

  • Spécifier les caractéristiques employées pour appliquer la sécurité

  • Contrôler les optimisations à l'aide du compilateur JIT (Just-In-Time) pour que le code demeure facile à déboguer

  • Obtention d'informations sur l'appelant d'une méthode.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft