C# - Kenmerken

Een kenmerk is een declaratieve tag die wordt gebruikt om informatie naar runtime over te brengen over het gedrag van verschillende elementen zoals klassen, methoden, structuren, enumerators, assemblages enz. in uw programma. U kunt declaratieve informatie aan een programma toevoegen door een attribuut te gebruiken. Een declaratieve tag wordt weergegeven door vierkante ([ ]) haakjes die boven het element worden geplaatst waarvoor het wordt gebruikt.

Attributen worden gebruikt voor het toevoegen van metadata, zoals compilerinstructie en andere informatie zoals commentaar, beschrijving, methoden en klassen aan een programma. Het .Net Framework biedt twee soorten attributen:de vooraf gedefinieerde attributen en op maat gemaakte attributen.

Een kenmerk specificeren

Syntaxis voor het specificeren van een attribuut is als volgt −

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

De naam van het attribuut en zijn waarden worden gespecificeerd tussen vierkante haken, vóór het element waarop het attribuut wordt toegepast. Positionele parameters specificeren de essentiële informatie en de naamparameters specificeren de optionele informatie.

Vooraf gedefinieerde attributen

Het .Net Framework biedt drie vooraf gedefinieerde attributen −

• KenmerkGebruik
• Voorwaardelijk
• Verouderd

KenmerkGebruik

Het vooraf gedefinieerde attribuut AttributeUsage beschrijft hoe een aangepaste attribuutklasse kan worden gebruikt. Het specificeert de typen items waarop het attribuut kan worden toegepast.

Syntaxis voor het specificeren van dit kenmerk is als volgt −

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

Waar,

• De parameter validon specificeert de taalelementen waarop het attribuut geplaatst kan worden. Het is een combinatie van de waarde van een enumerator AttributeTargets . De standaardwaarde is AttributeTargets.All .

• De parameter allowmultiple (optioneel) geeft waarde voor de AllowMultiple eigenschap van dit attribuut, een Booleaanse waarde. Als dit waar is, is het kenmerk multifunctioneel. De standaardwaarde is false (eenmalig gebruik).

• De parameter geërfd (optioneel) geeft waarde voor de Inherited eigenschap van dit attribuut, een Booleaanse waarde. Als het waar is, wordt het attribuut overgenomen door afgeleide klassen. De standaardwaarde is false (niet overgenomen).

Bijvoorbeeld,

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

Voorwaardelijk

Dit vooraf gedefinieerde attribuut markeert een voorwaardelijke methode waarvan de uitvoering afhangt van een gespecificeerde voorverwerkings-ID.

Het veroorzaakt voorwaardelijke compilatie van methodeaanroepen, afhankelijk van de opgegeven waarde, zoals Debug of Traceren . Het toont bijvoorbeeld de waarden van de variabelen tijdens het debuggen van een code.

Syntaxis voor het specificeren van dit kenmerk is als volgt −

[Conditional(
   conditionalSymbol
)]

Bijvoorbeeld,

[Conditional("DEBUG")]

Het volgende voorbeeld demonstreert het attribuut −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

In Main function
In Function 1
In Function 2

Verouderd

Dit vooraf gedefinieerde attribuut markeert een programma-entiteit die niet mag worden gebruikt. Het stelt u in staat om de compiler te informeren om een ​​bepaald doelelement te verwijderen. Als er bijvoorbeeld een nieuwe methode in een klasse wordt gebruikt en je wilt nog steeds de oude methode in de klasse behouden, kun je deze als verouderd markeren door een bericht weer te geven dat de nieuwe methode moet worden gebruikt in plaats van de oude methode.

Syntaxis voor het specificeren van dit kenmerk is als volgt −

[Obsolete (
   message
)]

[Obsolete (
   message,
   iserror
)]

Waar,

• De parameter bericht , is een tekenreeks die de reden beschrijft waarom het item verouderd is en wat in plaats daarvan moet worden gebruikt.

• De parameter iserror , is een Booleaanse waarde. Als de waarde waar is, moet de compiler het gebruik van het item als een fout beschouwen. Standaardwaarde is false (compiler genereert een waarschuwing).

Het volgende programma demonstreert dit −

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

Wanneer u het programma probeert te compileren, geeft de compiler een foutmelding met de melding −

 Don't use OldMethod, use NewMethod instead

Aangepaste kenmerken maken

Met het .Net Framework kunnen aangepaste kenmerken worden gemaakt die kunnen worden gebruikt om declaratieve informatie op te slaan en die tijdens runtime kunnen worden opgehaald. Deze informatie kan worden gerelateerd aan elk doelelement, afhankelijk van de ontwerpcriteria en de toepassingsbehoefte.

Het maken en gebruiken van aangepaste kenmerken omvat vier stappen −

• Een aangepast kenmerk declareren
• Het aangepaste kenmerk maken
• Pas het aangepaste kenmerk toe op een doelprogramma-element
• Toegang tot attributen door reflectie

De laatste stap omvat het schrijven van een eenvoudig programma om de metadata te lezen om verschillende notaties te vinden. Metadata zijn gegevens over gegevens of informatie die worden gebruikt om andere gegevens te beschrijven. Dit programma zou reflecties moeten gebruiken voor toegang tot attributen tijdens runtime. Dit zullen we in het volgende hoofdstuk bespreken.

Een aangepast kenmerk declareren

Een nieuw aangepast kenmerk zou moeten worden afgeleid van het System.Attribute klas. Bijvoorbeeld,

//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

In de voorgaande code hebben we een aangepast kenmerk gedeclareerd met de naam DeBugInfo .

Het aangepaste kenmerk construeren

Laten we een aangepast kenmerk maken met de naam DeBugInfo , die de informatie opslaat die is verkregen door een programma te debuggen. Laat het de volgende informatie opslaan −

• Het codenummer voor de bug
• Naam van de ontwikkelaar die de bug heeft geïdentificeerd
• Datum van laatste herziening van de code
• Een stringbericht voor het opslaan van de opmerkingen van de ontwikkelaar

De DeBugInfo class heeft drie privé-eigenschappen voor het opslaan van de eerste drie informatie en een openbare eigenschap voor het opslaan van het bericht. Daarom zijn het bugnummer, de naam van de ontwikkelaar en de beoordelingsdatum de positionele parameters van de DeBugInfo-klasse en is het bericht een optionele of benoemde parameter.

Elk attribuut moet ten minste één constructor hebben. De positionele parameters moeten door de constructor worden doorgegeven. De volgende code toont de 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;
      }
   }
}

Het aangepaste kenmerk toepassen

Het attribuut wordt toegepast door het direct voor zijn doel te plaatsen −

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

In het volgende hoofdstuk halen we attribuutinformatie op met behulp van een klasseobject Reflection.