Caractéristiques (Attribute) C#

指定特性(Attribute)

指定特性(Attribute)的语法如下：

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

特性(Attribute)的名称和值是在方括号内指定的，放置在它所应用的元素之前。positional_parameters 指定必需的信息，name_parameter 指定可选的信息。

预定义特性(Attribute)

.Net 框架提供了三种预定义特性：

• AttributeUsage

• L'attribut (property) fournit une valeur booléenne. Si elle est true, cette caractéristique peut être héritée par les classes dérivées. La valeur par défaut est false (non héritée).

• Obsolete

AttributeUsage

预定义特性 AttributeUsage 描述了如何使用一个自定义特性类。它指定了特性可应用到的项目的类型。

La syntaxe de cette caractéristique prédéfinie est la suivante :

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

où :

• 参数 validon 指定特性可放置的语言元素。它是枚举器 AttributeTargets 的组合的值。默认值是 AttributeTargets.All。

• paramètre 。hérité allowmultiple AllowMultiple

• paramètre fournit une valeur booléenne. Si elle est true, cette caractéristique est réutilisable. La valeur par défaut est false (non réutilisable).hérité (optionnel) L'attribut (property) Hérité

Par exemple :

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

L'attribut (property) fournit une valeur booléenne. Si elle est true, cette caractéristique peut être héritée par les classes dérivées. La valeur par défaut est false (non héritée).

Conditional

Cette caractéristique prédéfinie indique une méthode conditionnelle dont l'exécution dépend de l'identificateur de préprocesseur spécifié. Il provoque la compilation conditionnelle des appels de méthode, en fonction de la valeur spécifiée, par exemple Debug ou. Par exemple, afficher la valeur des variables pendant le débogage du code.

La syntaxe de cette caractéristique prédéfinie est la suivante :

[Conditional(
　　　symbolConditionnel
)]

Par exemple :

[Conditional("DEBUG")]

下面的示例演示了该特性：

#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("Dans la fonction　1.
　　　　　　　　function2();
　　　　}
　　　　static void function2());
　　　　{
　　　　　　　　Myclass.Message("Dans la fonction　2.
　　　　}
　　　　public　static　void　Main()
　　　　{
　　　　　　　　Myclass.Message("Dans la fonction principale.");
　　　　　　　　function1();
　　　　　　　　Console.ReadKey();
　　　　}
}

Lorsque le code ci-dessus est compilé et exécuté, il génère les résultats suivants :

Dans la fonction principale
Dans la fonction　1
Dans la fonction　2

Obsolete

Cette caractéristique prédéfinie indique que l'entité du programme ne doit pas être utilisée. Elle permet de signaler au compilateur de ne pas utiliser un élément cible spécifique. Par exemple, lorsqu'une nouvelle méthode est utilisée dans une classe, mais que vous souhaitez toujours conserver l'ancienne méthode de la classe, vous pouvez la marquer comme obsolète (désuète) en affichant un message indiquant qu'il faut utiliser la nouvelle méthode plutôt que l'ancienne.

La syntaxe de cette caractéristique prédéfinie est la suivante :

[Obsolète(
　　　message
)]
[Obsolète(
　　　message,
　　　iserror
)]

où :

• paramètre messagec'est une chaîne de caractères qui décrit pourquoi l'élément est obsolète et ce qui doit être utilisé à la place.

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

下面的示例演示了该特性：

using　System;
public　class　MyClass
{
　　　[Obsolete("Ne pas utiliser OldMethod, utiliser NewMethod à la place", true)]
　　　static　void　OldMethod()
　　　{　
　　　　　　Console.WriteLine("C'est l'ancienne méthode");
　　　}
　　　static　void　NewMethod()
　　　{　
　　　　　　Console.WriteLine("C'est la nouvelle méthode");　
　　　}
　　　public　static　void　Main()
　　　{
　　　　　　OldMethod();
　　　}
}

当您尝试编译该程序时，编译器会给出一个错误消息说明：

　Ne pas utiliser OldMethod, utiliser NewMethod à la place

创建自定义特性(Attribute)

.Net 框架允许创建自定义特性，用于存储声明性的信息，且可在运行时被检索。该信息根据设计标准和应用程序需要，可与任何目标元素相关。

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

• 声明自定义特性

• 构建自定义特性

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

• 通过反射访问特性

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

声明自定义特性

一个新的自定义特性应派生自 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("Longueur:　{0}",　length);
　　　　　　Console.WriteLine("Largeur:　{0}",　width);
　　　　　　Console.WriteLine("Surface:　{0}",　GetArea());
　　}
}

Dans le prochain chapitre, nous utiliserons l'objet de la classe Reflection pour récupérer ces informations.