[Tutoriel c#] Attributs C# (Attribut)

Attribut C#

L'attribut est une méthode déclarative utilisée pour transférer des informations comportementales de divers éléments du programme (tels que des classes, des méthodes, des structures, des énumérations, des composants, etc.) au moment de l'exécution de l'étiquette. Vous pouvez ajouter des informations déclaratives à votre programme à l'aide d'attributs. Une balise déclarative est décrite par des crochets ([ ]) placés devant l'élément auquel elle s'applique.

L'attribut est utilisé pour ajouter des métadonnées, telles que des directives et des commentaires du compilateur, des descriptions, des méthodes, des classes et d'autres informations. Le framework .Net fournit deux types d'attributs : les attributs prédéfinis et les attributs personnalisés.

Spécifie un attribut (Attribut)

La syntaxe pour spécifier un attribut (Attribut) est la suivante :

[attribute(positional_parameters, name_parameter = value, ...)]
element

Le nom et la valeur d'un attribut (Attribut) sont spécifiés entre crochets, placés avant l'élément auquel ils sont appliqués. positional_parameters spécifie les informations requises, name_parameter spécifie les informations facultatives.

Attributs prédéfinis (Attribut)

.Le framework .Net fournit trois attributs prédéfinis :

AttributeUsage

Conditionnel

Obsolète

AttributeUsage

L'attribut prédéfini AttributeUsage décrit comment utiliser une classe d'attribut personnalisée. Il spécifie les types d'éléments auxquels la fonctionnalité peut être appliquée.

La syntaxe pour spécifier cet attribut est la suivante :

[AttributeUsage(
   validon,
   AllowMultiple=allowmultiple,
   Inherited=inherited
)]

Où :

Le paramètre validon précise l'élément de langage dans lequel l'attribut peut être placé. Il s'agit d'une combinaison des valeurs de l'énumérateur AttributeTargets. La valeur par défaut est AttributeTargets.All.

Le paramètreallowmultiple (facultatif) fournit une valeur booléenne pour la propriété AllowMultiple de la fonctionnalité. Si c'est vrai, l'attribut est polyvalent. La valeur par défaut est false (à usage unique).

Le paramètre hérité (facultatif) fournit une valeur booléenne pour la propriété Inherited de cette fonctionnalité. Si vrai, cet attribut peut être hérité par les classes dérivées. La valeur par défaut est false (non héritée).

Par exemple :

[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Feild |
AttributeTargets.Method |
AttributeTargets.Property, 
AllowMultiple = true)]

Conditionnel

Cet attribut prédéfini marque une méthode conditionnelle dont l'exécution dépend de l'identifiant du préprocesseur qu'elle surmonte.

Il provoque une compilation conditionnelle des appels de méthode, en fonction de la valeur spécifiée, comme Debug ou Trace. Par exemple, affichez la valeur d'une variable lors du débogage du code.

La syntaxe pour spécifier cette fonctionnalité est la suivante :

[Conditional(
   conditionalSymbol
)]

Par exemple :

[Conditional("DEBUG")]

L'exemple suivant illustre cette fonctionnalité :

#define DEBUG
using System;
using System.Diagnostics;
public class Myclass
{
    [Conditional("DEBUG")]
    public static void Message(string msg)
    {
        Console.WriteLine(msg);
    }
}
class Test
{
    static void function1()
    {
        Myclass.Message("In Function 1.");
        function2();
    }
    static void function2()
    {
        Myclass.Message("In Function 2.");
    }
    public static void Main()
    {
        Myclass.Message("In Main function.");
        function1();
        Console.ReadKey();
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

In Main function
In Function 1
In Function 2

Obsolète

Cet attribut prédéfini marque les entités du programme qui ne doivent pas être utilisées. Il vous permet de demander au compilateur de supprimer un élément cible spécifique. Par exemple, lorsqu'une nouvelle méthode est utilisée dans une classe, mais que vous souhaitez conserver l'ancienne méthode dans la classe, vous pouvez la marquer comme obsolète en affichant un message indiquant que la nouvelle méthode doit être utilisée à la place de l'ancienne méthode. ).

La syntaxe pour spécifier cette fonctionnalité est la suivante :

[Obsolete(
   message
)]
[Obsolete(
   message,
   iserror
)]

Où :

Le paramètre message, est une chaîne décrivant pourquoi le projet est obsolète et quoi utiliser plutôt.

Le paramètre iserror est une valeur booléenne. Si cette valeur est vraie, le compilateur doit traiter l'utilisation de cet élément comme une erreur. La valeur par défaut est false (le compilateur génère un avertissement).

L'exemple suivant illustre cette fonctionnalité :

using System;
public class MyClass
{
   [Obsolete("Don't use OldMethod, use NewMethod instead", true)]
   static void OldMethod()
   { 
      Console.WriteLine("It is the old method");
   }
   static void NewMethod()
   { 
      Console.WriteLine("It is the new method"); 
   }
   public static void Main()
   {
      OldMethod();
   }
}

Lorsque vous essayez de compiler ce programme, le compilateur affichera un message d'erreur indiquant :

 Don't use OldMethod, use NewMethod instead

Créer un programme personnalisé attributs (Attribut)

Le framework .Net permet la création d'attributs personnalisés qui stockent des informations déclaratives pouvant être récupérées au moment de l'exécution. Ces informations peuvent être associées à n'importe quel élément cible en fonction des critères de conception et des besoins de l'application.

创建并使用自定义特性包含四个步骤：

声明自定义特性

构建自定义特性

在目标程序元素上应用自定义特性

通过反射访问特性

最后一个步骤包含编写一个简单的程序来读取元数据以便查找各种符号。元数据是用于描述其他数据的数据和信息。该程序应使用反射来在运行时访问特性。我们将在下一章详细讨论这点。

声明自定义特性

一个新的自定义特性应派生自 System.Attribute 类。例如：

// 一个自定义特性 BugFix 被赋给类及其成员
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute

在上面的代码中，我们已经声明了一个名为 DeBugInfo 的自定义特性。

构建自定义特性

让我们构建一个名为 DeBugInfo 的自定义特性，该特性将存储调试程序获得的信息。它存储下面的信息：

bug 的代码编号

辨认该 bug 的开发人员名字

最后一次审查该代码的日期

一个存储了开发人员标记的字符串消息

我们的 DeBugInfo 类将带有三个用于存储前三个信息的私有属性（property）和一个用于存储消息的公有属性（property）。所以 bug 编号、开发人员名字和审查日期将是 DeBugInfo 类的必需的定位（ positional）参数，消息将是一个可选的命名（named）参数。

每个特性必须至少有一个构造函数。必需的定位（ positional）参数应通过构造函数传递。下面的代码演示了 DeBugInfo 类：

// 一个自定义特性 BugFix 被赋给类及其成员
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute
{
  private int bugNo;
  private string developer;
  private string lastReview;
  public string message;

  public DeBugInfo(int bg, string dev, string d)
  {
      this.bugNo = bg;
      this.developer = dev;
      this.lastReview = d;
  }

  public int BugNo
  {
      get
      {
          return bugNo;
      }
  }
  public string Developer
  {
      get
      {
          return developer;
      }
  }
  public string LastReview
  {
      get
      {
          return lastReview;
      }
  }
  public string Message
  {
      get
      {
          return message;
      }
      set
      {
          message = value;
      }
  }
}

应用自定义特性

通过把特性放置在紧接着它的目标之前，来应用该特性：

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle
{
  // 成员变量
  protected double length;
  protected double width;
  public Rectangle(double l, double w)
  {
      length = l;
      width = w;
  }
  [DeBugInfo(55, "Zara Ali", "19/10/2012",
  Message = "Return type mismatch")]
  public double GetArea()
  {
      return length * width;
  }
  [DeBugInfo(56, "Zara Ali", "19/10/2012")]
  public void Display()
  {
      Console.WriteLine("Length: {0}", length);
      Console.WriteLine("Width: {0}", width);
      Console.WriteLine("Area: {0}", GetArea());
  }
}

 以上就是【c#教程】C# 特性（Attribute）的内容，更多相关内容请关注PHP中文网（www.php.cn）！