Attributes in .NET

Door Flard op woensdag 2 januari 2008 13:37 - Reacties (1)
Categorie: .NET, Views: 5.445

Op mijn werk werken we hoofdzakelijk met het implementeren Microsoft Dynamics NAV (Navision) bij klanten. Aangezien de toekomst van Dynamics er heel erg ‘.NET’ uitziet, ben ik aangenomen om eens langzaam wat voortrajecten en –projecten te doen om wat meer ‘feeling’ te krijgen voor .NET binnen het bedrijf. Inmiddels zijn er ook al wat collega’s bezig met .NET, en ik zal proberen hier wat dingen verder uit te leggen die voor niet .NET-programmeurs wellicht wat moeilijk te begrijpen zijn.
In een deeltje of vier wil ik tot een simpele plugin-engine komen, en daarbij alle stappen zo ver mogelijk uitleggen. De eerste stap die ik daarbij graag uitleg zijn Attributes. Een .NET-techniek om metadata toe te voegen aan je klassen.

Wat zijn Attributes?
Zoals iedere help/tutorial zal zeggen zijn het ‘metadata’. Maar goed, wat zijn metadata dan? metadata zijn een soort notities die je kunt toevoegen aan de verschillende entiteiten van .NET. Zo kun je deze ‘notities’ toevoegen aan een assembly, een class, een property, enz…
Niet duidelijk? Een voorbeeld dan maar.
Waarschijnlijk heb je het AssemblyInfo.cs bestand wel eens gezien. Deze ziet er ongeveer als volgt uit:

C#:
1
2
3
4
5
6
7
8
9
10
..
\[assembly: AssemblyTitle("Projectnaam")]
\[assembly: AssemblyDescription("")]
\[assembly: AssemblyConfiguration("")]
\[assembly: AssemblyCompany("Bedrijfsnaam")]
\[assembly: AssemblyProduct("")]
\[assembly: AssemblyCopyright("Copyright © Bedrijfsnaam 2008")]
\[assembly: AssemblyTrademark("")]
\[assembly: AssemblyCulture("")]
...


Al deze regels zijn attributen!
Zo wordt op de eerste regel het AssemblyTitle-attribuut toegekend aan de assembly, met de waarde "Projectnaam". In dit geval wordt dit attribuut door de compiler opgepakt, en toegevoegd aan de bestandsinformatie, en kun je dit zien als je de eigenschappen van het uitvoerbestand bekijkt in de Windows Verkenner.

Andere attributen die je misschien wel eens hebt gezien zijn [Serializable] of [ComVisible], die beiden aan een klasse kunnen worden toegevoegd. Die respectievelijk aangeven dat een object met serialiseerbaar is of zichtbaar zijn binnen COM.

Kort samengevat: Attributen zijn (read-only) markeringen die je op ontwerpniveau toevoegd aan een klasse.

Hoe gebruik je attributen?
Eigenlijk heb ik het in het vorige hoofdstuk al verklapt, maar door middel van de blokhaken ([ en ]) ken je een attribuut toe aan een .NET entititeit.
Attributen zijn dus toe te voegen aan assemblies, klassen, fields, properties en methoden, al zijn niet alle attributen overal op toe te passen. Zo is een AssemblyTitle alleen toe te passen op een assembly. Hierover straks nog meer.

Een voorbeeld:

C#:
1
2
3
4
\[Plugin("Test Plugin", "Voorbeeld")]
public class Plugin
{
}



Zoals je ook in het bovenstaande voorbeeld ziet kun je ook parameters toevoegen aan een attribuut. In principe roep je gewoon de constructor van het attribuut aan, attributen zelf zijn immers ook gewoon klassen.

Het is ook mogelijk om properties van het attribuut te zetten, als dit niet mogelijk is volgens de constructor-definitie. Dit zijn de zogenaamde Named Parameters.
Stel dat je bijvoorbeeld een 'optionele' property Version hebt, dan kun je deze als volgt toepassen:

C#:
1
\[Plugin("Test Plugin", "Voorbeeld", Version="1.0")]



Hoe maak je Attributes
Ook dat is eigenlijk vrij eenvoudig. Stel, je wilt een Plugin-attribute, dan maak je een nieuwe class met de naam PluginAttribute, die erft van de Attribute klasse.

Het 'Attribute' achter de naam van je plugin is overigens niet verplicht, maar het wordt wel voorgeschreven volgens de MSDN Naming Conventions, en je zult erachter komen dat je zo niet zo snel in de war komt met klassen. (Zie bijvoorbeeld mijn bovenstaande voorbeeld, waar ik een klasse Plugin heb, en een PluginAttribute).
Het is dus bij het toekennen van attributen ook niet verplicht dit 'Attribute' nog eens te typen.

Daarnaast wordt het sterk aanbevolen het AttributeUsageAttribute toe te kennen aan de klasse-definitie. Met dit attribuut kun je aangeven op welke entiteiten het attribuut mag worden toegepast, kun je optioneel aangeven of het attribuut geŽrft mag worden.

Om bij het voorbeeld van ons Plugin-attribuut te blijven:

C#:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
\[AttributeUsage(AttributeTargets.Class)]
public class PluginAttribute : Attribute
{
    string name;
    string description;
    string version;

    public PluginAttribute(string name, string description)
    {
        this.name = name;
        this.description = description;
    }

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public string Description
    {
        get { return description; }
        set { description = value; }
    }

    public string Version
    {
        get { return version; }
        set { version = value; }
    }
}



Wanneer gebruik je Attributes?
Eigenlijk kun je Attributes het beste zien als vervanging van static properties die een constante waarde teruggeven.

Neem ons plugin-voorbeeld: zonder attributes zou je waarschijnlijk een public static property 'Name' hebben, die steeds een constante waarde teruggeeft. Nu doe je dit via een attribute.

Daarnaast gebruik je dus de .NET attributen om bepaalde 'functionaliteit' toe te voegen aan je klassen. (Bijvoorbeeld XmlSerializable, ComVisible, etc...)

Hoe gebruik je Attributes?
Dan zal ik gaan verklappen in het volgende deeltje, waarin ik in ga op Reflection.

To be continued...

Volgende: 10 jaar Meldersnet 12-'08 10 jaar Meldersnet
Volgende: Wii-motes zijn koel 12-'07 Wii-motes zijn koel

Reacties


Door Tweakers user Snake, donderdag 18 december 2008 13:21

Waar blijft de update? :P

Reageren is niet meer mogelijk