Alfabetische lijst van gebruikte afkortingenusers.telenet.be/hcorsmit/Eindwerk_hans_corsmit.docx ·...

VOORWOORD

SAMENVATTING

INHOUDSTAFEL

VOORWOORD.................................................................................................2SAMENVATTING.............................................................................................2INHOUDSTAFEL..............................................................................................2INLEIDING......................................................................................................3ALFABETISCHE LIJST VAN GEBRUIKTE AFKORTINGEN........................................41 QFRAME...........................................................................................51.1 .NET gespecialiseerd........................................................................51.2 Behandelen van projecten.................................................................61.3 Aanbieden Consultancy.....................................................................61.4 Werknemers.....................................................................................62 STAGEOPDRACHT.............................................................................72.1 Uitvoering........................................................................................72.1.1 Eerste fase..........................................................................................................82.1.2 Tweede fase.......................................................................................................82.1.3 Derde fase..........................................................................................................92.1.4 Vierde fase.........................................................................................................93 REALISATIE.....................................................................................103.1 Diagram.........................................................................................103.2 Generatie.......................................................................................113.3 Import en export............................................................................114 DOMAIN SPECIFIC LANGUAGE..........................................................124.1 Ontwikkelingstools.........................................................................134.2 DSL-Tools.......................................................................................134.3 Belangrijkste vensters....................................................................134.3.1 Toolbox.............................................................................................................134.3.2 Hoofdscherm....................................................................................................134.3.3 Proporties.........................................................................................................134.3.4 DSL Explorer.....................................................................................................144.3.5 DSL details........................................................................................................145 INSTELLEN DSL-MODEL...................................................................155.1 Aanmaken DSL - project..................................................................155.2 Opstarten DSL-Model......................................................................155.3 Aanmaken nieuwe elementen..........................................................165.3.1 Elementen........................................................................................................165.3.2 Connectoren.....................................................................................................175.4 Eigenschappen toekennen..............................................................175.4.1 Type bepalen....................................................................................................175.4.2 Enumeraties toevoegen....................................................................................185.4.3 Soort bepalen...................................................................................................18

3

5.4.3.1 Normal..............................................................................................................................................185.4.3.2 Calculated.........................................................................................................................................185.4.3.3 Custom Storage................................................................................................................................195.4.4 Sleuteleigenschap bepalen...............................................................................205.4.5 Decorators toekennen......................................................................................205.4.5.1 Text Decorator..................................................................................................................................215.4.5.2 Icon Decorator..................................................................................................................................215.5 Groeperen van elementen...............................................................215.6 Acties op shapes.............................................................................225.7 Rules en validatie...........................................................................235.8 Custom Editor instellen...................................................................246 DSL-MODEL BEKIJKEN......................................................................266.1 Elementen toevoegen.....................................................................266.2 Overzicht elementen bekijken.........................................................267 COMMANDO INSTELLEN DSL-MODEL................................................287.1 Aanmaken menu commando’s.........................................................287.1.1 Symbols............................................................................................................287.1.2 Commandplacements.......................................................................................297.1.3 Buttons.............................................................................................................297.1.4 Menu’s..............................................................................................................297.1.5 Groups..............................................................................................................307.2 Toewijzen constanten.....................................................................307.3 Acties toekennen aan Commando....................................................307.3.1 Toevoegen aan model:.....................................................................................307.3.2 Statusfunctie bepalen:......................................................................................317.3.3 Actie bepalen....................................................................................................328 GEBRUIK VOOR GENERATIE..............................................................338.1 Instellen processor.........................................................................338.2 Opstellen Templates.......................................................................358.3 Aanmaken Templates......................................................................358.3.1 Losse templates................................................................................................358.3.2 Templates via constante waarden....................................................................358.4 Template schrijven.........................................................................368.5 Methode schrijven..........................................................................368.6 Extra functionaliteiten schrijven......................................................389 EXPORTEER DSL-MODEL..................................................................399.1 Gebruik maken store......................................................................399.2 Schrijven basisclass........................................................................399.3 Schrijven export class.....................................................................4010 IMPORTEER NAAR DSL-MODEL.........................................................4110.1 Importeer vanuit DSL......................................................................4110.2 Importeren buiten DSL....................................................................4210.3 Positioneren Shapes.......................................................................43BESLUIT ......................................................................................................43LITERATUURLIJST.........................................................................................43BIJLAGEN.....................................................................................................44

4

INLEIDING

5

ALFABETISCHE LIJST VAN GEBRUIKTE AFKORTINGENDB Database

DSL Domain Specific Language

EA Enterprise Architecture

T4 Text Templating

UML Unified Modeling Language

XML Extensible Markup Language

XSLT Extensible Stylesheet Language Transformation

6

1 QFRAMEQFrame is het .NET competence center binnen Cronos NV, de bekende e-business integrator uit Kontich. Cronos NV is een groep van ondernemingen die vaak nauw samenwerken maar dan gespecialiseerd in hun domein. Qframe heeft zich gespecialiseerd in maatwerk voor .NET en Microsoft Office toepassingen en stelt 30 mensen tewerk.

De focus ligt op technische kennis en QFrame tracht dan ook continu op de hoogte te blijven van de laatste nieuwigheden op dat gebied. Toch zijn ze bovenal bezig met het zoeken naar de meest pragmatische oplossing in de context van de klant, wat niet altijd betekent de meest recente technologie.

Het merendeel van de QFrame-klanten is marktleider of is een belangrijke speler binnen hun bedrijfstak. Deze status aanhouden is vanzelfsprekend geen sinecure en enkel mogelijk mits een strenge bewaking van de verschillende bedrijfsprocessen. Het is dan ook niet verwonderlijk dat deze bedrijven bij de selectie van hun IT-partner nauw toekijken op de ervaring en kwaliteit van de externe medewerkers die men wenst in te schakelen. Wij zijn er van overtuigd dat specialisatie, mits de juiste omkadering en begeleiding, een antwoord vormt op de vraag naar de nodige expertise en kwaliteit.

1.1 .NET gespecialiseerd

Microsoft .NET is de laatste jaren uitgegroeid tot hét referentieplatform voor het ontwikkelen van software wereldwijd. Deze technologie wordt alom geloofd om zijn zeer uitgebreide mogelijkheden, snelheid en productiviteit bij het ontwikkelen. Met .NET kunnen diverse types toepassingen ontwikkeld worden, wij concentreren ons echter vooral op bedrijfskritische data-entry en backend systemen.

QFrame was trouwens al vóór het ontstaan van .NET erg actief met het ontwikkelen van administratieve maatsoftware, toen nog in COM-technologie. Deze kennis, vooral rond ontwikkeltool Visual Basic 6, is nog steeds in huis en ook veel gevraagd. Sinds de introductie van .NET in 2002 wordt voor nieuwe ontwikkelingen bijna integraal voor .NET gekozen.

We ontwikkelen zowel Windows- als Web toepassingen, maar ook de ontwikkeling van Webservices en integratie modules met andere platformen behoren tot de activiteiten.

Voor dataopslag wordt bij voorkeur Microsoft SQL Server ingezet, echter ook connectiviteit naar Oracle databases verloopt probleemloos.

Voor maatwerk .NET projecten richt QFrame een gestandaardiseerde projectflow in, waarin centraal versiebeheer, geautomatiseerde tests en builds en hiermee geïntegreerde communicatie en rapportage via Visual Studio Team System centraal staan.

8

1.2 Behandelen van projecten

QFrame houdt zich vooral bezig met het realiseren van projecten. Elk project krijgt een team toegekend. In dit team zullen alle belangrijkste technische taken op zich worden genomen: developer, technical coach & technical architect, … Wanneer andere zaken nodig zijn kunnen ze altijd beroep doen op gespecialiseerde mensen van andere bedrijven uit de Cronos groep.

Het gebeurt ook dat het gemengde projectteams zijn. Deze teams bestaan uit medewerkers van QFrame maar ook medewerkers van de klant. Dit zorgt er voor dat de klant op een korte termijn een uitgebreide ervaring op doet.

Steeds wordt er aan de klant duidelijke afspraken rond gemaakt hoe ze QFrame makkelijk kunnen bereiken. Dit gebeurt via het “Single point to contact” concept dat ze hanteren. Steeds een plaats waar ze QFrame kunnen bereiken.

1.3 Aanbieden Consultancy

Klanten die nood hebben aan assistentie of technische kennis kunnen ook terecht bij QFrame. Wanneer er een project tijdig afgerond moet worden en ze even fulltime assistentie nodig hebben om dit te realiseren. Vooral om een specialist voor een beperkte tijd in te huren of om meer coaching te hebben bij een project.

Maar buiten de .NET en office ontwikkelaars hebben ze een uitgebreid pakket van activiteiten aan te bieden zoals:

het opstellen van een verkennende studie maken van een (UML gebaseerde) functionele analyse ontwerpen van een applicatie architectuur interne voorstellen realiseren intern project management bugfixing op bestaande projecten, etc.

1.4 Werknemers

Voor QFrame zijn de werknemers ook belangrijk. Ze kiezen ervoor om een goede reputatie te creëren voor hun medewerkers. Omdat voor vele computers een hobby is en sommige medewerkers sleutelposities beschikken op forums en newsgroups van Microsoft. Een paar medewerkers zijn zelf gecertificeerde Microsoft trainers.

Medewerkers hebben voluit de kans om zich bij te schaven door middel van cursussen, (inter)nationale congressen en conferenties.

9

2 STAGEOPDRACHTQframe heeft een framework ontwikkelt met de naam Leaf.net. Dit framework helpt hen om snel bepaalde klassen te genereren die verder helpt om snel applicaties te kunnen starten. Dit gebeurt nu via omzetting van een commit-model naar xml. Uit deze xml-files worden dan via een tool die gebruikt maakt van bepaalde XSLT-bestanden om de xml-files om te zetten naar code.

De bedoeling is dat dit via een nieuwe methode te doen. Het commit-model wordt dan omgezet naar een domain specific language model. De opdracht is dus om een dsl-model te ontwikkelen en ervoor te zorgen dat je een commit-model kunt omzetten naar een dsl-model. Het is ook de bedoeling om het dsl-model om te zetten naar code via texttemplating.

De stap om het commit-model om te zetten naar een dsl-model moet ook in de omgekeerde richting gebeuren. Dit is namelijk voor het feit dat er bepaalde noodzakelijke scripts bestaan die gebruik maken van het Commit-model, vooral de scripts die de tabellen opvullen met de informatie uit het Commit-model.

Dit zou ook helemaal in het bestaande gedeelte moeten worden opgenomen. Dus dat het via hun tool gemakkelijk kan worden gebruikt om code te genereren want de andere opties moeten nog steeds beschikbaar zijn als mensen daar voor kiezen. Dit is wordt in de toekomst wel anders, het wordt de bedoeling dat ze in de toekomst enkel met DSL gaan werken en de stappen om code te genereren reduceren naar twee stappen. Namelijk het ontwikkelen van het model en van daaruit dan code te generen

Als extra kan het nog zijn dat het via Guidance Automation Toolkit mogelijk moet zijn om via de xml-file van de dsl-model en de templates om daarmee de code te genereren.

2.1 Uitvoering

Qframe heeft in de loop van de jaren een aantal tools ontwikkelt die hen helpt in het ontwikkelen van een applicatie. Zo is er een framework ontstaan met de naam “LeaF.net”. Dit staat voor “Large Enterprise Application Framework”. Het is een soort van uitbreiding voor het .net framework van microsoft.

Leaf.net framework is een uitgebreid framework dat hen helpt bij het creëren van uitgebreide zoekmogelijkheden, rolebased security of meertaligheid. Dit zijn niet de enige functies want hier boven is eigenlijk ook de codegenerator ontwikkeld. Dit helpt hen verder in het schrijven van de classes rond de data invoer van een applicatie. Hierbij zal dus de ontwikkeltijd verkorten en zal de kwaliteit aardig toenemen.

Omdat dit voor mij de belangrijkste functionaliteit is omdat hier mijn nieuwe functionaliteit behoort.

10

Hier is een schema met de functionaliteiten van nu en wat het zou moeten worden:

Om dit te realiseren is het verdeeld in vier fases. De eerste fase is de belangrijkste fase omdat dit centraal staat in de nieuwe generatie. Fase drie en vier zijn minder belangrijk omdat deze stappen in de toekomst misschien overbodig worden. Fase 1 en 2 blijven dan de belangrijkste stappen in de generatie van code.

2.1.1 Eerste fase

Aanmaken van het model zelf. Het model is de basis voor alles, je kan niet beginnen aan de generatie voordat je model af is. Je kan ook niet beginnen aan de import of export als er geen model is. Eerste fase is dus om het model zo op te stellen dat het voldoet aan alle noden voor het Leaf.NET framework. Alles wat in het bestaande commit-model zit zou je moeten terugvinden in het nieuwe DSL-model.

Ook moet er voor gezorgd worden dat het een duidelijk overzicht heeft en dat je rekening houdt met alle soorten relaties tussen alle elementen.

2.1.2 Tweede fase

Generatie is redelijk belangrijk omdat anders het DSL-model nutteloos is (buiten het bekijken ervan). Allereerst moet ik ervoor zorgen dat je vanuit het DSL-model kan genereren naar meerdere files. Daarna moet ik zorgen dat de T4-scripts worden aangemaakt voor elk soort van bestand. Daarna moet ik zorgen dat het mogelijk dat ik het resultaat van de generatie rechtstreeks naar bestaande projecten kan genereren.

11

2.1.3 Derde fase

Derde fase is in de toekomst misschien niet meer nodig maar momenteel is het nog wel een belangrijke stap. Het importeren van een commit-model naar je DSL-model. Dit zou vanuit de bestaande generator moeten kunnen gebeuren zonder dat je het DSL project moet opstarten.

In principe zou je dan niets meer moeten aanpassen aan je DSL-model om te kunnen genereren naar de juiste code. Omdat DSL een object georiënteerde taal is moet de import best gebeuren via objecten want je kan het ook via xml doen maar dit is niet zo gebruiksvriendelijk voor de aanpasbaarheid. Later kunnen er zaken aan het commit-model wijzigen zodat het snel kan worden aangepast.

2.1.4 Vierde fase

De vierde fase en de derde fase kunnen worden omgewisseld. Omdat de medewerkers vertrouwd zijn met het Commit-model en omdat er nog tooltjes bestaan die gebruik maken van een Commit-model moet het mogelijk zijn om een bestaand DSL-model te exporteren naar een Commit-model. Dit Commit-model kan je dan makkelijk gebruiken in de bestaande tools. Importeren en exporteren zijn gelijkaardig en wanneer je één stap kan, zal de omgekeerde stap via dezelfde manier lukken. In principe zou je een model kunnen exporteren en nadien weer importeren. Dit zou dan hetzelfde resultaat moeten geven dan voordien.

12

3 REALISATIEVoor de grootste gedeelte van de opdracht heb ik me bezig gehouden met fase 1 en 2 van mijn opdracht. Ik kon vertrekken van een bestaand model dat standaard werd meegeleverd met de DSL-Tools. Dit was natuurlijk het minimum van het minimum dat nodig was. Een uitbreiding was noodzakelijk om alle elementen die Qframe gebruikt in hun generatie te tonen.

3.1 Diagram

Een diagram bestaat meestal uit classes maar kan ook tabellen bevatten. Tussen beide elementen bestaat er eventueel een link. Elke class heeft de mogelijkheid om attributen en methodes toe te kennen. Een tabel bevat dan weer velden en bevat foreign keys en primary keys.

Tussen beide soort van elementen kan je relaties trekken. Er bestaan twee soorten relaties tussen dezelfde soort van elementen. Tussen twee tabellen of twee classes kan je relaties leggen die één richting uitgaan of relaties leggen die gelden langs beide richting. Er is wel een speciale soort van relaties namelijk relaties met een veel op veel multipliciteit. Dit is enkel tussen twee classes mogelijk omdat tabellen dit niet kunnen bevatten.

De link tussen beide is dan weer enkel mogelijk tussen één tabel en één class. Je kan geen meerdere tabellen aan één class hangen. Weer heb je hier het speciaal item voor veel op veel relaties. Hier heb je steeds een tabel die gelinkt is met de veel op veel relatie. Dit moet in DSL met een tussenstuk omdat je geen associaties kon leggen tussen associaties en elementen. Het tussenstuk bevat maximum twee classes en één tabel als link.

Zo kan een diagram er uitzien:

13

3.2 Generatie

Voor het generatie gedeelte was het lang een zoekwerk hoe ik voor elke class een aparte file kon genereren. Dit kon uiteindelijk door een commando toe te kennen en zo via een bepaalde methode de generatie te regelen. Standaard zal de generatie gewoon gebeuren in het model maar er is de mogelijk om een andere locatie te selecteren. Zo kan je snel kiezen om het resultaat van de generatie te gebeuren in een bestaand project of op een bepaalde locatie.

Wanneer een bestand bestaat zal hij het bestand overschrijven. Zo zijn er baseclasses die de grootste informatie bevatten van de modellen. Voor elke baseclass bestaat er een class die gebruikt maakt van de baseclass. Een baseclass moet bij elke generatie worden aangepast maar de class die gebruik maakt van deze baseclass niet. In deze class wordt er eigen code bijgeschreven die zeker niet mag worden verwijderd door een nieuwe generatie. Dit wordt voorkomen door te controleren of het bestand bestaat of niet. Wanneer het al bestaat zal hij het niet uitvoeren, anders zal hij een nieuw bestand aanmaken met de gepaste code.

Via verschillende commando’s kan je bepalen welke taal en welke classes je kunt genereren. Je kan ook per tabel beslissen of je wilt dat het wordt gebruikt in de generatie.

3.3 Import en export

Import en export gebeurt op dezelfde manier. Telkens wordt er voor elke class of tabel een object aangemaakt. Die wordt dan opgevuld met de correcte informatie. Wanneer alles over het object is ingevuld zal hij het object toevoegen aan de algemene collectie.

14

Een verschil is dat import buiten het DSL-model wordt gebruikt en dat zorgt voor een lastiger pakket. Een DSL-bestand is eigenlijk een XML-bestand, maar omdat je het model kunt bekijken in een speciale designer bevat het een hoop extra informatie. Alle elementen worden in een soort van collectie opgeslagen. Het toewijzen in een collectie gaat nog wel maar om een collectie toe te kennen aan een bestand is veel moeilijker. Een XML-bestand bevat geen extra instellingen. Dit is voorkomen door een bepaald element te gebruiken van het DSL-model. Je kan een store zo toekennen aan bestand.

Het importeren gebeurt via de bestaande generator. Je kan nu een nieuwe optie kiezen “Commit To DSL” tussen de opties. Er zal dan een formulier worden getoond waar je informatie kunt wijzigen zoals de locatie en de naam. Zo kan je dan bevestigen zodat er een nieuw DSL-model word aangemaakt.

Het exporteren gebeurt gewoon via een commando. Je moet dan de naam en locatie invullen. Wanneer je bevestigt, wordt er een nieuw Commit-model aangemaakt op de locatie.

15

4 DOMAIN SPECIFIC LANGUAGEDomain specific language is een ruim begrip. Het is eigenlijk een soort van abstracte taal die gebruikt wordt om ontwikkelde systemen duidelijker te maken. Het is een soort van analysetaal waarbij je modellen verduidelijkt. Het is mogelijk om schema’s op te stellen die bepaald zijn naar uw eigen eisen. Het hangt ook niet vast aan één bepaalde programmeertaal, het staat volledig los daarvan en kan dus zowel gemaakt worden voor Java schema’s, .net schema’s of andere talen.

De naam zegt ook waarvoor het dient, het is een taal die veel gericht is op een bepaald domein. Elk model is dan ook anders en is gebaseerd op het systeem dat ontwikkelt moet worden. Het geeft dan ook een heel goed beeld over het toekomstige systeem.

Het kan ook voor andere zaken gebruikt worden dan voor programmeerzaken weer te geven. Je kan het echt puur gebruiken om analysezaken weer te geven. Bijvoorbeeld om de structuur van je website te ontwikkelen of zelfs helemaal niets met informatica te maken hebben. Wanneer je een elektrische schakeling wilt tonen aan klanten.

Maar het dient vooral dus voor programmeren. Met de domain specific language tools is het mogelijk om je eigen modellen te maken en vanuit die modellen code te genereren. Dit bestond al wel voor UML modellen maar die modellen zijn vast bepaald en bij dsl kan je de modellen zo aanpassen naar je systeem.

Domain specific language zal nooit alles verduidelijken maar het is gewoon veel gerichter op je behoeftes dan programma’s. Het is ook een vrij nieuw begrip dus momenteel staat de ontwikkeling van Dsl-tools nog niet helemaal op punt.

16

4.1 Ontwikkelingstools

Om domain specific language te ontwikkelen bestaan er verschillende tools want het is geen vast gedefinieerde taal. Doordat er geen vast stramien voor de taal is, kan eigenlijk Word al ideaal zijn. Soms is het maar tekstueel weergeven van een systeem.

Maar om het visueel toch iets beter voor te stellen en om sneller te kunnen werken heeft Microsoft een tool ontwikkelt. Het heeft de simpele naam meegekregen “Dsl tools”. Dit zit niet standaard in Visual studio. Dit zit wel in de sdk van Visual studio die je gratis kan downloaden van de microsoft site. Opgelet: Visual studio moet de professional edition zijn. Anders zal je dsl tools wel kunnen installeren maar niet gebruiken.

In 2005 versie was het nog in de kinderschoenen en zullen er wel vaak stabiliteitsproblemen opduiken. Sinds 2008 is het beter maar je merkt wel weinig verschil maar hij zal veel stabieler werken.

4.2 DSL-Tools

Dsl-tools is eigenlijk een soort verzameling van classes in c# die samen met een achterliggende compiler zorgen voor de weergave van het klassemodel. Elk object dat je aanmaakt zal ook zijn eigen classes krijgen.

De structuur van de tool is altijd uit twee c#-solutions namelijk DSL en DSLpackage. DSL is de verzameling van de objecten met al hun classes. Hierbij zul je dus geen classes vinden die te maken hebben met het creëren van het model. Dat is aanwezig in DSLpackage. Hier vind je alles dat te maken heeft met de weergave van het dsl-model maar niets rond de objecten die getoond worden.

4.3 Belangrijkste vensters

Dsl-tools is bijna identiek aan Visual studio maar heeft natuurlijk extra vensters die gericht zijn op domain specific language.

4.3.1 Toolbox

Toolbox heeft elk Visual studio project ook maar voor dsl is er een aparte categorie aan toegevoegd die alle elementen bevat voor het aanmaken van een dsl-model. Ook alle elementen die niet tot een class diagram behoren zijn hier in weergegeven.

4.3.2 Hoofdscherm

Het hoofdscherm is in principe gewoon een scherm waar je bestanden kan wijzigen. Standaard staat hier dsldefinitions.dsl open. In dit bestand worden de nieuwe elementen toegevoegd voor je model. Dit is een bestand waar je de elementen van de toolbox naar toe sleept. Eigenlijk is het een dsl-model op zich.

4.3.3 Proporties

Dit is ook identiek aan Visual studio. Hier vind je niets speciaal in buiten dat de proporties gebaseerd zijn op elk element van het model.

18

4.3.4 DSL Explorer

Dsl Explorer bestaat uit de verzameling van elementen in het dsl-model. Elk soort collectie vind je hier terug. Bepaalde zaken kan je alleen hier instellen. Alles is hier ingedeeld in collecties. Hier vind je ook gewoon de verzameling terug van elementen en relaties maar ook kan je hier een overzicht krijgen hoe de xml in elkaar zit. Elk element kan je bekijken welke attributen en relaties er zijn.

4.3.5 DSL details

Dit vind je standaard onderaan terug. Hier kan je gedetailleerde informatie wijzigen. Vooral rond decorators, compartimenten en ook alle informatie rond relaties wijzigen.

19

5 INSTELLEN DSL-MODEL

5.1 Aanmaken DSL - project

Het aanmaken op zich is geen moeilijk proces. Alleen sommige elementaire zaken zijn belangrijk dat je die goed kiest. Bijvoorbeeld welke extensie je diagrammen gaan hebben. Deze moet uniek zijn en nog niet bestaand. Daarom kan je beter iets langer en een bepaalde afkorting gebruiken.

1. Je opent Visual studio en selecteert “New project”

2. Je kiest bij Other project types onder de categorie extensibility voor: Domain specific language designer

3. Selecteer in het keuze venster voor het gewenste diagram. (Voor mijn opdracht is het Class Diagram)

4. Je kiest een naam voor je project

5. Je kiest je unieke extensie. (Bij bestaande extensies ga je problemen krijgen)

6. Daarna vul je een naam van project in en tot wie het behoort en de namespace

7. Kies voor New key of voor bestaande keyfile (assembly informatie file)

8. Druk op finish

5.2 Opstarten DSL-Model

Standaard wordt er een basis gemaakt voor een class diagram. In Visual studio is er een class diagram viewer aanwezig voor elk project. (rechtermuisknop -> view as class diagram). Dit class diagram wordt als basis genomen voor de dsl-tools.

Wanneer je het standaard class diagram wil bekijken, hoef je enkel op het groene pijltje of menuoptie start debugging te kiezen in het menu debug. Er zal een nieuwe Visual studio geopend worden. Het is geen normale Visual Studio maar een Experimental Hive versie. Dit is de versie waar je zaken kunt proberen die invloed hebben voor de Visual Studio omgeving. Omdat het nogal kritisch is om de gewone Visual Studio te gebruiken, gebruiken ze een versie die bij beschadiging gemakkelijk kan hersteld worden zonder dat je de hele Visual Studio moet herinstalleren.

Wanneer je nog niets aangepast hebt, zal hij altijd een voorbeelddiagram aanmaken. Dit vind je terug in de solution Explorer van je model met de naam: sample.”extensie”. Dit bevat een voorbeelddiagram waar alle elementen aanwezig zijn van het model.

De omgeving is vertrouwd. Standaard bestaat de omgeving uit een toolbox aan de linkerkant, centraal dan de ruimte voor bekijken van de modellen. Aan de rechterkant bevind zich dan het proporties venster en de solution Explorer. Onderaan bevind er zich nog de error-list.

20

Opmerkingen:

In xp kunnen er fouten gebeuren en kan het zijn dat je geen Diagram editor kan openen van je bestand. Dit moet je oplossen door de buildopties van DSLpackage aan te passen in je project. Je volgt deze stappen om er voor te zorgen dat dit gebeurd:

1. Selecteer proporties bij DSLpackage

2. Kies build events

3. Vul in: "C:\Program Files\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Tools\Bin\regpkg.exe" /root:Software\Microsoft\VisualStudio\9.0 “$(TargetPath)”

4. Rebuild voor uittesten of het werkt

In principe zou dit standaard moeten gebeuren. Standaard zal hij bij stap 3 9.0exp kiezen. Maar bij XP wordt deze map soms niet gevonden. Daarom zal hij het niet uitvoeren zoals je wenst. Een foutmelding geeft hij niet maar wanneer je opstart krijg je een “Package Load Failure”.

Het is belangrijk om ervoor te zorgen dat je telkens twee acties uitvoert: “transform all templates” en dat je daarna het project build via “Build solution”. Daarom kan je best een macro opbouwen die de twee acties uitvoert.

1. Selecteer tools -> macros -> new macro project

2. Rechtermuisknop op nieuwe macro -> Set as recording project

3. Selecteer tools -> macros -> recording temporaryMacro

5.3 Aanmaken nieuwe elementen

Omdat het noodzakelijk is om nieuwe elementen toe te voegen die meer tot uw noden behoren moet je alles eens grondig doornemen. Meestal kan je de basis wel gebruiken en moet je enkel nieuwe elementen toevoegen.

Een nieuw element kan je gewoon slepen vanuit de toolbox. Je hebt keus tussen drie verschillende types:

5.3.1 Elementen

Een element is een item dat kan toegevoegd worden aan het diagram zonder echt afhankelijk te zijn van andere elementen. Natuurlijk is dit enkel het geval wanneer het element mag toegevoegd worden aan het rootelement. Elk diagram heeft één rootelement die eigenlijk de verzameling vormt van alle elementen. Sommige

21

elementen zijn wel speciaal. Zij behoren niet tot het rootelement maar tot een basiselement. Dit is vaak een embedded element: voorbeeld is een modelattribuut van een class. Wanneer je dus het basiselement verwijderd, zal hij alle subelementen mee verwijderen.

Om een element te tonen moet je er een Geometric shape of een image shape aan koppelen. Zonder shape zal hij het niet tonen. Een geometric shape is een bepaalde vorm: een vierkant, cirkel, ruit, … en een image shape is een afbeelding die je zelf wil gebruiken voor het element. Een compartiment shape is een speciale shape die bedoelt is om subelementen weer te geven. Elk compartiment wordt dan gelinkt aan een subelement en zo zullen de subelementen worden weergegeven in het hoofdelement.

5.3.2 Connectoren

Connectoren zijn de relaties tussen de elementen. Zonder connectoren kan je geen elementen met elkaar verbinden. Er zijn twee types: embedded connectoren en referenced connectoren. Hier bepaal je dus of het element een alleenstaand geval is of het element een onderdeel is van een ander element.

Een referenced connector is altijd afhankelijk van twee elementen. Dit kan twee verschillende elementen zijn maar kan ook hetzelfde element zijn. Bij elke relatie kan je dan bepalen welke multiplicity het bevat. Wanneer aan beide kanten 0..* is geselecteerd, zal hij geen extra proportie voorzien maar bij een 0..1 zal hij in het element een proportie aanmaken waarbij je een element kan selecteren dat voldoet aan de relatie.

Ook een connector heeft een connector shape nodig om het te tonen. Wanneer dit niet gebeurd, kan je wel relaties leggen maar kan je ze niet zien. Dit kan problemen geven wanneer je nieuwe relaties wil leggen en relaties wilt verwijderen.

5.4 Eigenschappen toekennen

Eigenschappen kan je aan alles toekennen. Zowel aan connectoren, elementen en zelfs aan shapes. Elk ingesteld eigenschap kan je standaard eigenschappen toekennen. Eigenschappen kunnen echt dienen als statische informatie voor het element. Een eigenschap kan van elk soort type zijn: boolean, string, integer of een eigen type.

Types kan je definiëren in de dsl explorer bij domain types. Hier hoef je enkel de naam en namespace ingeven. Dus wanneer je een eigen class heb aangemaakt en je wil objecten daarvan gebruiken moet je hier de naam van de class ingeven en de namespace.

22

5.4.1 Type bepalen

Standaard ontbreken er een paar dus als voorbeeld kan je zorgen je het type color kunt toevoegen. Dit zal er voor zorgen dat je bij je eigenschap nu een listbox krijgt met alle mogelijke kleuren.

1. Je selecteert dsl explorer

2. Je klikt met je rechtermuisknop op het hoofdelement en selecteert “add external type”

3. Je vult als naam in: Color

4. Je vult als namespace in: System.drawing

Vanaf nu kan je bij het type in plaats van string of integer ook color selecteren.

5.4.2 Enumeraties toevoegen

Enumeraties zijn lijsten met mogelijke keuzes. Het is mogelijk dat een eigenschap enkel vier mogelijkheden mag bevatten. Dit kan je best oplossen door een enumeratie toe te voegen. Enumeraties bevinden zich gewoon tussen de domain types. Hierbij kan je dus gewoon de enumeratie selecteren als type.

1. Je selecteert dsl explorer

2. Je klikt met je rechtermuisknop op het hoofdelement en selecteert “add enumeral type”

3. Je vult als naam in van de enumeratie

4. Je kan nu via de rechtermuisknop steeds nieuwe elementen aan de enumeratie toevoegen

5.4.3 Soort bepalen

Een eigenschap kan afhankelijk zijn van andere eigenschappen. Daarom is er een proportie “Kind”. Deze optie heeft drie mogelijkheden:

5.4.3.1 Normal

De eigenschap is van niets afhankelijk. Dit zal gewoon een eigenschap zijn dat je kan aanpassen naar wat je wilt. Deze wordt standaard geselecteerd als je een nieuwe domainproperty aanmaakt. Wanneer je van een andere optie voor deze optie kiest, dan zal hij geen rekening meer houden met de aangemaakte methodes die nodig zijn voor de andere opties.

5.4.3.2 Calculated

Wanneer dit geselecteerd is, betekend dat de eigenschap afhankelijk is van andere eigenschappen. Vanaf nu is de eigenschap ook read-only. Je kan de eigenschap niet

23

meer manueel aanpassen. Het zal wel telkens aanpassen als je de afhankelijke eigenschappen aanpast.

Je moet hier wel een methode schrijven waar je bepaald welk de gerelateerde eigenschappen zijn. Het kan ook dat je gewoon een functie schrijft die een bepaalde formule uitvoert zonder dat er een gerelateerde eigenschap achter hangt.

De naam van de functie is niet standaard te kiezen. Je kan best eerst alles builden om de naam te achterhalen. Hij zal dan een foutmelding geven dat er een bepaalde methode ontbreekt. Die methode schrijf je dan in een aparte class die dezelfde naam heeft als het element van de eigenschap.

1. Selecteer de gewenste domain property

2. Verander de property kind naar calculated

3. Transform all templates en rebuild

4. Krijg je foutmelding

5. Maak nieuwe klasse aan in DSL

6. Zorg voor de juiste klasse bij “public partial XXX” -> xxx is domain class name

7. Schrijf de functie die ontbreekt (zie foutmelding voor de naam)

8. Voer dan je acties toe en return het resultaat

Stel dat: De maxlength van een attribuut van een class is afhankelijk van het type. Dan moet je deze class schrijven:

Public partial class ModelAttribute{

Public Int GetMaxlengthValue(){

If(this.Type.equals(“String”)){

Return 255;}else{

Return 50;}}

}

5.4.3.3 Custom Storage

Dit gaat eigenlijk een stap verder als calculated. Het verschil is dat dit de eigenschap niet read-only maakt. Je kan het attribuut aanpassen maar hier is het mogelijk dat wanneer je het attribuut aanpast, dat je dan ineens de afhankelijke attributen aanpast. Hier is natuurlijk voorzichtigheid geboden want als je het verkeerd invult, zal hij misschien één van de twee afhankelijke eigenschappen niet mee aanpassen.

24

1. Selecteer de gewenste domain proportie

2. Verander de proportie kind naar customStorage

3. Transform all templates en rebuild

4. Krijg je foutmelding

5. Maak nieuwe klasse aan in DSL

6. Zorg voor de juiste klasse bij “public partial XXX” -> xxx is domain class name

7. Schrijf de functie die ontbreekt (zie foutmelding voor de naam)

8. Voer dan je acties toe en return het resultaat

Hier heb ik in je in plaats van een Get-methode een Set-methode nodig. Om het voorbeeld van hierboven aan te vullen:

Public void SetMaxLength(int newValue){

If(newValue==255){this.Type=”String”;

}else{this.Type=”Integer”;

}}

5.4.4 Sleuteleigenschap bepalen

Sleuteleigenschappen zijn standaard niet nodig omdat elk element een ID toegewezen krijgt. Maar ID’s zijn niet echt bruikbaar wanneer je interacties gaat doen in code later. Daarom is het handig om een domainproperty als vervanging te kiezen. Hiervoor moet je bepaalde instellingen aanpassen.

1. Selecteer de gewenste domainproperty

2. Verander de proportie “IsElementName” naar true

3. Ga naar de DSL explorer

4. Zoek in de categorie “XML Serialization Behavior” naar het bijhorende element

5. In element data selecteer je dan de element data waar je “IsElementName” verandert hebt.

6. Verander “IsMonikerKey” naar true

25

Vanaf nu zal de domainproperty gelden als ID in je model. IsElementName moet niet op true staan maar is wel belangrijk wanneer je meerdere items aanmaakt. Want dit moet namelijk identiek zijn anders kan je problemen krijgen wanneer je het voor de tweede keer wilt openen.

5.4.5 Decorators toekennen

Eigenschappen kunnen soms iets bepalend zijn voor je diagram. Standaard zal een bijhorende shape niets tonen van gegevens. Dit kan je oplossen door decorators. Een decorator kan je op alle soorten shapes toevoegen. Dus ook op connectoren is het mogelijk om bijhorende tekst te voorzien. Er bestaan twee types: text decorator en icon decorator.

5.4.5.1 Text Decorator

Wanneer je bijvoorbeeld de naam wil weergeven van een class moet je een decorator aanmaken in de bijhorende shape. Dit doe je steeds door via rechtermuisknop op add text decorator. Je bepaalt dan de naam van de decorator en waar dat de decorator moet komen op de plaats.

Een text decorator moet ook nog gelinkt worden aan een eigenschap. Dit doe je niet in de shape zelf maar in de link tussen de shape en het element.

1. Selecteer de link

2. Ga naar het venster “Dsl Details”

3. Ga naar het tabblad “Decorator maps”

4. Selecteer de decorator

5. Selecteer bij display proportie de gewenste eigenschap

6. Bepaal eventueel een filter (dit is alleen voor enumeraties) wanneer het geldt.

Vanaf nu zal dus de eigenschap te zien zijn op de plaats die je bepaald. Wanneer je twee decorators op eenzelfde plaats zet, zal hij het op elkaar zetten. Daarom is het best om eerst na te denken waar je het plaatst. Hij houdt dus geen rekening van: hier staat al een decorator dus moet ik naar beneden. Je kan wel manueel bepalen waar het moet komen via de verticaal of horizontal offset. Hiermee kan je echt bepalen waar de decorator moet komen. Opgelet: dit gaat niet met grote stappen. Wanneer je twee zaken ondereen wil plaatsen is het voldoende om een vertical offset te nemen van 0.15.

5.4.5.2 Icon Decorator

Hier is eigenlijk niet veel verschil met de text decorator. Het enige verschil is misschien dat een icon decorator meestal niet af hangt van een eigenschap. Hier kan je gewoon een icoon plaatsen in het element. Het icoon zal dan in elk element identiek zijn. Het kan wel dat je het laat afhangen van een eigenschap. Wanneer je bv een icoon wil tonen als de eigenschap multiplicity op 0..* moet je een filter instellen op de icon decorator op dezelfde manier als bij een text-decorator.

26

5.5 Groeperen van elementen

Het is mogelijk om elementen te groeperen. Hierbij moet je een abstract element aanmaken. Dit doe je door de proportie “inheritance modifier” in te stellen op abstract. Elk element kan je een base class toe verwijzen. Dit gaat enkel met abstracte elementen.

Het handige aan gegroepeerde elementen is dat je relaties kunt leggen naar meerdere elementen door gewoon een relatie te leggen tussen een element en de groep. Een groep is meestal een groep van gelijkaardige objecten. Het is ook mogelijk één domainproporty op de groep aan te maken zodat die overal bestaat in de subelementen.

Een gegroepeerd element moet niet per sé verbonden zijn met een element. Het kan ook gewoon dienen als een verzameling voor bepaalde elementen die dezelfde eigenschappen hebben. Je kan dus een boomstructuur ontwikkelen zodat groepen van elkaar overerven. Ook voor decorators kan dit handig zijn. Een decorator kan je dan maar één keer toewijzen aan een gegroepeerde eigenschap. Let wel op dat je dan ook een gegroepeerde structuur van shapes voorziet. Je moet dan ongeveer dezelfde structuur uitbouwen met een abstracte shape.

Relaties kan je ook groeperen. Als je verschillende types van relaties hebt tussen dezelfde elementen kan je een extra relatie leggen maar een abstracte. Het verschil is dat je zo eigenschappen kan toekennen aan alle relaties zonder dat je dat meerdere keren opnieuw moet doen.

5.6 Acties op shapes

Shapes dienen enkel voor het uiterlijk van elementen. Maar het is mogelijk dat het uiterlijk afhankelijk is van sommige eigenschappen. Daarom kan je zorgen dat wanneer je de eigenschap aanpast. Dat de lay-out automatisch mee wijzigt.

1. Maak dus de nieuwe class aan

2. Schrijf een functie die alles initialiseert.

protected override void InitializeResources(StyleSet classStyleSet){base.InitializeResources(classStyleSet);AssociationConnector.AssociateValueWith(this.Store, Association.TypeDomainPropertyId);}

3. Schrijf een algemene functie “onPropertyChanged”, dit is de functie die wordt opgeroepen wanneer je iets verandert aan een proportie van het element waartoe de shape behoort.

protected override void OnAssociatedPropertyChanged(PropertyChangedEventArgs e) {

}

27

4. Maak een if-methode om de juiste proportie te halen. Je vergelijkt eigenlijk gewoon de naam tussen “” met de e.propertyName via de equals – methode.

5. Schrijf dan een switch methode die de nieuwe waarde opvangt en cast naar het gewenste type. Je vergelijkt het dan met mogelijke waardes per case.

6. Verander het object door this.(item) = .....

28

5.7 Rules en validatie

Niet alles is toegelaten, daarom moet je soms via code alles controleren. Om een voorbeeld te nemen: Overerving kan niet in beide richtingen gebeuren, daarom moet je ervoor zorgen wanneer je een nieuwe overerving tekent, dat er wordt gecontroleerd of er al één bestaat tussen de twee classes. Dit geldt ook voor overerving van zichzelf, dit wordt niet toegelaten. Daarom moet je dus een regel schrijven dat dit verbied.

Aanmaken regel:[RuleOn(typeof(Generalization), FireTime = TimeToFire.TopLevelCommit, InitiallyDisabled = true)] internal sealed class CyclicInheritanceAddRule : AddRule { public override void ElementAdded(ElementAddedEventArgs e) { string message = string.Empty; Generalization g = e.ModelElement as Generalization; if (g != null) { if (!CyclicInheritanceAddRule.TestValidInheritance(g.Subclass, g.Superclass, ref message)) { throw new InvalidOperationException(message); } } base.ElementAdded(e); }

Testmethode:internal static bool TestValidInheritance(ModelClass sourceClass, ModelClass targetClass, ref string errorMessage) { if (sourceClass != null && targetClass != null) { if (object.Equals(sourceClass, targetClass)) { errorMessage = "Reflexive inheritance detected."; return false; }

ModelClass current = targetClass.Superclass;

// Loop until we detect an exisiting loop or the root of the hierarchy. while (current != null && current != targetClass) { if (object.Equals(current, sourceClass)) { errorMessage = "Inheritance loop detected."; return false; }

29

current = current.Superclass; } } return true; }

5.8 Custom Editor instellen

Omdat je niet altijd voor alles een vaste enumerator kan je een eigen editor schrijven. Dit zorgt ervoor dat je bijvoorbeeld een listbox kan maken met alle namen van de aanwezige classes. Dit kan dus handig zijn als je informatie wil bijhouden rond bepaalde elementen zonder dat er noodzakelijk een link ligt.

Wanneer je zoals bij een attribuut van de class wil dat je een eigen lijst hebt met types dan kan je dit hier ook bepalen. Meestal zal dit een listbox zijn. Het voordeel is dan dat je ook nieuwe waarden kan ingeven die niet in de listbox staan. Bij standaard enumeraties heb je enkel de keuze uit de mogelijkheden van de enumeratie. Hierbij is het mogelijk dat je met nieuwe elementen komt zonder dat je die moet gaan toevoegen in de listbox.

Voorbeeld lijst met types:

1. Maak een nieuwe class aan

2. Instellen van using references

using System;using System.Collections;using System.ComponentModel;using System.ComponentModel.Design;using System.Diagnostics;using System.Drawing;using System.Drawing.Drawing2D;using System.Drawing.Design;using System.Windows.Forms;using System.Windows.Forms.Design;using Microsoft.VisualStudio.Modeling.Design;

3. Overerven van base UITypeEditor

4. StandaardCode toevoegen (voor listbox toch)

private IWindowsFormsEditorService _wfes; public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) { if (context == null) { return base.GetEditStyle(context); } return UITypeEditorEditStyle.DropDown; } protected void List_Click(object pSender, EventArgs pArgs)

30

{ if (_wfes != null) { _wfes.CloseDropDown(); } }private DialogResult ShowForm(IServiceProvider provider, Form form){IUIService service = (IUIService)provider.GetService(typeof(IUIService));if (service != null){return service.ShowDialog(form);}return form.ShowDialog();}

5. Main Methode toevoegen

public override object EditValue( ITypeDescriptorContext context, IServiceProvider provider, object value) { if ((context == null) || (provider == null) || (context.PropertyDescriptor == null)) { return base.EditValue(context, provider, value); }

_wfes = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)); ListBox listBox = new ListBox(); listBox.Sorted = true; listBox.Click += new EventHandler(List_Click);

listBox.Items.Add("Boolean"); listBox.Items.Add("Byte"); listBox.Items.Add("Char"); listBox.Items.Add("Currency"); listBox.Items.Add("DateTime"); listBox.Items.Add("Decimal"); listBox.Items.Add("Document"); listBox.Items.Add("Double"); listBox.Items.Add("Email"); listBox.Items.Add("Guid"); listBox.Items.Add("HyperLink"); listBox.Items.Add("Integer"); listBox.Items.Add("Object"); listBox.Items.Add("Password"); listBox.Items.Add("Picture"); listBox.Items.Add("PrimaryKey"); listBox.Items.Add("RichString"); listBox.Items.Add("Single"); listBox.Items.Add("String"); listBox.Items.Add("TimeSpan");

31

listBox.Items.Add("ForeignKey"); listBox.SelectedItem = value;

_wfes.DropDownControl(listBox); return listBox.SelectedItem; }

6. Custom attribute toekennen aan proportie:

System.ComponentModel.EditorAttributetypeof(QFrame.DSLModel2.PropertyTablePropertyEditor)typeof(System.Drawing.Design.UITypeEditor)

7. Transform all templates en buid solution

32

6 DSL-MODEL BEKIJKENWanneer je een model hebt ontwikkelt wil je het natuurlijk bekijken. Een model is eigenlijk een platform waarbij je elementen kunt op slepen. Het model is zo groot als je maar wenst, er zijn geen echte grenzen. Een model wordt altijd opgestart wanneer je een DSL-project runt.

Op zich lijkt dit echt op een gewoon project want alles is er aanwezig van een gewone Visual Studio. Er is een toolbox, solution Explorer, Proporties, … maar het verschil zit vooral de eigen elementen. Je toolbox is volledig aangepast aan de elementen die jij hebt toegevoegd. Er is de mogelijkheid om een menuoptie bij te creëren in de menubalk of een eigen contextmenu als je op je rechtermuisknop klikt.

6.1 Elementen toevoegen

Een element toevoegen kan meestal door het slepen van elementen uit de toolbox. De editor zal het element ook plaatsen waar dat je het sleept. Het is niet zoals bij het ontwerpen van DSL dat de elementen automatisch ondereen komen. Je bent hier echt vrij om te slepen. Je kan zelfs elementen op elkaar plaatsen.

Sommige elementen hangen natuurlijk vast aan een bepaald element. Wanneer je dan een verkeerde actie doet, zal je een verbodsteken krijgen. Dit betekent dus dat het element hier niet hoort. Subelementen zijn zo een voorbeeld die je enkel kan toevoegen aan compartimenten. Wanneer die ontbreken kan je geen subelementen aan je model toevoegen.

Om connnectoren toe te voegen heb je steeds twee elementen nodig. Een element dat als bron dient en een element dat als target dient. Dit hoeven wel geen twee verschillende elementen te zijn, je kan ook een connector aanmaken tussen één element waarbij de bron en target identiek zijn.

6.2 Overzicht elementen bekijken

33

Er bevindt zich in het dsl-model een apart scherm. Dit dient ervoor om een overzicht te krijgen van alle elementen. Wanneer je grote schema’s hebt en je kan niet alles direct terugvinden kan je dat zeker met de Class Diagram Explorer . Dit is eigenlijk een overzicht uit xml. Hier zijn alle elementen gewoon gerangschikt zonder al die tekeningen. Wanneer je dus een element zoekt kan je het hier opzoeken en kan je dezelfde acties doen die je anders op het element kunt doen. Bij kleine schema’s is het beter om in het diagram te doen dan hier. Relaties kan je hier ook niet leggen dus dat ben je wel verplicht in het model.

34

7 COMMANDO INSTELLEN DSL-MODELDe tweede stap eigenlijk om er voor te zorgen dat je DSL-model klaar is voor generatie van code of voor andere zaken. Anders blijft je model toch op zichzelf en is er buiten de weergave van modellen geen andere functie.

Standaard zijn er geen commando’s verzien buiten op een compartiment shape. Dus bijvoorbeeld op een class om attributen toe te voegen. Maar het is mogelijk om dus hier extra methoden te voorzien. Commando’s kunnen ofwel in het contextmenu als je op rechtermuisknop klikt of in de menubar zelf.

Je kan ook de menu’s indelen per categorie. Achter een menu-item kan je dan code toevoegen om bepaalde acties uit te voeren. Voorbeelden rond mogelijke commando’s zijn om connectoren van stijl te veranderen. Je kan voor elke stijl een menucommando voorzien.

Een menu commando zit altijd gespreid over drie bestanden:

- Commands.vsct- Constants.cs- Commandset.cs

7.1 Aanmaken menu commando’s

Alle commando’s worden gedefinieerd en gecatalogiseerd in het bestand: Commands.vsct. Standaard zit er één bestand in DSLpackage maar die is leeg buiten de zes basisitems die je zeker nodig hebt in een vsct-bestand.

<Extern href="stdidcmd.h"/> <Extern href="vsshlids.h"/> <Extern href="msobtnid.h"/> <Extern href="virtkeys.h"/> <Extern href="DSLToolsCmdID.h"/> <Include href="GeneratedCode\GeneratedVsct.vsct"/>

Dit is een soort van xml-file waarbij je vijf categorieën hebt:

7.1.1 Symbols

Hier maak je eigenlijk het object aan. Elk item moet hier gedistantieerd worden anders kan je het niet gebruiken in de andere categorieën. Je moet bijna altijd twee items creëren voor één menucommando. Een commando moet je altijd toekennen aan een bepaalde groep. Een groep heeft ook altijd een item nodig. Bij veel commando’s kan je best in groepen verdelen om een beter overzicht. Daarom moet je zelfs de groep nog eens toekennen aan een groep.

Een symbol bestaat steeds uit een naam en een waarde. Die waarde moet verplicht uniek zijn anders ga je problemen krijgen later. Je moet ook rekening houden dat je best de basisitems voor de commands de laagste waarden toekent. Dit enkel om structuur te houden want die waardes heb je nodig in het bestand constants.cs.

Er is ook een standaard symbol om je collectie in op te slagen. Dit heeft als waarde een registerwaarde. Dit is nodig omdat de menu-items eigenlijk worden opgeslagen in het register.

35

<GuidSymbol name="guidCmdSet" value="{322191bb-83c0-4781-a974-9f30973980ff}" >

Er zijn wel enkele uitzonderingen. Standaard bied Visual studio al een uitgebreide set van Commands. Er zijn meer dan honderden standaardwaarden. Echt een lijst is hier niet van opgesteld, je vindt ze wel terug als je in de subfolder van de Visual studio SDK gaat kijken: Visual studio integration/inc. Hier vind je veel .h bestanden, je zoekt hier de vijf bestanden die bovenaan in het .vsct worden toegevoegd en in die bestanden vind je al de gebruikte ID’s.

7.1.2 Commandplacements

De naam zegt veel: hier plaats je eigenlijk de commando’s in de juiste groep. Bij elk commando moet je de correcte IDSymbol naam toekennen aan de ID. Omdat een commandplacement zelden alleen voorkomt, ken je het toe aan een parent-element waarbij je dan de juiste IDSymbol invult. Guid is steeds de verbinding tussen alle elementen.

<Naam> = naam<parent>= waar de groep toe behoort<volgorde> = volgorde van de items

<CommandPlacement guid="guidCmdSet" id="<naam>" priority="<volgorde>" > <Parent guid="guidCmdSet" id="<parent>"/></CommandPlacement>

7.1.3 Buttons

Elk item dient als een knop want je moet in staat zijn om er op te klikken. Daarom moet je hier ook definiëren om bepaalde standaardwaarden toe te kennen. Hier is het mogelijk om ervoor te zorgen dat de menu standaard is gedisabled of niet zichtbaar is.

Je bepaalt ook de tekst die wordt weergegeven.

<Button guid="guidCmdSet" id="<naam>" priority="<volgorde>" type="Button"> <Parent guid="guidCmdSet" id="<parent>"/> <CommandFlag>DefaultDisabled</CommandFlag> <CommandFlag>DefaultInvisible</CommandFlag> <CommandFlag>DynamicVisibility</CommandFlag> <Strings> <ButtonText><titel></ButtonText> </Strings></Button>

7.1.4 Menu’s

Hierbij maak je menu’s aan. Dit zowel voor contextmenu’s als voor menu’s bovenaan. Bij menu’s kan je ook werken met gegroepeerde items. Ofwel plaats je dus een groep in het menu ofwel plaats je gewoon een item in een menu. Elke groep in de contextmenu werkt dus ook met een menu-item.

<Menu guid="guidCmdSet" id="<Naam>" priority="<volgorde>" type="Context"> <Parent guid="guidCmdSet" id="<parent>"/> <Strings>

36

<ButtonText><titel></ButtonText> </Strings></Menu>

7.1.5 Groups

Een group is eigenlijk een collectie van menucommands. Hierbij bepaal je dus tot welke group de group eventueel zelf behoort. Een van de belangrijkste items want zonder een Group kan je geen menucommando’s toevoegen. Hier instantieer je alleen maar de groups. In “Menus” en “Button” voeg je items toe aan de groepen.

<Group guid="guidCmdSet" id="<Naam>" priority="<volgorde>"> <Parent guid="guidCmdSet" id="<parent>"/></Group>

7.2 Toewijzen constanten

De tweede stap bij het aanmaken van menucommando’s. Elk menucommando kan niet herkend worden als er geen constante voor gedefinieerd wordt. Een constante is de link tussen Commands.vsct en Commandoset.cs. Veel lijnen bevat dit bestand niet, per commando bevat dit één lijn.

De structuur van een commando is als het volgt:

<naam> = elk commando heeft een naam nodig<id> = deze naam vind je terug in de constants.cs bij generatedCode.<waarde> = dit is de waarde van het item. Dit vind je terug bij commands.vsct in de categorie symbols.

public static readonly CommandID <naam> = new CommandID(new Guid(<ID>), <waarde>);

7.3 Acties toekennen aan Commando

De laatste stap in het maken van een commando. Elk commando heeft een achterliggende actie. Standaard is die niet aanwezig wanneer je een nieuwe commando aanmaakt.

Zonder wijzigingen in het commandoset.cs zal je niets zien in het model. Want commandoset.cs bevat de belangrijkste zaken voor een commando. Hier volgt hoe je een commando nu echt toevoegt aan je model en hoe je er acties toekent. Alles gebeurt in de file “commandoset.cs”.

7.3.1 Toevoegen aan model:

1. Override de menuoptie: GetMenuCommands ()

2. Begin onder de baselijn: IList<MenuCommand> commands = base.GetMenuCommands();

3. Voeg een command toe via commands.Add()

37

4. Als parameters geef je mee: new Microsoft.VisualStudio.Modeling.Shell.DynamicStatusMenuCommand(a,b,c)

5. DynamicStatusMenuCommand bevat zelf ook drie parameters.

a. Eerst geef je de functie die bepaald wanneer het menu getoond wordt

b. De functie die bepaalt wat het commando moet doen

c. Hier geef je de constante in die behoort tot de menucommando. Elk constante begint met constants en dan de naam van de constante. Dit vind je terug in constants.cs.

6. Zo ga je verder voor elk commando

7.3.2 Statusfunctie bepalen:

Statusfunctie is iets belangrijk maar kan voor meerdere commando’s dienen. Dit moet je maar één keer schrijven als het voor drie commando’s geldt. Hier kan je bijvoorbeeld controleren of het bestand wel een model is of dat het menucommando enkel geldig is wanneer je een class selecteert.

1. Schrijf de hoofding

2. Vang het menucommando op: MenuCommand command = sender as MenuCommand;

3. Schrijf een if-functie om te controleren of het niet null bevat

4. Bepaal welke status het heeftVoorbeeld uit mijn project:

internal virtual void OnStatusSelect(object sender, EventArgs e) { MenuCommand command = sender as MenuCommand; if (command != null) { command.Visible = true; if

(this.CurrentDocData.Store.ElementDirectory.FindElements<ModelRoot>().Count > 0)

{ command.Enabled = true; } else { command.Enabled = false; } }

38

}

Dit zal er dus voor zorgen dat de menucommando’s die deze functie als status gebruiken enkel zichtbaar zijn als het een model is. Een model bevat altijd een modelroot.

7.3.3 Actie bepalen

Actie is eigenlijk de hoofdfunctie van een commando. Deze code wordt uitgevoerd als je het commando selecteert. Hier kan je van alles uitvoeren: formulieren tonen, objecten toevoegen, objecten onzichtbaar maken, ….

1. Schrijf de hoofding

2. Bepaal de acties naar wat je wenst

Voorbeeld uit mijn project:

internal virtual void OnMenuShowClass(object sender, EventArgs e){ foreach (TableShape table in this.CurrentDocData.Store.ElementDirectory.FindElements<TableShape>()) { table.Hide(); } foreach (ClassShape classe in this.CurrentDocData.Store.ElementDirectory.FindElements<ClassShape>()) { classe.Show(); } foreach (ManyToManyAssociationShape many in this.CurrentDocData.Store.ElementDirectory.FindElements<ManyToManyAssociationShape>()) { many.Show(); }

}

Bij dit commando gaat hij al de soorten objecten af. Wanneer het een tabel is zal hij de tabel onzichtbaar maken. Een class of een manytomanyassociation zal hij laten tonen. Natuurlijk is hier een gelijkaardige functie op die het omgekeerde doet en een functie die alles toont.

39

8 GEBRUIK VOOR GENERATIEGeneratie van bestanden is geen standaard voor een DSL-Model. Er zijn wel twee kleine voorbeelden aanwezig maar dat gaat steeds over één bestand. Maar het is meestal niet de bedoeling om alles in een bestand te generen. Eigenlijk kan je alles integreren in DSL door middel van de commando’s. Generatie is een van de belangrijkste doelen voor een DSL-Model in mijn project.

Genereren gebeurt via T4-templates. Dit is een methode die je kan gebruiken voor alle soorten bestanden zoals .html, .cs, .vb, .jsp, … wanneer je het bestand beziet zal het vrij gelijkaardig zijn aan het type bestand dat je wenst. Enkel zal je stukken code in het bestand zien staan tussen <# #> tekens. Je hebt drie soorten:

- <# #> wanneer je variabelen wil toekennen of iets in code wil uitvoeren.- <#= #> schrijft iets neer in het bestand. Hiermee kan je variabelen afdrukken in het

bestand- <#+#> is bedoeld om methodes te schrijven. Hier schrijf je alle methodes die je kan

gebruiken in je template.

Het is mogelijk om met If-structuren en lussen te werken zodat je dezelfde code kunt gebruiken voor een heel collectie. Ook kan je methodes schrijven die je bijkomende code vergemakkelijken. Eigenlijk is het herkenbaar voor iemand die C# schrijft of een andere programmeertaal. Alles kan je hiervan gebruiken. Je kan ook Libraries gebruiken door ze te importeren, zo kan je zelfs eigen gebruikte methodes schrijven zodat je de templates zoveel mogelijk spaart van extra code.

Templates worden opgeslagen in het model zelf. Je kan dus de templates niet bekijken wanneer je het model opgestart hebt. Eigenlijk bepaal je het zelf maar voor de commando’s is het gemakkelijker dat je ze in de resources map bewaard onder DSLpackage.

Een template omzetten naar code gebeurt niet zomaar. Je hebt een processor nodig. Dit is een soort van omzetter voor de templates. Standaard wordt er telkens één aangemaakt wanneer je een nieuw DSL-model opstelt. Maar de processor kan geen filter aan dus daarom zal je deze processor moeten aanpassen zodat je kunt zorgen dat de templates enkel gelden voor één element of één categorie uit het model.

8.1 Instellen processor

Wanneer je iets wil aanpassen moet je altijd een extra class maken die dezelfde naam gebruikt als de bestaande class. Hij zal dan rekening houden met beide classes. Zo kan je de functies schrijven die dienen om een parameter toe te voegen aan de class DirectiveProcessor.

1. Aanmaken eigen class

2. Verander hoofding van de class naar : public sealed partial class <modelnaam>DirectiveProcessor

3. Schrijf de methode voor de extra property. Dit is van het type required omdat dit een verplicht veld is. Het moet ingevuld worden anders zal het fout lopen.

40

protected override void InitializeRequiresDictionary(string directiveName, System.Collections.Generic.IDictionary<string, string> requiresDictionary)

{ base.InitializeRequiresDictionary(directiveName, requiresDictionary); requiresDictionary.Add("name", Guid.Empty.ToString()); }

4. Schrijf eventueel een methode wanneer je wenst als je met twee modellen in één template wil werken. Bepaald ook de naamgeving van this.(argument). (optioneel: leeg laten betekend dat je gewoon de standaard gebruikt this.Table)

protected override void InitializeProvidesDictionary(string directiveName, System.Collections.Generic.IDictionary<string, string> providesDictionary)

{

base.InitializeProvidesDictionary(directiveName, providesDictionary);

providesDictionary.Add("Table", "Table");

}

5. Als je helemaal wil gebruik maken van “this.<naam>” in je templates moet je een variabele toevoegen en een proportie. Dit gebeurt in de override methode GenerateTransformCode

protected override void GenerateTransformCode(string directiveName, StringBuilder codeBuffer, System.CodeDom.Compiler.CodeDomProvider languageProvider, System.Collections.Generic.IDictionary<string, string> requiresArguments, System.Collections.Generic.IDictionary<string, string> providesArguments) { base.GenerateTransformCode(directiveName, codeBuffer, languageProvider,

requiresArguments, providesArguments); codeBuffer.AppendLine("private Table _" + providesArguments["Table"] +

";"); codeBuffer.AppendLine("public Table " + providesArguments["Table"] +

"{ get { return _" + providesArguments["Table"] + " ; } }"); }

6. Als laatste moet je dan de methode schrijven die enkel de tabel die je wenst filtert.

protected override void GeneratePostInitializationCode(string directiveName, System.Text.StringBuilder codeBuffer, System.CodeDom.Compiler.CodeDomProvider languageProvider, System.Collections.Generic.IDictionary<string, string> requiresArguments, System.Collections.Generic.IDictionary<string, string> providesArguments)

{

base.GeneratePostInitializationCode(directiveName, codeBuffer, languageProvider, requiresArguments, providesArguments);

41

// Initialize the ModelClass property

codeBuffer.AppendLine(@"foreach (Table eachTable in this.Store.ElementDirectory.FindElements<Table>())");

codeBuffer.AppendLine(@"{");

codeBuffer.AppendLine(@" if (StringComparer.Ordinal.Compare(eachTable.Name, """ + requiresArguments["name"] + @""") == 0)");

codeBuffer.AppendLine(@" {");

codeBuffer.AppendLine(@" this._" + providesArguments["Table"] + " = eachTable;");

codeBuffer.AppendLine(@" break;");

codeBuffer.AppendLine(@" }");

codeBuffer.AppendLine(@"}");

}

8.2 Opstellen Templates

Templates bestaan meestal uit twee delen. Eventueel een derde deel kan als je extra methodes nodig hebt. Een template heeft altijd een hoofding waar je alles toevoegt van libraries en ook bepaal je welke processor je nodig hebt om de templates te laten omzetten naar code. Een ander deel is de code zelf. Dit deel bevat meestal een hoop tekst met delen code. Het derde deel kan als je met uitgebreide functies zit om informatie op te halen.

8.3 Aanmaken Templates

Er zijn twee manieren: ofwel kies je ervoor om met losse templates te werken of je kan zorgen dat je aan de templates een constante toewijst. Je hebt sowieso een soort van collectie nodig die alle templates bijhoudt. Daarom kan je een Dictionary aanmaken in code waarbij de locatie en de naam bijgehouden wordt van de templates. Zo kan je snel de juiste template achterhalen.

8.3.1 Losse templates

Je kan ervoor kiezen om met losse locaties te werken. Wanneer je telkens andere templates nodig hebt is dit een goede keuze. Vooral bij het testen van nieuwe templates kan dit handig zijn. Dan moet je de locatie wel telkens aanpassen maar dit gaat zo sneller dan er steeds constante waarde aan vast te hangen.

In je templatedictionary plaats je de locatie van de templates. Elk template moet je zeker een naam geven om later de juiste template terug te kunnen vinden. Wanneer je werkt met één folder waar alle templates zich bevinden, werk je dus best met een variabele waar je de locatie invult. Zo moet je dat niet op twintig plaatsen aanpassen.

Voorbeeld van een templatedictionary:

42

Dictionary templates = new Dictionary()

templates.Add(new KeyValuePair<”Action_cs”,”c://”>());

templates.Add(new KeyValuePair<”Action_vb”,”c://”>());

templates.Add(new KeyValuePair<”BL_vb”,”c://”>());

8.3.2 Templates via constante waarden

Er is een mogelijkheid om de templates in een bestand te steken en er een constante aan toe te kennen. Dit heeft het voordeel dat je niet heel de locatie moet overtypen om de template te bemachtigen. Het is veel gebruiksvriendelijker in je systeem. Zo maak je minder kans op fouten in de locatie. Wanneer je lange locaties hebt, kan het zijn dat je typefouten maakt en zo krijg je natuurlijk last dat hij een template niet vindt.

1. Open het bestand VSPackage.resx

2. Ga naar de categorie Files

3. Voeg de templates toe

Nu kan je de templates makkelijk bereiken door VSPackage.action bijvoorbeeld. Dit zal dan de achterliggende file ophalen.

8.4 Template schrijven

Een template schrijven begint altijd met een hoofding. De hoofding bevat de belangrijke lijnen voor de omzetting. Dit bevat voornamelijk het type processor. In mijn project was dat een aangepaste processor met twee parameters: één die de naam van het bestand bevatte en een die de naam van de tabel bevatte.

Voorbeeld: <#@ DSLModel2 processor=”DSLModel2DirectiveProcessor” requires=”filename=’<@@filename@@>’,tablename=’<@@tablename@@>’” #>

Het speciale is dat de beide parameters toegekend zijn met een soort van variabele. Deze variabele zal door de methode worden omgezet naar de juiste gegevens.

Het is mogelijk om namespaces te declareren zodat je in de code niet de volledige naam van types moet ingeven. Dit doe je door de namespace te importeren:

Voorbeeld: <#@ import namespace=”System.Collections.Generic” #>

Wanneer je een dll wil gebruiken in je templates kan je die dan toekennen door een assembly toe te voegen:

Voorbeeld: <#@ assembly name=”System.Drawing.dll” #>

Meestal kan je automatisch de extensie bepalen en de encoding van het bestand. Dit is enkel noodzakelijk wanneer je de template gebruikt voor een heel model. Wanneer je met de methode werkt zal je de extensie toekennen in de methode en niet in de template.

43

Voorbeeld: <#@ output extension=”.cs” encoding=”utf-8” #>

Templates kan je ook combineren door een template te includen. Dit is misschien handig las je een template in meerdere templates kan gebruiken. Zo vermijd je herhaling:

Voorbeeld: <# include file=”FileToInclude.tt” #>

8.5 Methode schrijven

Er is natuurlijk een methode nodig die zorgt dat je de template kan gebruiken voor meerdere files te genereren. In feite gaat hij de parameters vervangen door de juiste gegevens. Dus zal hij steeds de tabelnaam en de bestandsnaam bepalen door <@@filename@@> en <@@tablename@@> te vervangen met de correcte waarden.

Hij overloopt alle tabellen. Bij elke tabel zal hij de twee variabelen vervangen via een replacefunctie. Daarna zal hij door middel van de aanwezige templateservice de template omzetten naar code. Dit resultaat zal dan via een streamwriter worden weggeschreven naar het bestand met de juiste naam op de gekozen locatie.

Hier kan je natuurlijk zorgen dat je met bepaalde if-structuren of extra for-lussen ervoor zorgen dat het resultaat iets verschilt maar dit hangt er vanaf hoe uitgebreid dat je het wenst.

De eenvoudigste code ziet er als volgt uit:

private void GenerateTemplate(String extra, String baseTemplate, string genCodeDir, Table eachTable)

{

// Replace the marker text in the template with the name of the class to generate and the model file to load

string specificTemplate = baseTemplate.Replace("@@CLASSNAME@@", eachTable.Name);

specificTemplate = specificTemplate.Replace("@@MODELFILE@@", _genSettings.Dte.ActiveDocument.FullName);

string output = _genSettings.TemplatingService.ProcessTemplate("", specificTemplate, null, null);

string filePath = Path.Combine(genCodeDir, eachTable.Name + extra + "." + _genSettings.Extension);

if ((eachTable.ManyToManyAssociation!=null) && (filePath.Contains("Collection"))){

}else{

44

if (! File.Exists(filePath))

{

using (StreamWriter writer = new StreamWriter(filePath))

{

writer.Write(output);

writer.Flush();

}

}

else

{

using (StreamWriter writer = new StreamWriter(filePath))

{

writer.Write(output);

writer.Flush();

}

}

}

try

{

_genSettings.Project.ProjectItems.AddFromFile(filePath);

}

catch

{

}

}

45

8.6 Extra functionaliteiten schrijven

Er bestaat natuurlijk de mogelijkheid om er voor te zorgen dat de generatie zo optimaal mogelijk gebeurd. Je wilt niet altijd aan de standaardeisen voldoen. Je kan bijvoorbeeld voorzien dat je kunt zorgen dat je elk element kan laten bepalen of het standaard wordt mee gegeneerd. Wanneer je dan genereert moet je wel een if-functie aanmaken in je generatie methode. Die controleert dan de aangemaakte proportie van de tabel of het true of false is. Wanneer het false is, zal hij de tabel overslagen.

Je kan er ook voor kiezen om het resultaat naar een andere locatie te sturen dan naar de standaardlocatie. Dit heb ik opgelost door een commando die een folderbrowserdialog toont. Wanneer je dan een locatie selecteert zal dit worden bijgehouden in een algemene proportie. Dit kan je ook doen met bijvoorbeeld het path van de templates. Wanneer je templates wil gebruiken die niet op de standaardlocatie staan. Dit kan zijn als je lokaal wil testen of je templates in orde zijn voor generatie.

Een derde extra functie is dat je zelf de templates kunt selecteren. Wanneer je bijvoorbeeld maar één aangepaste template hebt, kan je de template selecteren via een formulier. In het formulier wijs je een categorie aan de template toe en geef je mee voor welke taal deze template dient. De gegevens worden dan bijgehouden in een collectie. Omdat collecties nog niet volledig worden ondersteund, zal hij de gegevens niet bijhouden wanneer je afsluit.

46

9 EXPORTEER DSL-MODELEen DSL-model exporteren kan omdat het eigenlijk een verzameling is van objecten. Je kan gegevens ophalen uit de objecten en ze dan omzetten naar andere soorten elementen. Je hebt enkel een project nodig die dit voor je regelt. Elk element wordt ingelezen en omgezet naar het nieuwe element.

Het enige moeilijke is eigenlijk de verzameling. Alle elementen zitten in een bepaalde store. In mijn project heb ik de store in een proportie gestoken van de export class zodat ik makkelijk de store kon gebruiken in de exportfunctie. Hij leest nadien alle elementen in en plaats die dan in de overeenkomende elementen. In de exportmethode kan je dan bepalen welke elementen er moeten worden geëxporteerd.

9.1 Gebruik maken store

Een store is een verzameling van alle aanwezige elementen. Dit wil niet zeggen alle zichtbare elementen. Het kan zijn dat je elementen toegekend hebt aan een store maar niet toegekend hebt aan een object. Dan loop je later het gevaar dat je met foute gegevens zit in een geëxporteerde resultaat.

Om u een overzicht te geven wat een store eigenlijk is:

U ziet hier eigenlijk gewoon een soort van boekenkast. Alle elementen staan hier in een bepaalde volgorde in. Ik heb ze gerangschikt via afhankelijkheid: groep 2 behoort tot groep 1 en groep3 behoort tot groep 2.

9.2 Schrijven basisclass

Je kan best met een basis class werken. Dit is een class die je makkelijk kan hergebruiken. Wanneer er verschillende mogelijkheden zijn om te exporteren, kan je deze class makkelijk gebruiken bij elke mogelijkheid. Dit werkt natuurlijk enkel voor tussen dezelfde type elementen. Wanneer je wenst te exporteren naar een ander soort van objecten dan moet je een nieuwe basis class schrijven die gebaseerd is op het andere model.

Een basis class bevat voor elk mogelijk object een functie en wanneer er verschillende importmogelijkheden zijn kunnen er meerdere functies voor hetzelfde object zijn. Deze functies kan je dan gebruiken in andere classes.

47

9.3 Schrijven export class

Een export class zorgt meestal voor de invoer en voor de structuur. Dit erft alles over van de basis class. Je overloopt hier alle elementen van het model dat je wil overlopen. Op basis van je noden bepaal je welke functies je nodig hebt en hoe dat je ze gebruikt.

Wanneer je bijvoorbeeld twee opties hebt om te exporteren kan je dus een verschillende export classes schrijven die wel gebruik maken van dezelfde basis class. De code verschilt wel maar de gebruikte functies blijven hetzelfde. Dit is voor hergebruik een groot voordeel. Je moet niet opnieuw elke functie gaan herschrijven als ze al bestaat. Het voordeel is ook als je de basis class gebruikt voor andere projecten dat je niet dezelfde code op tien plaatsen moet wijzigen.

48

10 IMPORTEER NAAR DSL-MODELImporteren gebeurt op dezelfde manier als exporteren. Het is een gebruik van objecten. Het enige verschil is dat ik hier twee mogelijkheden heb uitgewerkt. Hier heb ik een project geschreven die een DSL-model aanmaakt. Maar dit gebeurt nu niet in de DSL-editor. De basiscode blijft wel hetzelfde, maar de aanroepcode verschilt.

Het importeren is belangrijk voor oudere modellen of andere soorten modellen om te zetten naar DSL. Omdat het logisch is dat de bestaande generator voor een deel wordt hergebruikt, dat je hier ook een optie biedt om meteen te exporteren naar DSL. Er wordt dan een nieuw bestand aangemaakt op een gekozen locatie. Dit bestand heeft de extensie van het DSL-model en hier wordt de store aan toegevoegd.

10.1 Importeer vanuit DSL

Het importeren vanuit DSL vereist niet echt moeilijke code. Je zorgt ervoor dat de store van het bestaande bestand wordt doorgegeven aan de import-project. Zo wordt de store opgevuld met de correcte gegevens. In een formulier kies je dan het model dat je wenst te importeren. Dit model zal worden gebruikt voor importatie. De importfunctie zal alle elementen overlopen en toevoegen. Natuurlijk zal je een foutmelding krijgen als het model niet voldoet aan de eisen. Je kan enkel modellen importeren van hetzelfde type.

In principe is importeren hetzelfde als exporteren maar de omgekeerde weg. Het speciale is wel als je iets toevoegt moet je met twee zaken steeds rekening houden. Bij het aanmaken van een object, ken je het automatisch toe aan een store. Nadien vul je het nieuwe object gewoon op met de gegevens. Het object zit dan al wel in de store maar is niet toegekend aan de root bijvoorbeeld. Je gebruikt dan de ADD-functie van een collectie om dit object toe te kennen aan de root.

Wanneer je dus tijdelijk een object nodig hebt, kan je beter zorgen dat je zorgt dat het wordt verwijderd op het einde. Dit voorkomt foute gegevens in de store.

Voorbeeld:

Protected virtual ImportClass(string name, Table table)

{

ModelClass newClass = new ModelClass(store);

newClass.Name=name

newClass.Table=table;

Root.types.Add(newClass);

}

49

10.2 Importeren buiten DSL

Je zou denken dat als je kunt importeren in DSL dat je dit ook automatisch kan buiten DSL. Niets is minder waar, wanneer je in DSL importeert gebruik je automatisch de correcte store. Maar als je niet meteen beschikt over een store moet je een nieuwe aanmaken. Dit is niet het grote probleem, het is vooral het toekennen van de store aan een bestand. De store opvullen gebeurt op een identieke manier als in DSL eigenlijk automatisch doet wanneer je een DSL-model aanmaakt.

System.Runtime.Serialization.SerializationBinder binder = new DSLModelBinder(); NewModel = model; Store store = new Store(); Type[] modelTypes = new Type[] { typeof(Microsoft.VisualStudio.Modeling.Diagrams.CoreDesignSurfaceDomainModel), typeof(QFrame.DSLModel2.DSLModel2DomainModel)}; store.LoadDomainModels(modelTypes); //CoreDesignSurfaceDomainModel m1 = new CoreDesignSurfaceDomainModel(store); //DSLModel2DomainModel newModel = new DSLModel2DomainModel(store); string fileName = name+".leafDSL"; string filePath = Path.Combine(location, fileName); using (StreamWriter writer = new StreamWriter(filePath)) { writer.Flush(); } using (Transaction t = store.TransactionManager.BeginTransaction("Creating new diagram")) { DSLModel2SerializationHelper.Instance.LoadModel(store, filePath, null, null); StoreModel = store; Root = new ModelRoot(StoreModel); Root.AuditFields = false; Root.Name = NewModel.Name; ImportClasses(); ImportTables(); ImportRelations(); SetGeneralizations(); SetTableParent(); SetMultiplicity(); t.Commit(); } // Save the modelSerializationResult result = new SerializationResult(); DSLModel2SerializationHelper.Instance.SaveModel(result, Root, @filePath);

50

10.3 Positioneren Shapes

Omdat je toch een beetje structuur wenst in de objecten wanneer je iets imponeert, kan je ervoor kiezen om een bijkomende functie te schrijven die alle objecten overloopt en ze op een bepaalde logica rangschikt. Je kan er voor kiezen om alle gelijkaardige objecten onder elkaar te plaatsen. Dit zorgt voor een duidelijkere structuur dan wanneer alle objecten door elkaar staan.

Een echt diagram ga je moeilijk kunnen maken omdat een element geen vaste locatie heeft in een diagram. Maar eigenlijk heb je het niet echt in de hand, ook al schrijf je een degelijke functie, je zou bijna extra plaats moeten houden om zaken te scheiden. Hij doet het niet echt perfect, maar iets is beter dan niets zeggen ze vaak.

Voorbeeldcode hoe je een shape van locatie verandert:

Double x = diagram.AbsoluteBounds.Left;Double y = diagram.AbsoluteBounds.Top;int aantal = 0;foreach (ClassShape shape in this.CurrentDocData.Store.ElementDirectory.FindElements<ClassShape>()) { shape.AbsoluteBounds = new RectangleD(x, y, shape.Bounds.Width,shape.Bounds.Height); y += shape.Bounds.Height; aantal++; if (aantal == 10) { x+=shape.Bounds.Width; y = 0; } }

BESLUIT

LITERATUURLIJST

51

BIJLAGEN

1. Gegevens behandelen

Hij/zij kan gegevens verzamelen, opslaan en ter beschikking stellen, zodanig dat deze op een correcte en gebruiksvriendelijke manier kunnen worden opgevraagd.

Dit gaat over verschillende projecten. Elk project heeft wel oplossingen nodig en niet alle oplossingen zijn meteen aanwezig. Daarom is het steeds vereist om een bepaalde zaken op te zoeken op internet. Internet heeft niet altijd het juiste resultaat. Daarom moest ik altijd met gerichte zoektermen leren werken om tot de juiste oplossingen te vinden. Ook was het handig om bepaalde resultaten te bewaren om herhaling te vermijden.

In verband met het omgaan van gegevens voor een project kan ik als voorbeeld het asp-project nemen. Dit project had niet een kant en klare uitleg. Hier moest je over nadenken hoe je alles ging uitwerken door alle gegevens te verzamelen en die gegevens dan te verwerken in een paar modellen.

Gegevens uit grote gehelen halen was vooral nodig uit alle informatie uit het internet. Wanneer ik iets op zocht moest je steeds rekening houden met de echtheid van de gegevens. Daarom maak ik altijd een samenvatting met allemaal kleine puntjes zodat ik het begrijp zonder alle tekst te herlezen.

Gegevens moeten meestal via een login ter beschikking komen. In het asp-project moet alles wat aangepast kan worden of belangrijke informatie kon bevatten beveiligd worden met de juiste login. Elke login had zijn eigen rechten.

52

2. Analyseren

Hij/zij kan, zelfstandig of onder begeleiding en eventueel in teamverband, de informatiebehoeften van een organisatie gestructureerd en overzichtelijk weergeven.

Voor analyse was er eigenlijk een vak dat zich leidde naar juiste analyses. Elk project dat ik maakte had een analyse nodig. In begin is dat maar een kleine oppervlakkige analyse maar in de loop van mijn opleiding werd die analyse uitgebreider en gebruikte ik modellen die speciaal bedoelt waren om project vereisten te analyseren.

Het business project in het derde jaar was eigenlijk de grootste analyse. Dit project was eigenlijk een analyse van 13 weken om een file management systeem te ontwikkelen. Alle informatie om dit project te voltooien moest worden omgezet in een deftig plan van aanpak. Dit is een methode waar vele soorten informatie duidelijk wordt weergegeven zodat de klant gemakkelijk kan volgen. Dit zorgt er ook ineens voor dat ik bepaalde gegevens duidelijk en gestructureerd kon weergeven in een document.

Dit project had verschillende mogelijkheden voor een oplossing. Daarom was het ook nodig om elke optie duidelijk onder de loep komen en een vergelijkende studie te verrichten.

53

3. Oplossingen uitwerken

Hij/zij kan voor de organisatie nieuwe IT-oplossingen uitwerken, zodanig dat de opdrachtgever tevreden blijft.

Hier kan ik mijn stageopdracht goed gebruiken. Dit is een behoorlijk grote opdracht die toch de nodige structuur vereist. Voorwaarden waren bijvoorbeeld dat alles goed kan worden hergebruikt wanneer er veranderingen komen bij één van de stappen. Ook de code moet zo duidelijk mogelijk zijn. Ik heb ook rekening gehouden met de aanwezige structuur. Ik heb bekeken hoe het programmeren ginder werkte en heb uit de code geleerd om mijn code beter te structureren. Ook heb ik met allerlei trukken geleerd om code zo proper en om wijzigingen te doen in projecten.

Mijn project was ook een materie waar weinig informatie over beschikbaar is daarom was het vaak lang zoeken om tot een goede oplossing te komen. Dit heb ik zelfstandig allemaal moeten opzoeken en implementeren. Om dit allemaal duidelijk te houden voor andere heb ik alles wat niet echt duidelijk was om toe te passen gedocumenteerd in een handleiding. Er is ook voor de technische mensen een technical documentation opgesteld, deze is bedoeld voor aanpassingen aan de code.

Ik heb mijn project vaak getest door alle mogelijke manieren eens uit te testen. Ik had een checklist gemaakt waar alle opties aanwezig waren. Ik ben alles één voor één afgegaan om echt geen fouten te voorkomen. Dankzij de testen van mijn stagebegeleider kon ik ook weten hoe het systeem werkt op andere computers.

54

4. Oplossingen beheren

Hij/zij kan op een adequate wijze IT-oplossingen configureren, beveiligen en aanpassen, zodanig dat ze blijven beantwoorden aan de veranderende behoeften van de organisatie.

55

5. Projectmatig werken

Hij/zij is in staat om een opdracht op een projectmatige wijze aan te pakken, zodanig dat de planningen gerespecteerd worden.

56

6. Communiceren

Hij/zij kan mondeling en schriftelijk communiceren met alle betrokkenen, zodanig dat hij/zij zijn/haar gesprekspartners correct begrijpt en zijn/haar boodschappen helder overkomen.

57

7. Eigen gedrag aanpassen

Hij/zij is in staat om over het eigen gedrag te reflecteren en op basis daarvan het aan te passen zodanig dat hij/zij in wisselende omstandigheden optimaal kan functioneren.

58

8. Kwalitatief handelen

Hij/zij streeft naar kwaliteitsvolle taakuitvoering zodanig dat het resultaat voldoet aan de eisen van een steeds wisselende economische en maatschappelijke omgeving.

Alfabetische lijst van gebruikte afkortingenusers.telenet.be/hcorsmit/Eindwerk_hans_corsmit.docx ·...

Documents

Transcript of Alfabetische lijst van gebruikte afkortingenusers.telenet.be/hcorsmit/Eindwerk_hans_corsmit.docx ·...