C#-attributen onder de knie: code verrijken met metadata

Een attribuut is een declaratieve tag die informatie aan de runtime doorgeeft over het gedrag van verschillende elementen zoals klassen, methoden, structuren, enumeraties, assemblies, enzovoort in uw programma. U kunt declaratieve informatie toevoegen aan een programma door een attribuut te gebruiken. Een declaratieve tag wordt weergegeven door vierkante haken ([ ]) die boven het element worden geplaatst waarvoor het wordt gebruikt.

Attributen worden gebruikt voor het toevoegen van metadata, zoals compilerinstructies en andere informatie zoals opmerkingen, beschrijvingen, methoden en klassen aan een programma. Het .NET Framework biedt twee typen attributen: vooraf gedefinieerde attributen en aangepaste attributen.

Een attribuut specificeren

De syntaxis voor het specificeren van een attribuut is als volgt:

[attribuut(positionele_parameters, naam_parameter = waarde, ...)] element

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

Vooraf gedefinieerde attributen

Het .NET Framework biedt drie vooraf gedefinieerde attributen:

• AttributeUsage
• Conditional
• Obsolete

AttributeUsage

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

Syntaxis voor dit attribuut:

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

Waarbij:

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

• De parameter allowmultiple (optioneel) geeft de waarde voor de AllowMultiple-eigenschap van dit attribuut, een Booleaanse waarde. Als deze true is, is het attribuut meervoudig gebruikelijk. De standaardwaarde is false (enkelvoudig gebruik).

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

Bijvoorbeeld:

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

Conditional

Dit vooraf gedefinieerde attribuut markeert een voorwaardelijke methode wiens uitvoering afhangt van een gespecificeerde preprocessor-identifier.

Het zorgt voor voorwaardelijke compilatie van methodeaanroepen, afhankelijk van de gespecificeerde waarde zoals Debug of Trace. Bijvoorbeeld: het toont de waarden van variabelen tijdens het debuggen van code.

Syntaxis:

[Conditional(conditioneleSymbool)]

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, produceert het het volgende resultaat:

In Main function
In Function 1
In Function 2

Obsolete

Dit vooraf gedefinieerde attribuut markeert een programmeerentiteit die niet meer gebruikt moet worden. Het stelt u in staat de compiler te informeren om een bepaald doelelement te negeren. Bijvoorbeeld: wanneer een nieuwe methode in een klasse wordt gebruikt en u de oude methode nog wilt behouden, kunt u deze als verouderd markeren met een bericht dat de nieuwe methode gebruikt moet worden.

Syntaxis:

[Obsolete(bericht)]
[Obsolete(bericht, iserror)]

Waarbij:

• De parameter bericht is een tekenreeks die de reden beschrijft waarom het item verouderd is en wat er 대신 gebruikt moet worden.

• De parameter iserror is een Booleaanse waarde. Als de waarde true is, behandelt de compiler het gebruik van het item als een fout. De standaardwaarde is false (de compiler genereert een waarschuwing).

Het volgende programma demonstreert dit:

using System;

public class MyClass {
    [Obsolete("Gebruik niet OldMethod, gebruik NewMethod in plaats daarvan", true)]
    static void OldMethod() {
        Console.WriteLine("Het is de oude methode");
    }
    static void NewMethod() {
        Console.WriteLine("Het is de nieuwe methode");
    }
    public static void Main() {
        OldMethod();
    }
}

Wanneer u probeert het programma te compileren, geeft de compiler een foutmelding:

Gebruik niet OldMethod, gebruik NewMethod in plaats daarvan

Aangepaste attributen maken

Het .NET Framework stelt het maken van aangepaste attributen toe die gebruikt kunnen worden om declaratieve informatie op te slaan en tijdens runtime op te halen. Deze informatie kan betrekking hebben op elk doelelement, afhankelijk van de ontwerpcriteria en toepassingsbehoefte.

Het maken en gebruiken van aangepaste attributen omvat vier stappen:

• Een aangepast attribuut declareren
• Het aangepaste attribuut construeren
• Het aangepaste attribuut toepassen op een doelprogramma-element
• Attributen benaderen via Reflectie

De laatste stap omvat het schrijven van een eenvoudig programma dat de metadata uitleest om diverse aantekeningen te vinden. Metadata zijn data over data of informatie die gebruikt wordt om andere data te beschrijven. Dit programma moet reflectie gebruiken voor het benaderen van attributen tijdens runtime. Dit bespreken we in het volgende hoofdstuk.

Een aangepast attribuut declareren

Een nieuw aangepast attribuut moet afgeleid worden van de System.Attribute-klasse. Bijvoorbeeld:

// een aangepast attribuut BugFix dat aan een klasse en zijn leden toegewezen kan worden
[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 attribuut genaamd DeBugInfo gedeclareerd.

Het aangepaste attribuut construeren

Laten we een aangepast attribuut genaamd DeBugInfo construeren, dat de informatie opslaat die verkregen wordt door het debuggen van een programma. Laat het de volgende informatie opslaan:

• Het codenummer voor de bug
• Naam van de ontwikkelaar die de bug heeft geïdentificeerd
• Datum van de laatste codereview
• Een tekenreeksbericht voor de opmerkingen van de ontwikkelaar

De DeBugInfo-klasse heeft drie private eigenschappen voor de eerste drie informatiestukken en een publieke eigenschap voor het bericht. Het bugnummer, de naam van de ontwikkelaar en de datum van de review zijn dus de positionele parameters van de DeBugInfo-klasse en het bericht is een optionele of benoemde parameter.

Elk attribuut moet minstens één constructor hebben. De positionele parameters moeten via de constructor worden doorgegeven. De volgende code toont de DeBugInfo-klasse:

// een aangepast attribuut BugFix dat aan een klasse en zijn leden toegewezen kan worden
[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 attribuut toepassen

Het attribuut wordt toegepast door het direct vóór het 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 {
    // lidvariabelen
    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 Reflection-klasseobject.