[c# + algemeen] attributen, wat denken jullie ervan?

[Alarmnummer]

Ik ben me aan het verdiepen in c# en ik ben tegen attributen aangelopen. Ik begin me steeds meer af te vragen wat er allemaal mee mogelijk is. Je kan er ook runtime allerlei functionaliteit mee aan een class toevoegen en ik zie al een aantal mogelijkheden voor me (oa mijn mvc gebeuren zou op dit manier volledig anders te schrijven zijn), omdat je gewoon veel meer met metadata kan werken. Het heeft ook wel wat eigenschappen volgens mij van OAP (Aspect Oriented Programming) omdat meer in aspecten van je systeem kan denken en ook makkelijk een aspect kan toevoegen.

Ik vraag me dus af wat jullie verwachten van programmeren met attributen?

ps:
voor de mensen die niet weten wat het is:
http://www.codeproject.com/csharp/attributes.asp

[edit]
Ik denk zelfs dat je aan de hand van metadata allerlei code kan genereren. Moet dit idee nog even laten uitkristaliseren.

[ Voor 24% gewijzigd door Alarmnummer op 21-01-2003 22:00 ]

[Freak_NL]

edit:
/me haalt een paar C# termen door elkaar

* Freak_NL heeft goede hoop voor C# en de .NET CLI

[ Voor 55% gewijzigd door Freak_NL op 21-01-2003 21:52 ]

[mbravenboer]

Alarmnummer: Ik denk zelfs dat je aan de hand van metadata allerlei code kan genereren.

Dat is inderdaad een sterk punt van het annotatie systeem. Het is een goede zet om hier een standaard constructie voor op te nemen en niet vaag en ongestructureerd info in commentaar op te nemen. Het hele idee is dat je methode/klassen etc kan annoteren met informatie. Deze informatie kan at runtime gebruikt worden door API's, maar ook voor het genereren van code met behulp van tools (is in feite te vergelijken met interpretatie/compilatie onderscheid). Attributen zijn niets anders dan gegevens die zich richten op bepaalde tools. De tools hebben kennis van deze gegevens en kunnen daar dus iets mee gaan doen.

Voorbeelden van tools:
- compiler
- web-service of andere remoting libraries
- code of documentatie generator
- instrumentatie tool (waarbij er code toegevoegd wordt aan de bestaande code)
- verifieren van bepaalde zaken.

Het centrale idee is dat niet alle metadata in een taal kan zitten. Op dit moment zie je in vrijwel alle talen al vormen van metadata die gericht is op de compiler. Denk bijvoorbeeld eens aan de access modifiers. Deze zou je ook kunnen zien als attributen van een klasse/methoden die zich richten op de compiler. Ook een type aanduiding zou je al als een attribuut kunnen zien, die zich met name richt op de type checker. Je zou zelfs pre- en post condities als attributen kunnen zien.

Het is dus een sublieme zet om in deze tijd met attributen te komen. Code generatie en diverse meta-tools zijn behoorlijk hot aan het worden en attributen kunnen hier zeer goed bij helpen om een standaard manier van metadata te bieden ipv gerommel in commentaar.

Alarmnummer: Het heeft ook wel wat eigenschappen volgens mij van OAP (Aspect Oriented Programming) omdat meer in aspecten van je systeem kan denken en ook makkelijk een aspect kan toevoegen.

Er zijn inderdaad wel wat parallellen, maar er zijn ook wel verschillen: een centraal idee van AOP is dat je code (aspecten) kan invoegen zonder dat je op al deze plaatsen precies aangeeft dat je deze code wilt hebben. Met attributen ligt dit wel wat anders: je kan in feite alleen maar abstraheren. Ik denk dat er nog het meeste overeenkomst is als je ervan uit gaat dat de code wordt geinstrumenteerd door een AOP-achtig tool die instructies in attributen gebruikt. Ik denk dat deze aanpak echter lastig te vergelijken is met de aanpak van echte AOP tools als AspectJ.

Overigens had ik zelf misschien nog wel liever attributen in de vorm van XML gezien: pure data bij methoden. Je ziet dat attributen in feite ook zo gebruikt worden, waarbij je dan in feite klassen gaat implementeren om de data op te slaan. Ik vind dit een onhandige werkwijze.

Ook is het jammer dat er (AFAIK) geen gestandaardiseerde methode om is om buiten een CompilationUnit (file) metadata over de hele CompilationUnit te specificeren. Dit zou nog wat interessante mogelijkheden bieden omdat je deze metadata dan kan raadplegen voordat je uberhaupt de CompilationUnit gaat proberen te begrijpen (parsen bijvoorbeeld).

Dit idee zie je terug in Stratego waarbij er meta files zijn bij Stratego modules. Op dit moment worden deze meta files alleen nog gebruikt om de gebruikte syntax van een Stratego module te specificeren ten behoeve van Meta Programming with Concrete Object Syntax. Er kan echter willekeurige data (in XML achtige vorm) in worden opgenomen, die dan door andere tools benut kan worden. Overigens kent Stratego nog geen metadata in Stratego modules zelf, dat is zeker iets waar aan gewerkt moet worden.

Ik neem aan dat je al weet dat er voor Java ook een JSR loopt voor metadata: JSR 175: A Metadata Facility for the Java Programming Language

[Alarmnummer]

Ik weet idd dat er voor java ook zoiets gaande is, maar ik heb eerlijk gezegd nog niet eerder serieus naar attributen gekeken. Zijn er trouwens andere talen die al lange tijden iets met properties doen?

[ Voor 4% gewijzigd door Alarmnummer op 22-01-2003 13:39 ]

[whoami]

Alarmnummer schreef op 22 januari 2003 @ 13:38:
Zijn er trouwens andere talen die al lange tijden iets met properties doen?

Properties?
In Delphi kan je properties gebruiken in je classes:

code:

private
   FNaam    : string;
public
   property Naam  : string read FNaam write FNaam;

Of bedoelde je attributen?

[ Voor 5% gewijzigd door whoami op 22-01-2003 13:45 ]

[Alarmnummer]

Het is niet de eerste keer dat ik de namen door elkaar haal Maar ik bedoel idd attributen. Properties zijn idd erg handig bij delphi en een stuk eleganter dan excpliciete getters en setters. Verder vind ik naamgeving in c# wel een beetje naadje. Oa een I voor je interface en methodes beginnen met hoofdletters.

[EfBe]

Alarmnummer schreef op 22 januari 2003 @ 14:01:
Verder vind ik naamgeving in c# wel een beetje naadje. Oa een I voor je interface en methodes beginnen met hoofdletters.

Als je iets anders wilt gebruiken dan kan dat hoor. Ik gebruik gewoon hungarian coding style want ik vind dat zelf het beste (en dingen als 'counter' kan ik echt niet aanzien). Die coding style van MS vind ik zelf ook zwaar irritant, waarbij dit bv verboden is:

public abstract class Foo
{
protected int _bar;

// other code
}

Ookal is _bar nooit publiekelijk beschikbaar, dit compileert niet met de ClsCompliant attribute in je code. Dit komt omdat public members niet mogen worden geprefixed, maar omdat dit een abstract class is, is dat geen issue, want het is een protected member. Naja, dan maar niet ClsCompliant

Over attributes: het zijn leuke dingen, maar ik gebruik ze zelden (alleen wanneer het dus nodig is om de compiler te sturen, zoals bij com code etc). Custom metadata gebruik ik verder niet en zie ook niet 1 2 3 dat gebeuren in de toekomst, maar voor grotere projecten is het wellicht wel handig.

[Freak_NL]

Het is niet de eerste keer dat ik de namen door elkaar haal

..dat ging bij mij dus ook al mis hierboven. Property.. Attribuut.. (loop wel vaker te zoeken met wisselende termen.. duurde ook even voordat ik doorhad dat de C# ArrayList de gelijke van de Java Vector is.. )

De naamgeving in C# komt mij juist vrij "schoon" en logisch over.

Properties zijn ideaal als een nette vervanging voor getters en setters idd..

Attributes lijken me inderdaad voor grotere projecten wel nuttig, maar voor de meeste gevallen zal ik er niet gauw iets mee doen.

[whoami]

Freak_NL schreef op 22 januari 2003 @ 15:13:
[...]

Attributes lijken me inderdaad voor grotere projecten wel nuttig, maar voor de meeste gevallen zal ik er niet gauw iets mee doen.

Ik heb me nog niet zo verdiept in Attributes, maar volgens mij kan je ze zeker wel gebruiken, ook in kleinere projecten.
Als je bv. WebServices wilt gaan schrijven, dan kan je al niet zonder Attributes. Je zult nl. de Attribute [WebMethod] nodig hebben.

Als je zelf exception classes wilt gaan schrijven, dan moet je - als je wilt dat uw exceptions voldoen aan de MS - standaard - ook het attribuut [Serializable] gebruiken etc....

[tijn]

EfBe schreef op 22 januari 2003 @ 14:24:
[...]
Over attributes: het zijn leuke dingen, maar ik gebruik ze zelden (alleen wanneer het dus nodig is om de compiler te sturen, zoals bij com code etc). Custom metadata gebruik ik verder niet en zie ook niet 1 2 3 dat gebeuren in de toekomst, maar voor grotere projecten is het wellicht wel handig.

Een hele mooie toepassing van attributes kun je zien in Entitybroker (OR gereedschap). Hier worden bijvoorbeeld properties van klassen voorzien van attributes die de mapping naar de database tabellen regelen. Vind ik persoonlijk mooier dan alle mappings via losse xml bestanden regelen.

[Freak_NL]

Whoami whoami: Dat is wel waar Ik stond er niet eens bij stil, maar ook in normale GUI apps. (GTK# of Win32) staat [STAThread] vaak bij je entrypoint.. Zal me toch eens wat meer in de attributes verdiepen.

[ Voor 5% gewijzigd door whoami op 22-01-2003 15:40 ]

[Verwijderd]

Ik vind zelf attributes een goede toevoeging in .NET. Het geeft een heel nieuwe manier om bepaalde problemen op te lossen. In dit stuk ( volgens mij zoiets als wat tijn aangaf) kun je al zien hoe je dataaccess vanuit een heel ander perspectief kunt aanpakken. Ik denk dat door deze nieuwe mogelijkheden veel dingen praktischer kunnen worden opgelost ( zoals bijv. bij code generatie zoals mbravenboer aankaartte).

Zelf heb ik tot nu toe een keer gebruik gemaakt van custom attributes voor een plugin systeem van een FTP server. Je kunt dan je eigen commando's toevoegen, of bestaande commando's 'overriden'. Op het moment ben ik bezig met een parser generator voor .NET en ik zit me nu af te vragen of attributes hier misschien een rol in kunnen spelen. Iemand ideeen ?

[ Voor 5% gewijzigd door Verwijderd op 22-01-2003 20:34 ]

[mbravenboer]

ydejager: Op het moment ben ik bezig met een parser generator voor .NET en ik zit me nu af te vragen of attributes hier misschien een rol in kunnen spelen. Iemand ideeen ?

Hangt er een beetje vanaf wat je allemaal genereert . Ik neem aan dat je een parser en klassen voor een abstract syntax tree genereert vanuit een of andere subklasse van de context-vrije grammatica's?

Ik zie dan eigenlijk niet direct enorme toepassingsmogelijkheden voor attributen omdat die met name nuttig zijn om eigenschappen van C# code vast te leggen. Als je echter nog geen C# code hebt, is het ook lastig om daar eigenschappen van vast te leggen, laat staan ze ook te gebruiken .

[Alarmnummer]

Maar zijn er andere 'oo' talen waar attributen worden gebruikt?

[ Voor 24% gewijzigd door Alarmnummer op 23-01-2003 18:53 ]

[JeroenB]

Ik ben zelf druk met attributen bezig omdat ik aan een applicatie werk dat als framework moet dienen voor allerlei plug-ins. Deze plug-ins werken op verschillende niveau's (zoals het OSI-model) en het is dus erg handig dat ik dmv. attributen gewoon aan het framework kan vertellen voor welke laag een class gebruikt moet worden, zonder dat ik op voorhand alle lagen hoef te definieren door ze allemaal een unieke interface te geven.

Persoonlijk zit het me niet altijd even lekker om puur te baseren op attributen - zo'n eigen interface voorkomt wel een hoop problemen mochten anderen je code gaan gebruiken en die attributen negeren. Maargoed, ooit moet je je erbij neerleggen dat als mensen je code op een verkeerde manier gebruiken, het toch wel misgaat, wat je ook probeert

[mbravenboer]

Alarmnummer: Maar zijn er andere 'oo' talen waar attributen worden gebruikt?

Naar aanleiding van je eerdere opmerking hierover heb ik daar inderdaad over na zitten denken, maar ik kan eigenlijk geen echte oorsprong of links vinden ... M'n taalhistorische kennis is helaas ook nog niet zo goed, dus ik kan iets volledig over het hoofd zien.

Ik denk dat het voor een deel voortkomt uit de grote diversiteit aan aanwijzingen in commentaar in diverse talen voor diverse toepassingen. Ook is er wel een link met de grotere mate van reflectie mogelijkheden (alhoewel nog niet te vergeleken met sommige minder bekende talen uit het verleden die reflectie zowat als basismodel hadden).

Als je het echt wilt weten zou je het kunnen vragen op http://lambda.weblogs.com . Er zitten daar aardig wat mensen moet veel kennis van historische talen en ontwikkelingen .

[Alarmnummer]

Bedankt voor de (altijd goede en uitgebreide) uitleg martin

en de markt is dus helemaal nog open voor idoms en design patterns voor attributen

[ Voor 57% gewijzigd door Alarmnummer op 23-01-2003 21:47 ]

[mbravenboer]

Alarmnummer: en de markt is dus helemaal nog open voor idoms en design patterns voor attributen

Alarmnummer ruikt weer eens kans voor het zoeken naar richtlijnen en patronen .

[Alarmnummer]

Ik ben me nu aan het inlezen in Enterprise patterns van Fowler (en dat is echt een zeer verhelderend boek). Maar ik begin me nu toch een beetje af te vragen hoe je je ontwerp nu volledig anders kan opstellen door attributen. In een tutorial op codeproject zag ik iets staan voor XML en in dit topic staat ook nog een voor OR mapping, en dan krijg je weer een hele andere kijk op de datalayer

[JeroenB]

Volgens mij zitten de attributen niet zo zeer op het niveau waarin dat soort dingen echt toepasbaar zijn. Of eigenlijk, attributen an sich zijn een design pattern voor compilerbouwers.

[maikel]

Ik en een collega (het was zijn idee) hebben attributen wel eens gebruik voor het gebruik in factory-objecten.
Bij de properties van een class zetten we een metadata-tag met daarin de tabel- en kolomnaam van de overeenkomende data in de database. Een eventuele andere metadata-tag gebruiken we om relaties in de database aan te geven (tabelnaam, kolomnaam, gelinkte tabel, gelinkte kolom).

Een zogenaamde factory-class heeft een fill-method waarbij we een van de classes met metadata meegeven. Die method vult dan aan de hand van de metadata de properties met de data die op de aangegeven lokaties in de database staat.
Ook kan de factory dan automatisch de goede joins, update-statements, insert-statements genereren.
Op die manier hoeft iemand die met de classes werkt, totaal geen kennis van de database-structuur te hebben.

PS. Door de metadata te gebruiken zijn ook constructies mogelijk als: factory.Fill(object, object.Name = "Maikel");
Hierbij zorgt de factory automatisch voor de vertaling naar een mooie where-clause voor de database.