C# - Attribute

Ein Attribut ist ein deklaratives Tag, das verwendet wird, um Informationen über das Verhalten verschiedener Elemente wie Klassen, Methoden, Strukturen, Enumeratoren, Assemblys usw. in Ihrem Programm an die Laufzeit zu übermitteln. Sie können einem Programm deklarative Informationen hinzufügen, indem Sie ein Attribut verwenden. Ein deklaratives Tag wird durch eckige ([ ]) Klammern dargestellt, die über dem Element stehen, für das es verwendet wird.

Attribute werden zum Hinzufügen von Metadaten wie Compileranweisungen und anderen Informationen wie Kommentaren, Beschreibungen, Methoden und Klassen zu einem Programm verwendet. Das .Net Framework bietet zwei Arten von Attributen:die vordefinierten Attribute und benutzerdefiniert Attribute.

Angeben eines Attributs

Die Syntax zum Angeben eines Attributs lautet wie folgt:−

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

Der Name des Attributs und seine Werte werden in eckigen Klammern vor dem Element angegeben, auf das das Attribut angewendet wird. Positionsparameter spezifizieren die wesentlichen Informationen und die Namensparameter spezifizieren die optionalen Informationen.

Vordefinierte Attribute

Das .Net Framework bietet drei vordefinierte Attribute −

• Attributverwendung
• Bedingt
• Veraltet

Attributverwendung

Das vordefinierte Attribut AttributeUsage beschreibt, wie eine benutzerdefinierte Attributklasse verwendet werden kann. Es gibt die Arten von Elementen an, auf die das Attribut angewendet werden kann.

Die Syntax zur Angabe dieses Attributs lautet wie folgt:−

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

Wo,

• Der Parameter validon gibt die Sprachelemente an, auf denen das Attribut platziert werden kann. Es ist eine Kombination aus dem Wert eines Enumerators AttributeTargets . Der Standardwert ist AttributeTargets.All .

• Der Parameter allowmultiple (optional) stellt den Wert für AllowMultiple bereit Eigenschaft dieses Attributs, ein boolescher Wert. Wenn dies wahr ist, ist das Attribut mehrfach verwendbar. Der Standardwert ist „false“ (Einmalverwendung).

• Der Parameter inherited (optional) liefert den Wert für Inherited Eigenschaft dieses Attributs, ein boolescher Wert. Wenn es wahr ist, wird das Attribut von abgeleiteten Klassen geerbt. Der Standardwert ist false (nicht vererbt).

Zum Beispiel

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

Bedingt

Dieses vordefinierte Attribut markiert eine bedingte Methode, deren Ausführung von einer angegebenen Vorverarbeitungskennung abhängt.

Es bewirkt eine bedingte Kompilierung von Methodenaufrufen, abhängig vom angegebenen Wert wie Debug oder Verfolgen . Zum Beispiel zeigt es die Werte der Variablen beim Debuggen eines Codes an.

Die Syntax zur Angabe dieses Attributs lautet wie folgt:−

[Conditional(
   conditionalSymbol
)]

Zum Beispiel

[Conditional("DEBUG")]

Das folgende Beispiel demonstriert das Attribut −

Live-Demo

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

In Main function
In Function 1
In Function 2

Veraltet

Dieses vordefinierte Attribut markiert eine Programmentität, die nicht verwendet werden sollte. Es ermöglicht Ihnen, den Compiler anzuweisen, ein bestimmtes Zielelement zu verwerfen. Wenn beispielsweise eine neue Methode in einer Klasse verwendet wird und Sie die alte Methode weiterhin in der Klasse beibehalten möchten, können Sie sie als veraltet markieren, indem Sie eine Meldung anzeigen, dass die neue Methode anstelle der alten Methode verwendet werden soll.

Die Syntax zur Angabe dieses Attributs lautet wie folgt:−

[Obsolete (
   message
)]

[Obsolete (
   message,
   iserror
)]

Wo,

• Der Parameter Nachricht , ist eine Zeichenfolge, die den Grund beschreibt, warum das Element veraltet ist, und was stattdessen verwendet werden soll.

• Der Parameter isterror , ist ein boolescher Wert. Wenn sein Wert wahr ist, sollte der Compiler die Verwendung des Elements als Fehler behandeln. Der Standardwert ist falsch (der Compiler generiert eine Warnung).

Das folgende Programm demonstriert dies −

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

Wenn Sie versuchen, das Programm zu kompilieren, gibt der Compiler eine Fehlermeldung aus, die besagt:−

 Don't use OldMethod, use NewMethod instead

Benutzerdefinierte Attribute erstellen

Das .Net Framework ermöglicht die Erstellung benutzerdefinierter Attribute, die zum Speichern deklarativer Informationen verwendet und zur Laufzeit abgerufen werden können. Diese Informationen können je nach Designkriterien und Anwendungsbedarf mit jedem Zielelement in Beziehung gesetzt werden.

Das Erstellen und Verwenden von benutzerdefinierten Attributen umfasst vier Schritte −

• Ein benutzerdefiniertes Attribut deklarieren
• Konstruieren des benutzerdefinierten Attributs
• Wenden Sie das benutzerdefinierte Attribut auf ein Zielprogrammelement an
• Zugriff auf Attribute durch Reflektion

Der letzte Schritt beinhaltet das Schreiben eines einfachen Programms zum Durchlesen der Metadaten, um verschiedene Notationen zu finden. Metadaten sind Daten über Daten oder Informationen, die zur Beschreibung anderer Daten verwendet werden. Dieses Programm sollte Reflexionen für den Zugriff auf Attribute zur Laufzeit verwenden. Dies werden wir im nächsten Kapitel besprechen.

Ein benutzerdefiniertes Attribut deklarieren

Ein neues benutzerdefiniertes Attribut sollte von System.Attribute abgeleitet werden Klasse. Zum Beispiel

//a custom attribute BugFix to be assigned to a class and its members
[AttributeUsage(
   AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

public class DeBugInfo : System.Attribute

Im vorhergehenden Code haben wir ein benutzerdefiniertes Attribut namens DeBugInfo deklariert .

Erstellen des benutzerdefinierten Attributs

Lassen Sie uns ein benutzerdefiniertes Attribut namens DeBugInfo erstellen , das die Informationen speichert, die durch das Debuggen eines beliebigen Programms erhalten wurden. Lassen Sie es die folgenden Informationen speichern −

• Die Codenummer für den Fehler
• Name des Entwicklers, der den Fehler identifiziert hat
• Datum der letzten Überprüfung des Kodex
• Eine String-Nachricht zum Speichern der Anmerkungen des Entwicklers

Die DeBugInfo Die Klasse hat drei private Eigenschaften zum Speichern der ersten drei Informationen und eine öffentliche Eigenschaft zum Speichern der Nachricht. Daher sind die Fehlernummer, der Name des Entwicklers und das Überprüfungsdatum die Positionsparameter der DeBugInfo-Klasse und die Nachricht ist ein optionaler oder benannter Parameter.

Jedes Attribut muss mindestens einen Konstruktor haben. Die Positionsparameter sollten durch den Konstruktor übergeben werden. Der folgende Code zeigt die DeBugInfo Klasse −

//a custom attribute BugFix to be assigned to a class and its members
[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;
      }
   }
}

Anwenden des benutzerdefinierten Attributs

Das Attribut wird angewendet, indem es unmittelbar vor seinem Ziel platziert wird −

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle {
   //member variables
   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());
   }
}

Im nächsten Kapitel rufen wir Attributinformationen mit einem Reflection-Klassenobjekt ab.