C# Grundlagenanleitung

C# Fortgeschrittene Anleitung

C# Objektorientiert(OOP)

C#-Reflexion（Reflection）C#-Reguläre Ausdrücke

C#-Attribut（Attribute）

Eigenschaft(Attribute)Sind deklarative Markierungen, die zur Übermittlung von Verhaltensinformationen verschiedener Elemente im Programm (z.B. Klassen, Methoden, Strukturen, Enumerations, Komponenten usw.) bei der Laufzeit verwendet werden. Sie können durch Platzierung von eckigen Klammern ([ ]), die vor dem angewendeten Element stehen, beschrieben werden.

Die Eigenschaft(Attribute) wird verwendet, um Metadaten wie Compileranweisungen und Kommentare, Beschreibungen, Methoden, Klassen und andere Informationen hinzuzufügen. Das .Net-Framework bietet zwei Arten von Eigenschaften an:VorgegebeneEigenschaften undBenutzerdefiniertEigenschaft.

Eigenschaft(Attribute)

Die Syntax zur Angabe der Eigenschaft(Attribute) ist wie folgt:

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

Der Name und der Wert der Eigenschaft(Attribute) werden in eckigen Klammern angegeben und vor dem angewendeten Element platziert. positional_parameters gibt erforderliche Informationen an, name_parameter gibt optionale Informationen an.

Vorgegebene Eigenschaften(Attribute)

.Net-Framework bietet drei vorgegebene Eigenschaften an:

AttributeUsage
Bedingtes
Veraltet

AttributeUsage

Vorgegebene Eigenschaften AttributeUsage Beschreibt, wie eine benutzerdefinierte Eigenschaftsklasse verwendet wird. Es wird der Typ der Projekte angegeben, auf die die Eigenschaft angewendet werden kann.

Die Syntax für diese Eigenschaft ist wie folgt:

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

davon:

Der Parameter validon gibt an, auf welche Sprachelemente die Eigenschaft angewendet werden kann. Es ist ein Enumerator AttributeTargets Wertekombinationen. Standardwert ist AttributeTargets.All。
Parameter allowmultiple(Optional) Das Attribut (property) AllowMultiple bietet einen Boolean-Wert. Wenn true, ist die Eigenschaft mehrfach verwendbar. Der Standardwert ist false (nicht mehrfach verwendbar).
Parameter geerbt(Optional) Das Attribut (property) Geerbt Das Attribut (property) bietet einen Boolean-Wert. Wenn true, kann diese Eigenschaft von Ableitungen geerbt werden. Der Standardwert ist false (wird nicht geerbt).

Zum Beispiel:

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

Bedingtes

Diese vorgegebene Eigenschaft kennzeichnet eine bedingte Methode, deren Ausführung von einem bestimmten Präprozessor-Bezeichner abhängt.

es verursacht die bedingte Kompilierung von Methodenaufrufen, abhängig vom angegebenen Wert, zum Beispiel Debug oder Verfolgen. Zum Beispiel, um den Wert einer Variable während der Debugging-Phase anzuzeigen.

Die Syntax für diese Eigenschaft ist wie folgt:

[Bedingtes(
　　　bedingtesSymbol
)]

Zum Beispiel:

[Bedingtes("DEBUG")]

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

示例

#define DEBUG
using　System;
using System.Diagnostics;
public class Myclass
{
　　　　[Bedingtes("DEBUG")]
　　　　public static void Message(string msg)
　　　　{
　　　　　　　　Console.WriteLine(msg);
　　　　}
}
Klasse Test
{
　　　　1()
　　　　{
　　　　　　　　Myclass.Message("In Funktion　1.
　　　　　　　　Funktion2();
　　　　}
　　　　2()
　　　　{
　　　　　　　　Myclass.Message("In Funktion　2.
　　　　}
　　　　public　static　void　Main()
　　　　{
　　　　　　　　Myclass.Message("In Hauptfunktion.");
　　　　　　　　Funktion1();
　　　　　　　　Console.ReadKey();
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

In Hauptfunktion
In Funktion　1
In Funktion　2

Veraltet

Diese vorgegebene Eigenschaft kennzeichnet Programmobjekte, die nicht verwendet werden sollten. Sie ermöglicht es Ihnen, dem Compiler mitzuteilen, dass ein bestimmtes Zielobjekt weggelassen werden soll. Zum Beispiel, wenn eine neue Methode in einer Klasse verwendet wird, aber Sie dennoch die alte Methode in der Klasse beibehalten möchten, können Sie dies durch eine Meldung, dass die neue Methode verwendet werden sollte, anstatt der alten, als veraltet markieren.

Die Syntax für diese Eigenschaft ist wie folgt:

[Veraltet(
　　　message
)]
[Veraltet(
　　　message,
　　　iserror
)]

davon:

Parameter message，ist ein String, der beschreibt, warum das Projekt veraltet ist und was stattdessen verwendet werden sollte.
Parameter iserror，ist ein Boolean-Wert. Wenn dieser Wert true ist, sollte der Compiler die Verwendung dieses Elements als Fehler behandeln. Der Standardwert ist false (der Compiler generiert eine Warnung).

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

示例

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();
　　　}
}

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

　Don't　use　OldMethod,　use　NewMethod　instead

创建自定义特性(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("Länge:　{0}",　length);
　　　　　　Console.WriteLine("Breite:　{0}",　width);
　　　　　　Console.WriteLine("Fläche:　{0}",　GetArea());
　　}
}

Im nächsten Kapitel werden wir die Reflection-Klasse verwenden, um diese Informationen abzurufen.

C#-Reflexion（Reflection）C#-Reguläre Ausdrücke