MAGAZINE. IN DIT NUMMER O.A.:

SOFTWARE DEVELOPMENT NETWORK

MAGAZINE

IN DIT NUMMER O.A.:

Snel en Schaalbaar met Velocity Distributed Cache < SQL Server Integration Services in de Praktijk < XML-Parsing in COBOL < Create and use of Google maps web part < MVP: Most Valuable Pattern? <

Nummer 103 november 2009 SDN Magazine verschijnt elk kwartaal en is een uitgave van Software Development Network

103

www.sdn.nl

Advertentie Macaw

Colofon Uitgave:

voorwoord

Software Development Network Zeventiende jaargang No. 103 • november 2009

Bestuur van SDN: Remi Caron, voorzitter Rob Suurland, penningmeester Joop Pecht, secretaris Mark Vroom, vice-voorzitter

Redactie: Rob Willemsen ([email protected])

Aan dit magazine werd meegewerkt door: Maurice de Beijer, Anko Duizer, Paul Gielens, Christiaan Heidema, Marcel van Kalken, Stefan Kamphuis, Marcel Meijer, Mirjam van Olst, Johan Parent, Joop Pecht, Sandra de Ridder, Maarten van Stam, Bob Swart, Marianne van Wanrooij, Rob Willemsen en natuurlijk alle auteurs!

Listings: Zie de website www.sdn.nl voor eventuele source files uit deze uitgave.

Vormgeving en opmaak: Reclamebureau Bij Dageraad, Winterswijk www.bijdageraad.nl ©2009 Alle rechten voorbehouden. Niets uit deze uitgave mag worden overgenomen op welke wijze dan ook zonder voorafgaande schriftelijke toestemming van SDN. Tenzij anders vermeld zijn artikelen op persoonlijke titel geschreven en verwoorden zij dus niet noodzakelijkerwijs de mening van het bestuur en/of de redactie. Alle in dit magazine genoemde handelsmerken zijn het eigendom van hun respectievelijke eigenaren.

Adverteerders Macaw VNU Bergler Aladdin Avanade 4DotNet Sogeti Sybase iAnywhere Barnsten / Embarcadero Microsoft

2 10 24 29 36 44 53 58 66 72

In de periode van de vallende bladeren, het natte wegdek, de laagstaande zon en de vierkante treinwielen valt de laatste editie van het SDN-magazine van 2009 met een hart verwarmende plof op je deurmat. Tijd genoeg om binnen te zitten en weer de volle 72 pagina’s tot je te nemen. Na de succesvolle Software Development Conference van oktober j.l., inclusief de OpenForce ’09 DNN-conferentie en de Developers Launch van Windows 7, en vóór het laatste Software Development Event van 2009 – op 14 december in Houten – verwennen we je nog met een 15-tal artikelen, variërend van de noodzaak van design van de user experience – in Andries van der Meulens artikel “Daarom User Experience Design!” - tot de broodnodige aandacht die we als developers aan de dag (zouden) moeten leggen voor de beheerders van al onze, ongetwijfeld prachtige, applicaties – zie “Monitoring” van Eric Denekamp - … want zij kunnen maar weinig met een message-box met de melding “unknown error” en een Okbutton! Hoezo OK?!? En er is nog meer aandacht voor de kwaliteitsaspecten van onze applicaties. Schaalbaarheid wordt b.v. in 2 artikelen behandeld. Roy Cornelissen kijkt hoe dat geregeld zal kunnen worden via Velocity’s Distributed Cache en Andre Boonzaaijer doet zijn verhaal over Schaalbare Modellen. Ook voor security-aspecten is aandacht: Brandon Haynes praat in zijn “Under the Hood’-reeks over de Security Services die je in DotNetNuke 5.1 terugvindt. Verbetering van de kwaliteit van een app kun je ook bereiken door niet het wiel opnieuw uit te vinden. Design patterns kunnen daar een goede rol bij spelen, zoals Marcel Peereboom laat zien in zijn eigen MVP-versie, die voor het Most Valuable Pattern. Op het gebied van user interactie worden jullie o.a. voorzien door Dennis Vroegop die ingaat op de beginselen van development voor Surface: als je met z’n 4en rond die tafel staat is dat toch wat anders als dat je in je uppie met je eigen muis naar je eigen beeldscherm kijkt. Een belangrijke factor bij development voor Surface lijkt creativiteit: wie komt met het briljante idee voor de nieuwe killer-app? Paul Keijzers laat in het artikel “Create and use of Google maps web part” zien hoe bezoekers van het Spaarne Ziekenhuis in Haarlem via een interactief kaartje kunnen zien bij welke huisarts zij op zeker moment het beste/snelste terecht kunnen. De resterende artikelen hebben allemaal wel een ‘data-link’. Johan Machielse kijkt naar “SQL Server Integration Services in de Praktijk” en Marcel Meijer blikt vooruit naar “SQL Azure”. Cary Jensen vervolgt zijn “Introduction to LINQ” van het vorige magazine, en Ann Lynnworth kijkt o.a. naar de performance van Firebird in haar artikel “Firebird SQL and Web Traffic Analysis with Delphi”. Christiaan Heidema doet uit de doeken dat “XML-Parsing in COBOL” is opgenomen, en als gebruikers genereren wij die data vaak met behulp van een toetsenbord, misschien zelfs wel als een soort Hans Klok via “Het Magische Toetsenbord” van Peter van der Sman. Veel leesplezier! rob willemsen, [email protected] •

PS: Rest me nog te melden dat dit niet alleen het laatste magazine van dit jaar is … het is tevens het laatste magazine dat onder mijn redacteurschap valt. Het is tijd voor iets anders, as simple as that … er is – gelukkig! - nog zo veel uitdagends en interessants te beleven in de software-wereld. Een bedankje mijnerzijds naar alle lezers en naar alle SDN-medewerkers, en ik hoop dat menigeen met veel interesse en met veel plezier gelezen heeft in het SDN-magazine, en dat ook zal blijven doen!

Adverteren? Informatie over adverteren en de advertentietarieven kunt u vinden op www.sdn.nl onder de rubriek Magazine. magazine voor software development 3

Inhoud 03

Voorwoord

Rob Willemsen

04 05

Inhoudsopgave Snel en Schaalbaar met Velocity Distributed Cache

Roy Cornelissen

11

Firebird SQL and Web Traffic Analysis with Delphi

Ann Lynnworth

17

Daarom User Experience Design!

20

SQL Server Integration Services in de Praktijk

Andries van der Meulen Johan Machielse

25

ASP.NET onder de Motorkap: ASP.NET 4.0 op bezoek bij je browser

Michiel van Otegem

26

XML-Parsing in COBOL

Christiaan Heidema

30

Surface development

Dennis Vroegop

35

Interesting Things: Writing Better Software Faster

Sander Hoogendoorn

37

Introduction to LINQ, part 2

Cary Jensen

SDN EVENT

41

Under the Hood: Security Services in DotNetNuke 5.1

Brandon Haynes

45

Create and use of Google maps web part

14 DECEMBER 2009

50

DevTweet: Software Development with a wink

HOUTEN

51

Paul Keijzers

Marianne van Wanrooij en Sander Hoogendoorn

Schaalbare modellen

Andre Boonzaaijer

54

Monitoring

Eric Denekamp

56

SQL Azure

Marcel Meijer

58

Boek Review: Handboek Silverlight 3

Emile van Ewijk

61

MVP: Most Valuable Pattern?

Marcel Peereboom

67

Het Magische Toetsenbord

Peter van der Sman

.NET

Roy Cornelissen

Snel en Schaalbaar met

Velocity Distributed Cache In het hart van je computer vind je de processor en het interne geheugen. Deze onderdelen horen bij de computerarchitectuur die is vernoemd naar John von Neumann, een beroemd wiskundige en computergeleerde. Eén van de onhebbelijkheden van deze architectuur is de “Von Neumann bottleneck”: doordat het geheugen zich “op afstand” van de processor bevindt en veel data kan bevatten, ontstaat er een grote hoeveelheid verkeer op de relatief smalle verbindingsweg tussen die twee onderdelen. Dit leidt tot opstopping en vertraging. Deze flessenhals wordt in computers deels opgeheven door een buffer tussen de twee onderdelen te plaatsen: de cache. Op veel grotere schaal, in de wereld van software development, krijgen we steeds meer te maken met gedistribueerde data en event-driven applicaties. Gegevens zijn cruciaal voor applicaties om te functioneren, maar applicaties zijn door hun gedistribueerde en servicegeoriënteerde architectuur afhankelijk van vele schakels in de keten. Gegevens kunnen van diverse bronnen afkomstig zijn, zelfs van externe partijen. Soms moet je gegevens van verschillende bronnen aggregeren voor je er iets mee kunt. Ook kun je er niet altijd zeker van zijn dat verbindingen voorhanden zijn. Of misschien heb je een SLA waarbij je moet betalen voor het aantal calls dat je afneemt en is het dus een kostenoverweging om het aantal aanroepen van services te beperken. Denk ook aan offline scenario’s op smart clients, handheld devices, enz. In een gedistribueerde en servicegeoriënteerde omgeving ontstaat door al deze aspecten een behoefte aan een vorm van caching.

De ”Von Neumann bottleneck” is (deels) op te lossen via caches Er zijn gelukkig middelen die het ons steeds gemakkelijker maken om caches te bouwen. De prijs van geheugenchips blijft dalen en door slim gebruik te maken van meerdere computers kunnen we gedistribueerde caches bouwen op basis van goedkope hardware. Een gedistribueerde cache bestaat uit een verzameling computers die samen één grote cache vormen. Doordat de cache verspreid is over meerdere machines kun je profiteren van b.v. hoge beschikbaarheid (door kopieën van gegevens te verspreiden over meerdere computers en ze elkaars werk te laten overnemen als er een computer uitvalt) en hoge performance doordat de belasting van de machines wordt verdeeld over verschillende computers. Zolang je computers hebt met geheugen en een netwerkkaart, kun je de gedistribueerde cache blijven vergroten.

De performance van bekende community sites als Hyves en MySpace of grote webwinkels als Amazon zou als een plumpudding in elkaar zakken als zij niet waren voorzien van grote gedistribueerde caches

De performance van bekende community sites als Hyves en MySpace of grote webwinkels als Amazon zou als een plumpudding in elkaar zakken als zij niet waren voorzien van grote gedistribueerde caches. Wat stop je in een cache? Er zijn verschillende soorten gegevens die zich lenen om te cachen en waarbij ook verschillende scenario’s passen. Referentiedata Dit zijn gegevens die niet vaak wijzigen maar wel heel vaak worden geraadpleegd. Denk hierbij aan productgegevens in een productcatalogus of gegevens over reisverzekeringen van verschillende verzekeringspartners. Stamtabellen voor landen, plaatsnamen, postcodes, etc., vallen ook in deze categorie. Meestal wordt aan deze gegevens een bepaalde geldigheidsduur meegegeven. Zolang deze uiterste houdbaarheidsdatum niet is verstreken, kunnen deze gegevens in de cache blijven. Referentiedata lenen zich uitstekend om te cachen. Activity data Hieronder verstaan we gegevens die geldig zijn terwijl een eindgebruiker bezig is met een gebruikerssessie. We noemen dit ook wel conversational state. Een voorbeeld van activity data is de inhoud van een winkelwagentje dat een gebruiker aan het samenstellen is op de site van een internetwinkel. Deze gegevens bevinden zich meestal ergens in de user interface / front end laag van een applicatie. In ASP.NET applicaties gebruiken we daarvoor vaak de Session container. Pas na afloop van een transactie komt activity data in een of andere vorm definitief in een backendsysteem, database of service te staan. Het winkelwagentje uit het voorbeeld wordt dan omgezet in een order. Activity data wordt vaak geschreven en gelezen, maar alleen binnen de context van één gebruiker. Deze gegevens moeten daarom worden gekoppeld aan die ene gebruiker. Voorbeelden hiervan zijn de session state, cookies of de viewstate in ASP.NET applicaties. Resource data Dit zijn gegevens die vaak worden gelezen en geschreven door meerdere gebruikers of applicaties. Bijvoorbeeld de beschikbare voorraad van producten in een magazijn. Bij iedere bestelling moeten deze gegevens worden bijgewerkt en ze moeten altijd beschikbaar zijn. Hier is dus een sterke koppeling met de achterliggende gegevensbron en deze gegevens moeten doorlopend met elkaar in de pas worden gehouden. Caching is in deze gevallen vooral een

magazine voor software development 5

.NET

middel om snelheid te krijgen bij het raadplegen, maar het risico is groot dat de gegevens in de cache verouderd zijn. De beste performance krijg je door de cache zo dicht mogelijk bij de applicatie te leggen, b.v. door de cache in-process te draaien of op dezelfde machine. Gedistribueerd cachen met Velocity Microsoft is een project gestart met de code naam Velocity uitgaande van de eerder genoemde trend in applicatiearchitectuur en de mogelijkheden die de hardware ons biedt. Velocity levert een gedistribueerde cache die in veel verschillende scenario’s inzetbaar is. Het product is nog volop in ontwikkeling en is momenteel als CTP3 beschikbaar. Wanneer versie 1.0 beschikbaar komt is nog onduidelijk. In de rest van dit artikel ga ik in op de eigenschappen van Velocity CTP2 en waar je rekening mee moet houden als je het product wilt inpassen in je architectuur. Velocity is dus een gedistribueerde cache. De filosofie die Microsoft hanteert is die van een bundeltje computers waarvan de interne geheugens aan elkaar worden gesmeed tot één grote cache die beschikbaar is voor de applicatie. Vanuit de applicatie gezien benader je één logische cache, Velocity zorgt voor lastige zaken als het verdelen van gegevens over een heel cluster. Hiermee zorgt Velocity voor failover, hoge beschikbaarheid, schaalbaarheid enzovoort. In de huidige opzet is Velocity een cache-aside, wat betekent dat de cache niet meer is dan een grote silo voor gegevens. De applicatie bepaalt zelf wanneer objecten in de cache moeten worden gezet of wanneer ze moeten worden ververst. Velocity heeft zelf dus geen weet van wat de applicatie doet of wat er in de cache wordt opgeslagen. Wat kan er allemaal in Velocity worden opgeslagen? Eigenlijk alle gegevens, zolang ze serializable zijn: .NET objecten, DataRows, XML en byte arrays. De reden waarom ze serializable moeten zijn is dat ze proces- en machinegrenzen oversteken. Met serializable bedoel ik dat ze moeten zijn voorzien van het Serializable attribuut of de DataContract en DataMember attributen.

Fig. 1: Schematische weergave van de Velocity onderdelen beheer. Zo kun je een cluster in zijn geheel stoppen en starten. Je kunt de omvang van je cache beïnvloeden door er hosts aan toe te voegen of eruit te verwijderen. Een cache wordt gevormd door het geheugen van de hosts binnen een cluster te combineren en er een logische naam aan te koppelen. Door die naam wordt het een ‘named cache’. Er kunnen meerdere named caches in een cache cluster bestaan. De naam levert niets meer op dan een context voor je applicatie. Zo kunnen een order- en een salesapplicatie gebruik maken van hetzelfde cachecluster en zelfs dezelfde sleutels gebruiken voor hun data, maar doordat de cache in beide gevallen een eigen naam heeft, ontstaat er geen verwarring. Vergelijk het met de namespace van XML documenten. Zoals de figuur al aangeeft, is een cache uitgesmeerd over de hosts in het cluster.

Velocity is een Silo van serializable data In zijn kleinste vorm kan Velocity ook worden ingezet als een in-process cache. Dit heet een local cache. Velocity draait dan in het proces van je applicatie mee. De hoeveelheid gegevens die Velocity in de local cache stopt heeft dan wel direct invloed op het geheugengebruik van de applicatie. Een local cache kun je ook combineren met een volledig cache cluster. Gegevens die je opvraagt vanuit het cache cluster worden dan gebufferd in de local cache. Velocity werkt met een fallback mechanisme: het controleert of objecten in de local cache staan. Alleen wanneer dat niet het geval is, zal Velocity het cache cluster aanspreken. De eerstvolgende keer staan de gegevens wel in de local cache. Omdat de local cache in het proces van de applicatie meedraait, hoeven objecten niet te worden geserialiseerd en gedeserialiseerd. Het werkt daardoor zeer snel, maar het zorgt er wel voor dat de applicatie zelf meer geheugen gaat gebruiken. De opbouw van een cache cluster In de gedistribueerde cache van Velocity praten we over een aantal onderdelen: de cache zelf, hosts, clusters en regions. Figuur 1 toont hoe de verschillende onderdelen met elkaar in verbinding staan. Een cache host is een proces dat (een deel van) een cache beheert en vormt een apart te beheren onderdeel van de gedistribueerde cache. Een host is meestal gekoppeld aan één fysieke machine, maar er kunnen best meerdere hosts draaien op één computer. Een cluster is een logische verzameling van hosts en van één of meerdere caches. Een cluster als geheel is ook weer een eenheid van

6

MAGAZINE

Fabric Het fabric clustering protocol is een populaire technologie in de netwerkwereld. Het is een protocol dat zorgt voor het beheer van group membership van hosts binnen een cluster, het automatisch detecteren dat er hosts worden toegevoegd of verwijderd. Het zorgt voor schaalbaarheid en beschikbaarheid en voorkomt een single point of failure doordat data wordt gerepliceerd naar andere nodes. Daarnaast levert het routing tables om een verzoek van de client door te verwijzen naar de juiste host binnen een cluster. Microsoft heeft Fabric geïmplementeerd en beschikbaar gesteld als een verzameling .NET assemblies. Deze zijn op dit moment onderdeel van de Velocity CTP2 download.

Binnen een cache kun je nog een opdeling maken in regions. Een region gebruik je om gelijksoortige gegevens te bundelen, vergelijkbaar met een tabel in een database. Je kunt dan, behalve de sleutel voor een object, ook meer informatie aan je data koppelen in de vorm van tags. Je kunt daardoor tag based zoeken, b.v. naar alle objecten met de tag “Dieselauto”. Velocity koppelt zo’n region wel aan één bepaalde host, dus je kunt dan niet profiteren van het feit dat Velocity de gegevens verdeelt over de verschillende hosts ten behoeve van de schaalbaarheid. Velocity kan overigens wel regions als geheel repliceren voor failover doeleinden. Door een cluster op te bouwen uit verschillende hosts en daar een cache overheen te “projecteren” kan Velocity een cache leveren met

.NET

een hoge beschikbaarheid en failover. Deze twee doelen bereikt Velocity door gegevens slim te verdelen over de hosts en vervolgens te repliceren. Mocht er een node uitvallen, dan is er altijd nog een host die een kopie van de gegevens beschikbaar heeft. Doordat er onbeperkt hosts kunnen worden toegevoegd aan een cluster, zelfs terwijl een cluster draait, is Velocity enorm schaalbaar. Het beheren van het cluster gebeurt in Velocity op basis van het Fabric Cluster Management protocol (zie kader). Voor het beheren van de clusters en hosts krijg je een beheertool op basis van Windows PowerShell. Velocity past goed op je spullen In een gedistribueerde omgeving zullen er meerdere applicaties zijn die gebruik maken van de cache. Denk aan een web farm waarop dezelfde web applicatie meerdere malen is uitgevoerd. Ook meerdere lagen binnen een applicatie kunnen gebruik maken van dezelfde cache. Doordat de cache vanuit verschillende bronnen kan worden gevuld met data en weer worden uitgelezen, is het belangrijk dat Velocity zijn cache goed bewaakt. Bij het beheren van de cache waar meerdere partijen gebruik van maken komen eigenlijk dezelfde aspecten aan bod als bij “traditioneel” gegevensbeheer, namelijk constistency, concurrency en beveiliging. Specifiek bij caching is ook een goed beheer van geheugen belangrijk. Consistency Consistency in Velocity betekent het gelijk houden van de gegevens die verspreid en gerepliceerd zijn over de verschillende hosts binnen het cluster. Je kunt kiezen voor twee modellen: weak consistency of strong consistency. Bij strong consistency is een operatie om gegevens in de cache te stoppen of te wijzigen synchroon: de operatie is pas klaar als de gegevens succesvol zijn gerepliceerd naar alle hosts in het cluster. Als je het niet zo belangrijk vindt om te weten of een object wel in de cache is opgeslagen, dan kun je kiezen voor het weak consistency model. In het weak model gebeurt het wegschrijven en repliceren van gegevens in de cache asynchroon. Dit kan je veel snelheidswinst opleveren als je vaak gegevens in de cache schrijft, doordat je niet telkens hoeft te wachten totdat alle gegevens succesvol over alle hosts in het cluster zijn verspreid. Wanneer het wegschrijven van de gegevens mislukt door een onvoorzien probleem terwijl je daar niet van op de hoogte bent, moet je er in je applicatie wel rekening mee houden dat objecten niet per se in de cache staan en je hierdoor mogelijk vaker misgrijpt als je om objecten vraagt. Velocity ondersteunt in CTP2 alleen nog het synchrone model (strong consistency). Concurrency en beveiliging Bij resource data heb je mogelijk te maken met gegevens die door verschillende clients worden gewijzigd. In deze gevallen is het prettig dat Velocity de concurrency bewaakt. Net als in een database kun je kiezen tussen optimistic en pessimistic locking. Bij optimistic locking gebruikt Velocity wat extra metadata in de vorm van een versienummer. Een update op de gegevens in de cache lukt dan alleen als je ook het juiste versienummer van die data hebt. Heeft iemand anders dat nummer in de tussentijd opgehoogd, dan zal de wijziging falen. In het pessimistic locking scenario leg je expliciet een lock op het object in de cache en kan alleen de houder van het lock de gegevens wijzigen en het lock weer vrijgeven. Het is wel belangrijk om te beseffen dat Velocity geen transacties over meerdere items heen ondersteunt. In een pessimistic locking scenario moet de applicatie goed de volgorde van acties en het leggen van locks bewaken om deadlock situaties te voorkomen. Velocity heeft zelf geen deadlock detectie, dus dat moet je in de applicatie verzorgen. Velocity doet in CTP2 nog niets aan beveiliging. Objecten worden nog niet beveiligd tegen ongeautoriseerde toegang en er is ook nog geen

moeite gestoken in b.v. het coderen van gevoelige gegevens. Hoewel je je moet afvragen of het verstandig is om gevoelige gegevens te cachen, moet je er dus wel rekening mee houden dat deze objecten in het geheugen van je computer kunnen zijn geladen. Ze zouden door kwaadwillenden kunnen worden uitgelezen. Het Velocity team werkt momenteel aan een model voor security. De ideeën lopen uiteen van een systeem met ACL’s (Access Control Lists) of het gebruik van een

“Traditioneel” gegevensbeheer, zoals constistency, concurrency en beveiliging, is nog steeds belangrijk in de cache simpele sleutel per region of object. In de afweging wordt vooral gekeken naar een goed evenwicht tussen beveiliging en goede performance. Geheugenbeheer Eerder werd al genoemd dat Velocity een cache-aside is. Dit betekent dat de applicatie verantwoordelijk is voor het beheer van de gegevens in de cache: de applicatie bepaalt of gegevens nog geldig zijn en wanneer ze moeten worden vervangen. Velocity zorgt echter wel voor efficiënt geheugenbeheer en houdt daarbij rekening met de kaders die je stelt bij het aanmaken van een gedistribueerde cache. Deze kaders worden uitgedrukt in twee strategieën: expiration en eviction. Expiration gaat over de geldigheid van gegevens. Je kunt aan gegevens een bepaalde levensduur (time-to-live) meegeven. Wanneer deze levensduur is verstreken, zal Velocity de gegevens verwijderen uit de cache. Het verwijderen van items hangt nauw samen met eviction. Eviction is het verwijderen van cache items op basis van een Low en een High Watermark. Als je een cache aanmaakt, kun je een low en een high watermark als kaders opgeven. Deze watermarks zijn een soort barometers die bepalen wanneer Velocity moet gaan opruimen. De low watermark geeft aan bij welk geheugengebruik Velocity moet beginnen met opruimen van items waarvan de levensduur is verstreken. Als de high watermark is bereikt, dan gaat Velocity objecten opruimen ongeacht de levensduur. Bij deze laatste vorm van eviction verwijdert Velocity wel als eerste de objecten die het langst niet zijn gebruikt. Dit gaat op basis van het least-recently-used (LRU) algoritme. Als je in je oplossing gebruik maakt van expiration en/of eviction, dan is het dus belangrijk om je bewust te zijn van het gedrag dat Velocity dan vertoont. Bij caching in zijn algemeenheid kun je er niet altijd van uitgaan dat gegevens ook daadwerkelijk beschikbaar zijn in de cache en je applicatie is ervoor verantwoordelijk dat ontbrekende gegevens worden aangevuld of ververst. Het Velocity team heeft wel toekomstplannen voor het automatisch aanvullen van de cache op het moment dat objecten niet (meer) in de cache zitten. Hoe gebruik ik Velocity? Grofweg zijn er twee manieren waarop je Velocity kunt inzetten in je applicatie: als een expliciete cache-aside en voor sessiemanagement in webscenario’s. In het eerste geval heb je een client API ter beschikking waarmee je objecten in de cache kunt stoppen of eruit kunt halen. Voor sessiemanagement heeft Velocity een provider. Als je Velocity wilt inzetten als sessionstate-provider, dan is het wel belangrijk de cache die je daarvoor gebruikt zodanig te configureren dat sessies niet zomaar verloren gaan. Denk daarbij aan het eerder beschreven eviction en expiration gedrag. Eviction zal moeten


.NET

worden uitgeschakeld. Verder kan het handig zijn de standaard expiration van 10 minuten te verhogen naar bijvoorbeeld een half uur. Sessiegegevens zijn belangrijk, dus het aanzetten van de high availability eigenschap van Velocity is in dit geval ook een goed idee. Dit alles doe je via de PowerShell beheertool met de opdracht in listing 1.

myDefaultCache = myCacheFactory.GetCache("default"); //---------------// Cache gebruiken //---------------//Maak een region aan in de cache myDefaultCache.CreateRegion("DemoRegion", true);

Set-CacheConfig –CacheName MijnSessionCache –Eviction none –TTL 30 –Secondaries 1

//Zet objecten in DemoRegion, beiden met twee tags //Widget is een class met DataContract en DataMember attribu-

Listing 1: Cache configureren voor session state via PowerShell beheertool

ten

Bovenstaande opdracht schakelt eviction uit (“-Eviction none”), stelt de expiration periode in op 30 minuten (“-TTL 30”) en schakelt high availability in (“-Secondaries 1”). Als je eviction uitschakelt, loop je wel de kans dat het geheugen volloopt, omdat objecten niet meer worden opgeruimd tenzij de houdbaarheid verloopt.

myDefaultCache.Add("DemoRegion", "key1",

Tag[] tags = new Tag[] { new Tag("lifestyle"), new Tag("work") }; new Widget("Widget101"), tags); myDefaultCache.Add("DemoRegion", "key2", new Widget("Widget102"), tags); //Zoeken op tags

Om CTP2 te kunnen gebruiken moet je referenties maken naar twee DLL´s: CacheBaseLibrary.dll en ClientLibrary.dll. Deze vind je na installatie in %PROGRAMFILES%\Microsoft Distributed Cache\v1.0.

List> results =

Listing 2 laat zien hoe je toegang krijgt tot de cache en welke methodes je onder andere kunt aanroepen om de data in de cache te manipuleren. In het eerste deel van de code wordt de cache-client geconfigureerd. De code geeft aan met welke cache-host hij communiceert, dat het een simple client is en dat de local cache ingeschakeld is. Je ziet dat hier expliciet de naam van een cache-host wordt opgegeven. Er is altijd één host die je als eerste aanspreekt om toegang te krijgen tot de cache, maar de Velocity infrastructuur zorgt ervoor dat je ook bij de andere hosts binnen het cluster uitkomt als dat nodig is.

foreach (KeyValuePair<string, object> kv in results)

myDefaultCache.GetAnyMatchingTag("DemoRegion", new Tag[] { new Tag("work") });

{ Console.WriteLine(kv.Key + ": " + ((Widget)kv.Value).Name); } //Zet een waarde buiten een region myDefaultCache.Add("key2", "Testwaarde2"); //Zet een waarde via indexer myDefaultCache["key3"] = "Testwaarde3";

//-------------------------// Cache client configureren

Listing 2: Gebruik van Velocity vanuit code

//-------------------------//We communiceren met 1 cache host ServerEndPoint[] servers = new ServerEndPoint[1]; //Cache Host Details //

Parameter 1 = host name

//

Parameter 2 = cache port number

//

Parameter 3 = cache service name

servers[0] = new ServerEndPoint("localhost", 22233, "DistributedCacheService");

Je hoeft de cache-client niet altijd vanuit code te configureren. Dat kan ook in de App.config. Listing 3 geeft een voorbeeld van dezelfde configuratie als in het C# codevoorbeeld, maar nu in App.config. <section name="dcacheClient" type="System.Data.Caching.DCacheClientSection, CacheBaseLibrary" allowLocation="true" allowDefinition="Everywhere"/>

//Routing of Simple Client

// False = Simple Client (geen routing table) // True = Routing Client

bool routingClient = false;

//Local cache of niet // True = Wel local cache // False = Geen local cache bool localCache = true;

//Geen logging van cache exceptions CacheFactory.DisableLogSinks();

//Configuratie meegeven aan CacheFactory constructor myCacheFactory = new CacheFactory(servers,

routingClient, localCache); //Vraag de "default" cache op

Listing 3: Configuratie van Velocity in App.config 8

MAGAZINE

.NET

De eigenschappen van Velocity, zoals het schaalbaar, gedistribueerd en highly available zijn, hebben ook voordelen in webapplicaties die draaien in grote webfarms. In ASP.NET heb je voor sessiemanagement de keuze uit in-process, SQL Server of een State Server. ASP.NET gebruikt daarvoor een provider model, waardoor je gemakkelijk kunt wisselen zonder de applicatie te hoeven aanpassen. SQL Server en State Server zijn de opties die je overweegt wanneer je applicatie flink is opgeschaald en draait op meerdere webservers, zeker als je geen sticky routing toepast. Bij sticky routing wordt dezelfde gebruiker voor ieder request telkens door dezelfde web server bediend. Nu we de kracht van Velocity kennen, zou het handig zijn ook meteen hier het sessie-management te beleggen. Dat kan, want Microsoft levert een ASP.NET sessionstate-provider op basis van Velocity. Listing 4 toont hoe je deze kunt configureren.

De read thru/write behind ondersteuning is er één die een beetje tegen de cache-aside filosofie indruist. Read thru betekent dat de cache automatisch terugvalt op een back-end service of database wanneer een object niet kan worden gevonden in de cache. Write behind houdt in dat Velocity een wijziging in een item in de cache (asynchroon) doorstuurt naar de back-end. Hiermee wordt Velocity meer dan een cache-aside, namelijk de spil tussen applicatie en gegevensbronnen. Persoonlijk ben ik benieuwd naar de manier waarop Microsoft dit gaat oplossen. Ik denk dat een uniforme toegang tot gegevens hiervoor noodzakelijk is, dus ik verwacht rechtstreekse koppelingen met SQL Server tabellen of REST style interfaces zoals als die van ADO.NET Data Services. Op de roadmap staan verder nog zaken als het ondersteunen van LINQ queries op de cache en Velocity in the cloud. Deze zaken zullen waarschijnlijk na versie 1.0 aan Velocity worden toegevoegd. Op deze manier is Microsoft bezig om technologieën, die op zichzelf al nuttig zijn, op een slimme manier te combineren.

<sessionState mode="Custom" customProvider="Velocity"> <providers>

Listing 4: Configuratie van session state provider op basis van Velocity Afwegingen voor configuratie Velocity kun je in verschillende configuraties toepassen. Welk scenario past nu het best bij datgene wat je wilt bereiken? Tabel 1 geeft een overzicht van de effecten die een bepaalde configuratie met zich meebrengt. Configuratie High availability

Gepartitioneerde cache

Local cache

Effect Positief Hogere garantie dat gegevens beschikbaar zijn en blijven, ook bij uitval van een host. Betere performance doordat gegevens worden verdeeld over het cluster en daardoor ook de belasting van de cache hosts. Hierdoor ook een grotere scale. Hoge performance doordat local cache binnen de applicatie draait en objecten niet hoeven te worden geserialiseerd/gedeserialiseerd.

Negatief Negatief effect op performance doordat Velocity kopieën van gegevens op meerdere hosts moet bijhouden. Als een cache host uitvalt, verlies je die gegevens. Deze moeten dan opnieuw in de cache worden gezet. Kleine overhead door fallback mechanisme. De applicatie verbruikt meer geheugen.

Tabel 1: Verschillende configuraties en hun effecten De configuraties in tabel 1 kunnen worden gecombineerd. Je kunt dus een gepartitioneerde cache maken die highly available is. Het verlies aan performance door high availability te gebruiken kun je compenseren door een local cache toe te passen. Een kijkje in de toekomst De CTP’s tonen al een aardig werkend product. Maar er zijn nog zaken waar het team aan werkt. Naast het continu verbeteren van de schaalbaarheid en snelheid wordt gekeken naar betere manieren om de cache te monitoren voor diagnose van problemen. Verder staan voor versie 1.0 de volgende zaken op de planning:

Conclusie In een gedistribueerde applicatie, waar gegevens uit meerdere heterogene bronnen afkomstig zijn, is caching bijna onmisbaar. Het zorgt voor snellere toegang tot data, betere beschikbaarheid en grotere schaalbaarheid. Er zijn meerdere oplossingen op de markt maar Velocity is een veelbelovende nieuwe speler. Het is gratis beschikbaar als losse release naast het .NET framework. Velocity is veelzijdig doordat het in uiteenlopende scenario’s inzetbaar is, van een in-process cache tot volledig gedistribueerd en highly available en zelfs als session state provider voor ASP.NET. NB: Dit artikel is gebaseerd op de CTP2. Op dit moment is CTP3 beschikbaar en is CTP4 onderweg. Ten opzichte van CTP2 bevat CTP3 meer mogelijkheden, hier komen we later op terug. Referenties • Velocity team blog: http://blogs.msdn.com/velocity • Voorbeeld code: http://code.msdn.microsoft.com/velocity • Velocity whitepaper: http://msdn.microsoft.com/en-us/library/cc645013.aspx • PDC 2008 Sessies (waaronder over Velocity): https://sessions.microsoftpdc.com •

Roy Cornelissen Roy Cornelissen werkt als IT architect bij Info Support voor de business unit Industrie. Hij heeft negen jaar ervaring in de ICT en heeft gewerkt aan uiteenlopende projecten. In zijn dagelijks werk past hij Microsoft technologie toe in service georiënteerde omgevingen.

Visual Studio 2010

TIP:

Visual Studio 2010: VAR & Intellisense 1. Notificaties vanuit de cache bij wijzigingen in objecten, zodat clients hierop kunnen anticiperen; 2. Beveiligde toegang tot named caches; 3. Bulk operaties met meerdere objecten; 4. Read thru/write behind ondersteuning.

Je kunt nu gebruik maken van het VAR type. Deze wordt al compile time vervangen door het juiste datatype. Nadeel hiervan was, dat je deIintellisense moest ontberen. In Visual Studio 2010 is er nu full Intellisense support voor VARs.


Advertentie VNU

DELPHI

Ann Lynnworth

Firebird SQL and Web Traffic Analysis

with Delphi Whether you want to learn how to efficiently import data into Firebird, or you wonder if it is worth upgrading to Delphi 2010 for "routine" tasks, this article will give you some food for thought. In particular, this article explores the use of Delphi and the open-source relational database system named "Firebird SQL" to load and analyze web traffic logs. Along the way, the size and performance of EXEs compiled with Delphi 7 versus Delphi 2010 are compared, plus the speed of Firebird 1.5 versus Firebird 2.1 and four common Firebird data access components are measured. Fortunately, there are worldwide standards governing the format of web traffic log files. So, if you have a web site that logs traffic data (on any operating system), there is a very good chance that the solution discussed in this article will apply to your situation. We have (so far) tested log files from IIS 5 on Win2000 and IIS 6 on Win2003, with various data fields included and excluded. The FBPrepLog utility described in this article is free, with Object Pascal source, and is available immediately from Code Central thanks to Embarcadero (look for item #27086). An early version of FBPrepLog is also on the Delphi 2010 Companion DVD. The source definitely compiles in Delphi 7 and in Delphi 2010; it probably compiles in all versions in between. All SQL code in this article probably works with Interbase but was only tested with Firebird. Quick Background on Web Traffic Logs Picture a typical moment in your favorite web browser, just as you go to a web site, and focus on the address bar. The address starts HTTP or HTTPS, right? When you make a web request, an HTTP server, somewhere, processes your request and sends an answer-document that appears in your (client-side) software. Leaving all the complexity aside, that is how it works: request, process, response. It even works that way when you check the train schedule using your iPhone. For each request, the HTTP server usually writes an entry in a web traffic log to record which file was requested, by whom, whether the request was successful, and so on. Whether those log files constitute a violation of your privacy is another long story which, although fascinating, is outside the scope of this article!

Ordinarily, Windows-based webmasters use Microsoft SQL Server to store and query their IIS web traffic logs, but what if you are using Apache, or would simply prefer to use Firebird SQL? If you are the owner or webmaster of a web site, you might look at the traffic log files using anything from Notepad to Firebird to a glossy web-stats package to learn what surfers are doing on your web site. Here are some examples of reasons for studying web traffic logs: • You can find out about errors on your site, including invalid links. Stop link rot!

• You can also find out how much traffic is coming from people versus from software robots. (One typical example of a "bot" is Googlebot, the "spider" used by Google to "crawl" the "web" for keywords, etc.) If you are doing any type of search engine optimization, such as displaying pages slightly differently to web robots than to humans, it can be vital to detect new bots as they come out. • If you want to verify whether an advertiser is really sending you the traffic that they claim to be sending you, especially if you are paying on a per-click basis, running accurate queries is essential. These are only a few of the reasons that people wish to have some strong tools for viewing and analyzing web traffic logs. Microsoft IIS offers an ODBC option for logging the data directly to a SQL database. So I tried that first, with Firebird ODBC. That idea had Two Big Problems: 1. I could not make it work; 2. In ODBC-mode, IIS only saves a few fields, not the full extended list of fields. This led to the idea of building a utility to import the .log data into a Firebird database. Microsoft SQL has a bulk import feature; Firebird offers importing from so-called "external files". This external file feature was to be the basis of the utility.

In addition to having fun, I also wanted to quantify the relative speed of two different versions of Delphi, two different versions of Firebird, and several different data access components magazine voor software development 11

DELPHI

Any difficulty? If you have not looked at a web traffic .log file lately, you might be wondering what could be so difficult about importing its contents into a database. Surely in 2009, this must be a simple software task! The two main difficulties are: 1. The .log file contains comment rows and data rows, and we only want to import the data; 2. The list of fields can vary within the file, whenever the comments indicate a structure change. To make these difficulties more clear, look at a minimalist .log file (from http://msdn.microsoft.com/en-us/library/ms525807.aspx) with some comment rows , starting with #, then one data row, and then more comments to indicate a structure change and one final data row. #Software: Internet Information Services #Version: 1.0 #Date: 2009-05-02 17:42:15 #Fields: time c-ip cs-method cs-uri-stem cs-version 17:42:15 172.16.255.255 GET /default.htm #Software: Internet Information Services #Version: 1.0 #Date: 2009-05-02 17:44:00 #Fields: time c-ip cs-method cs-uri-stem cs-version cs(User-Agent) 17:44:00 172.16.255.255 GET /default.htm Mozilla/5.0+Ok

6.0

sc-status 200 HTTP/1.0 6.0

sc-status 200 HTTP/1.0

Listing 1: Minimal IIS Log File where #Fields comment defines structure of following data Stripping out the comment fields can be done in many ways, including using the free utility named PrepLog from Microsoft. However, making the importer cope with a structure that can vary an unlimited number of times per document is a bit more challenging. In web traffic log files, the data fields are delimited by a single space. Data strings, such as the user agent*, where you might ordinarily expect spaces, have those spaces translated to a plus ('+') symbol by the http server software prior to logging. (*: The "user agent" is the name of the http client software used by the user - commonly a web browser such as Firefox, Opera or Internet Explorer. Finding a user agent of "Mozilla/5.0+Ok" in a log file could mean that a person was there using Firefox, or it could means that some other http client was there, hoping that your web site would give it content as-if it were Firefox. Zie http://en.wikipedia.org/wiki/ Mozilla.) The Goal If all goes well, we will end up with the web traffic data in a table, in a Firebird database. In figure 1 you can see some of the fields, as displayed by the IB_SQL utility:

The question is, how quickly can we import the data? Does it matter which Delphi compiler we use, or which data access components? Can we measure a difference between Firebird SQL v1.5 and v2.1? And how exactly does one use the External Files feature? Our Example Log Files The examples discussed here use log files generated by IIS 6 on Windows 2003, in Extended log format, made daily, with some but not all optional fields included. We have also tested the import of log files made by IIS 5 on Win2000. For testing, we used more than 60 log files, totaling more than 1/2 GB of data, courtesy of traffic data from Earth Wave Records, ranging from July 4th to early September 2009. The web application behind the site was written with Delphi 7 and WebHub. The site uses the ISAPI filter from HREF Tools named StreamCatcher to, among other things, adjust the IIS log files on the fly so that the Session ID (without any random portion) can be readily parsed out by FBPrepLog or human eyes. The particular log file used for all the performance tests was from 31-Aug-2009 and it size was 12,680 kb. Runtime Environment All tests were done on inside a VirtualBox (with thanks to WebCentre Ltd in New Zealand, who allowed us to run tests on one of their backup servers).

Virtualizer Sun VirtualBox v3.0.4 Host OS Windows 2003 Standard Guest OS Windows XP Pro with SP3 Guest RAM 512 KB Guest Disk 10MB drive C Guest CPU 1 ble 1: Runtime Environment

Table 1: Runtime Environment

F

Firebird Installation Notes The tests started with the installation of Firebird-1.5.5.4926-3Win32.exe, using default options with these minor adjustments on the last page of choices: [ ] [ ] [x] [x] [x]

Use the Guardian Start Firebird automatically Install Control Panel Applet Copy Firebird client library Generate client library as GDS32.DLL

To test the newest Firebird, I uninstalled Firebird 1.5 and then installed the Firebird-2.1.2.18118_0_Win32.exe file, again using default options. After installing Firebird, the firebird.conf file MUST be adjusted per the notes in the readme-fbpreplog.rtf file. Otherwise, your output when running FBPrepLog will look like this: Preparing external LOGBLOCK #0... Created table... Exception Access to external file "C:\FBPREPLOG\___LOGBLOCK___0" is denied by server administrator

Listing 2: Oops - forgot to modify firebird.conf to grant access to external files

Fig. 1: IB_SQL shows some of the IISLOGS table after FBPrepLog did the import 12

MAGAZINE

Reset Between Tests Of course it is helpful to reset the starting point prior to each test. The reset-test BAT file stops the Firebird service, copies an empty database to the official location and restarts Firebird. Note that the empty database file does NOT include the table which will hold the data; that is created on the fly by FBPrepLog.

DELPHI

CD /D c:\FBPrepLog net stop FirebirdServerDefaultInstance copy IISLOGS.empty.fb2.fdb iislogs.fdb net start FirebirdServerDefaultInstance

Listing 3: A BAT file to reset things between tests Test Results The test results cover two areas: size and speed. Size of FBPrepLog.exe The following table illustrates how much variation there is in the size of the FBPrepLog.exe depending on the type of components used and the compiler used: • IBX is the built-in Interbase Express driver provided with Delphi; • IBO refers to the TDataSet-derived version of Interbase Objects, where all components are named TIBO*; • IBO Native refers to the version of Interbase Objects which descends from TComponent, where all components are named TIB_*; • dbExpress refers to the new Firebird driver provided with Delphi 2010.

{$ENDIF} {$IFDEF HREFTOOLS} {*htns*}ZaphodsMap, // for advanced, flexible configuration {*htns*}ZaphodsMapMessages, {*htns*}ZaphodProjectOptions, {*htns*}NativeXml, {*htns*}uCode, {$ENDIF} Classes ;

Listing 4: Units used in FBPrepLog DPR Speed of FBPrepLog.exe Each type of test was run at least three times and the average speed is reported here. The slowest speed is 4 minutes 41 seconds and the fastest is 1 minute 22 seconds.

Firebird 1.5 Firebird 2.1

Delphi 7 IBX 4min 41sec 3min 25sec

IBO 4min 5sec 3min 1sec

IBO Native 4min 11sec 2min 58sec

Delphi 2010 IBX dbExpress 2min 30sec 2min 36sec 1min 23sec 1min 22sec

Table 3: Results of Timing Tests

Delphi 7 Unfortunately, table 3 does not include any Delphi 2010 test results IBX 405 kb for IBO nor IBO Native because those components were not available IBO (TIBO*) 1159 kb for that compiler at the time of testing. Based on the results with IBO Native 965 kb Delphi 7, it seems reasonable to expect IBO's performance in Delphi (TIB_*) 2010 to be very similar to IBX and dbExpress. Delphi 2010 In any case, the speed differences among data access components IBX 827 kb is quite small. My guess is that this is because most of the time is dbExpress 1420 kb spent (a)and having the OS write the external file and (b) having Firebird ble 2: Size of EXE depending on data access components compiler Table 2: Size of EXE depending on data access components and compiler To better understand where the "size" comes from, we can look at the units linked in depending on the test: program fbpreplog; {Firebird SQL "prep log" utility} {$APPTYPE CONSOLE} {$DEFINE TESTIBX} {any Delphi, test Interbase Express} //{$DEFINE TESTDBEXPRESS} {for Delphi 2010, test dbExpress} //{$DEFINE TESTIBO} {test TIBOQuery, www.ibobjects.com} //{$DEFINE TESTIBONATIVE} {test native TIB_Query} //{$DEFINE HREFTOOLS} {to support ZaphodsMap configuration} uses SysUtils, DateUtils, {$IFDEF TESTDBEXPRESS} // dbExpress DBXFirebird, SqlExpr, WideStrings, {$ENDIF} {$IFDEF TESTIBX} // Interbase Express IBDatabase, IBCustomDataSet, IBQuery, {$ENDIF} {$IFDEF TESTIBO} // IBObjects IB_Components, IBODataSet, {$ENDIF} {$IFDEF TESTIBONative} // IBObjects Native IB_Components, {$ENDIF} {$IFNDEF TESTIBONATIVE} DB, // TDataSet used by most access components

bulk-import. Remember, in FBPrepLog, we are using a very small, rare subset of the data access component's capabilities. Therefore these timing results are not indicative of overall performance; that would require different tests.

The speed improvement from Delphi 7 to Delphi 2010 is quite significant, and Firebird 2.1 is definitely faster than Firebird 1.5 Highlights from the Source Code The FBPrepLog utility is made from one source code file, FBPrepLog.DPR, with no additional PAS files. There are just under 900 lines of code. Some highlights follow. To understand the "engine" inside FBPrepLog, you will need some reference to the data structures, which follow in listing 5: const cUtilVersion = '1.0.1.4'; LogFieldDBEquivalent: array[0..29] of array[0..2] of string = ( ('time', 'fieldTime', '10'), // ('Field in IIS Log-file', 'Equivalent to field('time') // in Firebird database'). // 'Field' prefix avoids reserved-words. ('c-ip', 'fieldCIp', '20'), // snip ('cs(User-Agent)', 'fieldcsUserAgent', '2048'), ('cs(Cookie)', 'fieldcsCookie', '2048'), ('cs(Referer)', 'fieldcsReferer', '2048'), ('cs-username', 'fieldCsUsername', '40'),


DELPHI

// snip ('sc-substatus', 'fieldScSubstatus', '40') ); AdditionalFieldsCount = 8; LogDBAdditionalFields: array[0..1] of array[0..AdditionalFieldsCount - 1] of string = ( ('cs-uri-query', 'sessionid', 'session=', '&', '15', '', '+', ''), // SessionId placed in log-field "cs-uri-query". Value // placed after string "session=" and before delimiter "&" // This feature is for WebHub sites. ('cs-uri-stem', 'lingvo', '', '', '15', '#', '+', '/eng#/fra#/rus#/spa#/deu#/ita#/nld#/jpn#/chi') //# is delimiter //+/- is to include/exclude // erwrwe#cxvx - delimited string, erwrwe // and cxvx are items // This feature is for any site with translated sub-sites ); LogBlockMaxSize = 15000; type TLogBlockData = record Date: string; Index: Integer; Fields: TStringList; FieldsLengths: TStringList; end; TLogConfiguration = record dbPath: string; dbUsername: string; dbPassword: string; dbTableName: string; end; TFBImportIISLog = class private FLogFile: TStringList; FLogBlock: TStringList; FLogBlockData: TLogBlockData; FLogConfiguration: TLogConfiguration; FdbFieldNames: TStringList; FdbAdditionalFieldNames: TStringList; public constructor Create; destructor Destroy; override; procedure LoadConfiguration; function PrepareLogsExternalTable(InFilename, OutFilename : string; var BlockStart: Integer): Integer; procedure ImportLogBlock(Filename: string); public property BlockIndex: Integer read FLogBlockData.Index; property LogTableName: string read FLogConfiguration.dbTableName write FLogConfiguration.dbTableName; end; var {$IFDEF TESTDBEXPRESS} LogsDatabase: TSQLConnection; LogsTransaction: TObject = nil; // not used {$ENDIF} {$IFDEF TESTIBX} LogsDatabase: TIBDatabase; LogsTransaction: TIBTransaction; {$ENDIF} {$IF Defined(TESTIBO) or Defined(TESTIBONATIVE)} LogsDatabase: TIB_Connection; LogsTransaction: TObject = nil; // not used {$IFEND}

Listing 5: Data structures and essential variables

14

MAGAZINE

The database location, log table name, user name and password parameters all have default values. These values can be overridden by command line parameters. The type of components needed to connect to the database and manage the external file import vary by test. At the end of listing 5, you can see how TSQLConnection is used in Delphi 2010 with dbExpress, whereas TIBDatabase is used with the IBX components which are available in older versions such as Delphi 7. When I compile with the {$DEFINE HREFTools} active and link in ZaphodsMap, etc., I can use XML files to configure the same details. That is helpful for me because I have to organize FBPrepLog import processes for many servers. If you are interested in advanced configuration, see TFBImportIISLog.LoadConfiguration in the source and pay a visit to the ZaphodsMap web site. The function TFBImportIISLog.PrepareLogsExternalTable transforms the data in the .log file into another file which is suitable for bulk-import into Firebird. The procedure TFBImportIISLog.ImportLogBlock does the "real work", and it includes the definition of all the SQL that is used for all steps in the process. Some steps are optional (such as creating the IISLOGS table, which may already exist). Please see the FBPrepLog.dpr file if you are interested in how this works -- look for procedure TFBImportIISLog.ImportLogBlock. Listing 6 shows certain key lines in bold to show the overall flow. procedure TFBImportIISLog.ImportLogBlock(Filename: string); //snip case SQLId of 1: //snip 12: begin Clear; Add('CREATE TABLE ' + 'Temp' + ‘ EXTERNAL FILE ''' + Filename + ''' '); //snip 14: begin Clear; Add('INSERT INTO ' + LogTableName + ' ('); //big snip try GetSQL(1, SQL); // step 1 Open; TableExists := not Eof; Close; //snip -- code for creating table, trigger, generator GetSQL(14, SQL); // step 14 ExecSQL; //snip Transaction.Commit; //snip GetSQL(11, SQL); // step 11 ExecSQL; //snip LogsDatabase.Connected := False; //snip

Listing 6: ImportLogBlock The rest of the FBPrepLog source code (other than ImportLogBlock) is involved with (a) showing usage syntax in case someone needs to see the parameters allowed before running it, (b) looping as needed when importing all files in a directory and (c) timing the import process. Data Mining To get a rough idea of the amount of traffic by day, we can use the query shown in listing 7. This includes requests by humans and web robots.

DELPHI

SELECT a.FIELDDATE, count(a.ID) FROM IISLOGS a group by a.FIELDDATE order by a.FIELDDATE

Listing 7: Query count of requests by date FlameRobin or IB_SQL (or a custom Delphi application) can be used to display the results. If FlameRobin is used, some reassuring information is displayed while the query runs, as shown in the figure below.

To count the number of links from Google, we can count the hits where the referer starts with http://www.google.com (and that will include google.co.jp which is relevant for this web site). On a site that uses WebHub or for any reason includes a session id in the URL, we can follow people (anonymously) and find out which pages they view, and from that perhaps we can determine which pages to improve. The example shown in figure 5 helps us focus on hits from people who were sent by Google, to find out whether they stayed around to view more than 1 page after arriving. The SQL is a bit interesting and is shown in listing #8. The substring function is used because the SessionID field is varchar(128) and only the first 15 characters are signficant. (Yes - we have shortened that field since taking these screenshots.)

Fig. 2: FlameRobin shows status info prior to running the query To find out whether we have any bad links on the site, we can search for hits where the status code is 404 (file not found). Of course, some of those hits will probably be from hackers trying to get in by trying vulnerable resources which yield access on some systems. In figure 3, you can see some of these "rotten links" and who has them (the Referer is the URL which led to the request).

Fig. 5: FlameRobin shows result of query checking whether people arriving from Google "stick" on the web site If this query is run on a site and shows mostly 1's in the Count column, that would indicate that arriving surfers did not immediately see what they wanted, and they did not feel like following any links within the site. If these had been paid (adwords) links from Google, this would indicate an expensive problem, because all those click-throughs would represent wasted advertising. select B.FIELDDATE, Substring(B.SESSIONID from 1 for 15) as SESSIONIDCUT, count(B.ID) from IISLOGS B, (

Figure 3: FlameRobin shows invalid requests and who sent them

select A.FIELDDATE, Substring(A.SESSIONID from 1 for 15) as SESSIONIDCUT from IISLOGS A where (A.SessionID > '1001') and (A.fielddate >= '2009-09-01') and (A.FIELDCSREFERER STARTING WITH 'http://www.google.') ) GOOGLERS where (SUBSTRING(B.SESSIONID FROM 1 for 15) = GOOGLERS.SESSIONIDCUT) and (B.FIELDDATE = GOOGLERS.FIELDDATE) group by B.FIELDDATE, SESSIONIDCUT order by B.FIELDDATE, SESSIONIDCUT

Fig. 4: FlameRobin shows people arriving from Google

Listing 8: Nested query to count hits on the same session number for Googlers


DELPHI

This is just a sampling of the data mining that is possible once the data is in a database. Different sites have different requirements, and it is possible for anyone to do their own analysis if they are willing to put in the effort to figure out the query syntax. The SQL Knowledge Base compiled by IB Phoenix was helpful to me while I worked on the queries shown here. For low-traffic sites, you might not need any queries. Simply having the traffic in an organized format makes it possible to read through the entries and see important patterns. If you have a do-it-yourself site, that might be sufficient. Quick Tips • For prototyping queries, consider installing both FlameRobin and IB_SQL. They each have their strengths. • Use the fastest machine available for Firebird SQL. Log databases become large quickly and you will save yourself a lot of time by using a fast machine. • If you decide to use FBPrepLog, test it once on a relatively small .log file and review the resulting IISLogs table. Then, go back to the source code and consider changing some of the field names to be shorter (easier to type and recognize), and consider making some field lengths shorter. Then, recreate an empty database and start using FBPrepLog daily or hourly. • If you have other data transformations that you would like to accomplish during import (such as tracking the lingvo in its own field rather than just in the uristem), study the code which fills in the SessionID and Lingvo and use that as a basis for your own customizations. Enjoy! International Character Sets The examples in this article used English web sites and URLs. It is

Product FBPrepLog Source

URL cc.embarcadero.com

Firebird SQL Firebird Foundation

www.firebirdsql.org/index.php?op=files www.firebirdsql.org/index.php?op=ffou ndation&id=contributions

Delphi 2010

www.embarcadero.com

Firefox

www.mozilla.com/enUS/firefox/all.html www.flamerobin.org www.webcentre.co.nz www.ibobjects.com

FlameRobin Hosting IB Objects IB_SQL IIS6 enable UTF8 Knowledge Base

www.ibobjects.com/ibo_ib_sql.html www.microsoft.com/technet/prodtechn ol/WindowsServer2003/Library/IIS/bea 506fd-38bc-4850-a4fbe3a0379d321f.mspx?mfr=true www.ibphoenix.com

Mozilla Opera RFC for logs

en.wikipedia.org/wiki/Mozilla www.opera.com/mini/download www.rfc-editor.org/rfc/rfc2616.txt

StreamCatcher

www.streamcatcher.com

Vintage vinyl records Virtual Box Warehousing and Distribution

www.earthwaverecords.com

WebHub

www.href.com/webhub

ZaphodsMap

www.ZaphodsMap.com

www.virtualbox.org www.csweb.biz

Table 4: Product Placement

16

MAGAZINE

Notes Use of Code Central is free as long as you have registered with the Developer Network. Look for item #27086. Free, open-source Any $ donation will be appreciated and invested per priorities which are open to discussion and community input. Not free; talk to your local Embarcadero sales rep for upgrade pricing and deals. Free; available in many lingvos Free admin and query tool Colo server Interbase Objects components (free eval; trustware license) Free admin and query tool Topic: Log File Formats in IIS (IIS 6.0) Use [Search KnowledgeBase] link, bottom-left of home page, for excellent information about many aspects of Interbase and Firebird SQL History lesson Alternative to the alternative. Defines standard for web traffic .log files Commercial ISAPI filter for remapping; can modify IIS logs on the fly. Supplied the traffic logs Free, open-source... from Sun Courier Services co-sponsored the development of FBPrepLog to help the Firebird Foundation Commercial product; a web development framework for Delphi for sites that are to be translated, skinned or otherwise deployed repeatedly. Free, open-source, configuration subsystem from HREF Tools

possible, with IIS6 on Win2003 and later, to log requests using UTF8, allowing for many important non-western lingvos. The FBPrepLog utility would need to be modified to support UTF8. The logic within the external file processing would need to change, and importantly, when you create the Firebird database to hold the traffic data, you would have to specify the charset as "UTF8", rather than "None." Both IB_SQL and FlameRobin make it easy to select the charset when the database is first created. It is very likely that by the time you read this article, the coding changes will be complete and included in FBPrepLog as posted on Code Central. Products and Other Things Worth Finding To find any of the products or services mentioned in this article, please see table 4. All URLs were valid as of September 3, 2009. Conclusion Were you surprised to find so little difference in speed between the data access components? I certainly was, until I realized that the whole point of doing a bulk import is that the Firebird engine does all the work, rather than the components. Finding out that Delphi 2010's compilation of the same source code (e.g. the "IBX" test) led to an EXE that was larger, yet 45% faster, was a wonderful outcome and has convinced me to start recompiling all my utilities with Delphi 2010. Finding out that Firebird 2.1 was faster the 1.5 was not a surprise, although I was glad for the confirmation. Now I need to chase down my last remaining copies of Firebird 1.5 and get them all upgraded! Thank you very much for reading this article, and please consider donating at least $10 to Firebird Foundation if you use FBPrepLog. Grazie. Danke sehr. Merci. Gracias. Dank u! •

Ann Lynnworth Ann Lynnworth was born near Boston, Massachusetts USA at the right time to catch the information technology wave. In 1978, she found she could not resist learning to program fancy macros for WordPerfect, and she has never been afraid to pick up a manual and/or guess her way into a new technology. She started her "Software Doctor" consulting business in 1983 on Apple's early computers, published WordStar at Your Fingertips, wrote Situation Analyst for the IBM PC, helped create Ronstadt's Financials and then joined XL/Proteus to learn all about Paradox and a bit about SQL. Skipping ahead to 1994, Ann learned Delphi and soon co-founded HREF Tools and has worn many hats with the internet tools company, the most enjoyable of which was producing “Tech Talk Radio” for several years for WebHub customers. A dynamic speaker with an unusual point of view, Ann has had rave reviews from attendees in training seminars and at technical conferences. Ann holds an associate art's degree from Simon's Rock College and a bachelor’s degree in psychology from Wellesley College, also in Massachusetts.

UX

Andries van der Meulen

Daarom

User Experience Design! Wat is het? User Experience, of UX in het kort, is de wetenschap over hoe een persoon een systeem ervaart en gebruikt. In dit artikel richt ik mij voornamelijk op UX van software applicaties. Dit varieert van mobiele applicaties tot tablet-, desktop- en webapplicaties. Als je het vervolgens over User Experience Design hebt, of UXD in het kort, dan ga je actief nadenken over wat de best mogelijke manier is om die applicatie door de eindgebruiker te laten “ervaren”. UX designers zijn voortgekomen uit verschillende rollen uit de 80er jaren. Destijds waren het voornamelijk mensen met een achtergrond die niet in de techniek lag, met bijvoorbeeld de naam Usability Engineers. In de loop der jaren zijn deze rollen geëvolueerd en is het meerdere specialisaties gaan kennen. Grafisch en interactie-ontwerpers, bouwers van prototypen, mensen die gespecialiseerd zijn in het testen met eindgebruikers, integratiespecialisten en de meer recent verschenen “Persuasion Architect”. Ze houden zich onder andere bezig met ergonomie, informatiedichtheid, navigatie, schermopbouw en de werkomgeving van de gebruikers. Helaas is het in veel projectmethoden nog steeds niet gestandaardiseerd. Maar dit is aan het veranderen. Er zijn steeds meer bedrijven die hiervoor ondersteuning bieden. Maar wat in de meeste situaties gebeurt is dat opdrachtgevers van het gebruik van UXD afzien, omdat niemand ze het voordeel van de “investering” heeft vertelt. Daarom is het tijd om aan te geven waarom je dit nou juist wel wilt. Waarom wil je het? De voordelen van het gebruik van UXD zal ik uitleggen aan de hand van de Application Lifecycle Management cirkel. Dit iteratief proces is onderverdeeld in drie delen. De eerste is “Business”, waar de functionaliteiten worden bepaald. Daarna komt “Development” waarbij de applicatie gebouwd en getest wordt. Als laatste is er “Operations”. Hier wordt o.a. de applicatie ondersteund in het gebruik. Van het laatste onderdeel kan vervolgens de applicatie worden uitgefaseerd, of er wordt teruggegaan naar “Business” om de cirkel te herhalen.

Hieronder staan 4 argumenten waarom je als opdrachtgever UXD wilt. 1. Business - Verbeterde requirements Als je UX wilt gebruiken in je project, is het verstandig dit te doen vanaf de eerste stap, door het toevoegen van wireframes, interface design, interaction design, rapid prototyping en eindgebruikerstesten. Er wordt een betere dienst aan de opdrachtgever geleverd omdat je nu kunt laten zien wat ze kunnen verwachten. Het is inderdaad een extra investering en zal vermoedelijk de business periode verlengen. Maar wanneer dit goed wordt geïmplementeerd zal de toegevoegde waarde direct zichtbaar worden bij de volgende fase van het project. De ontwikkeltijd wordt verkort en daarmee de ontwikkelkosten. 2. Development - Versnelde “Time-to-market” Omdat de kwaliteit van de documentatie en specificaties is verbeterd, wordt de ontwikkeltijd gereduceerd. Er zullen minder wijzigingen op het laatste moment nodig zijn en de kans dat er onvoorziene fouten worden gemaakt is een stuk kleiner. Testen zal sneller en beter gaan, vanwege de duidelijke specificatie die al vooraf beschikbaar was. Door dit alles kun je sneller een applicatie uitbrengen. Sterker nog, naar mate het projectteam meer ervaring krijgt, wordt de extra tijd in de requirementsfase gecompenseerd door de snellere ontwikkeltijd. 3. Operations - Toegevoegde waarde per gebruiker Wanneer de applicatie is uitgerold, zullen de gebruikers beter en sneller kunnen werken en daarbij minder fouten maken. De applicatie is speciaal ontworpen en opgezet voor hun behoeften en hun manier van werken. Nieuwe medewerkers zullen minder tijd nodig hebben om de applicatie te leren, omdat een applicatie met een intuïtieve User Experience zichzelf uitlegt. Over het algemeen kun je zeggen dat het geleverde werk per gebruiker toeneemt. 4. Operations - Verlengde levensduur applicatie De levensduur van een applicatie neemt toe wanneer deze perfect aansluit op de werkmethoden van de gebruiker. Deze zal dan minder snel klagen, minder workarounds hoeven te gebruiken en daardoor minder snel aansturen op vervanging. Naast de argumenten voor de opdrachtgever, staat hieronder waarom het binnen het projectteam ook toegevoegde waarde heeft.

Fig. 1: Application Lifecycle management

1. UXD bij ontwikkeling Door het verbeterde functioneel en technisch ontwerp zullen er in de architectuur minder wijzigingen en fouten voorkomen. Hiermee verkort je de volledige ontwikkeltijd. Het ontwikkelteam werkt met duidelijke en getoetste specificaties waardoor er een beter beeld is waarnaar wordt toegewerkt. Technisch wordt er een betere kwaliteit gehaald en onduidelijkheden zijn al in een vroeg stadium weggenomen.


UX

UXD in de ontwikkelfase werkt het best met de volgende drie rollen; de designer, de ontwikkelaar en iemand die daartussen staat, een zogenaamde integrator. De designer zorgt voor de interactie en interfaces. De ontwikkelaar maakt de interne werking van het systeem. De integrator kent beide kanten van de applicatie en kan zodoende het proces sturen zodat het werk van de designer en ontwikkelaar goed op elkaar aansluit. 2. Visuele terugkoppeling opdrachtgever Één van de belangrijkste zaken is hoe je communiceert met de opdrachtgever. Met UXD kun je naast tekst ook met beelden de wensen en eisen omschrijven. Het biedt de mogelijkheid te zien wat het wordt voordat het klaar is. Door het tekenen van wireframes, het maken van een interactie- en interface-ontwerp, en bouwen van prototypen met de voorgestelde functionaliteit, is er de mogelijkheid om een betere indruk te geven dan wat met tekst alleen mogelijk is. Daarbij bied je een handvat aan de opdrachtgever om duidelijker eventuele wijzigingen door te geven. Het is makkelijker aan te geven hoe, waarom en waar iets moet worden veranderd. En als er daarbij gebruik wordt gemaakt van prototypen, kunnen alle vooraf ontstane aannames worden voorkomen. Daarbij wordt ook gelijk getest of het voorgestelde idee werkt in de praktijk.

het beste resultaat zul je voor elke mens-machine interactie actief moeten nadenken hoe dit gebeurt en hoe je het kunt optimaliseren. Met de huidige technieken zijn er weinig restricties om zo’n mensmachine interactie zodanig uit te ontwikkelen dat het perfect kan aansluiten bij de werkzaamheden van zijn eindgebruikers. Uiteraard moet je een gezonde afweging maken in de mate van het toepassen. Voor kleinere projecten met relatief weinig eindgebruikers is de toegevoegde waarde van een uitgebreid onderzoek ook een stuk minder. Hierbij kun je er voor kiezen om alleen op basis van feedback van een uitgerolde applicatie verbetering aan te brengen. Initieel een zo’n goed mogelijk product opleveren, maar waarbij je uitgaat dat er regelmatig nieuwe versies worden gelanceerd.

UXD is de toegevoegde waarde bij applicatieontwikkeling dat het verschil gaat maken in de nabije toekomst Op het moment dat het product door veel mensen gebruikt gaat worden, en waarbij de beschikbare tijd van de eindgebruiker van belang is, is het ‘t absoluut waard om UXD vanaf het begin toe te passen in het project. Wat is het niet? Waarschijnlijk doen veel mensen onbewust aan UXD. Ze denken na over een product dat goed aansluit bij de wensen van de gebruikers. Echter doordat ze hier niet bewust mee bezig zijn of omdat ze ook vaak een andere agenda hebben, komt het UXD gedeelte nooit volledig tot zijn recht. Voor een stukje bewustwording gebruik ik de 10 meest voorkomende misvattingen over UXD die Whitney Hess (User Experience Designer in New York) heeft samengesteld. 1. UXD is niet alleen User Interface Design Alhoewel de User Interface (of UI) het meest herkenbare is van de gebruikerservaring, is het slechts een onderdeel van UXD. Hoe informatie getoond wordt en hoe mensen ermee communiceren is ongelofelijk belangrijk, maar UXD gaat veel dieper. Het is de basis voor de gehele applicatie en daarmee ook de UI.

Fig. 2: Interaction Design

2. UXD is niet één stap in het proces Het is iets waar je continu mee bezig moet blijven. Bij iedere iteratie neem je de ervaringen mee, en wordt er opnieuw gekeken waar en of je kunt verbeteren. UXD is niet een stap die je kunt afronden, het moet samenvallen in alles wat je in het project doet. 3. UXD gaat niet over techniek User Experience gaat niet over techniek, maar over hoe mensen leven, werken, hun dingen doen en alles wat daarmee te maken heeft. Techniek is daarbij een middel, maar geen doel. Net zoals schilders hun verf gebruiken om te communiceren, gebruiken User Experience Designers beschikbare techniek om mensen te helpen hun doel te bereiken. Het primaire doel is dan ook om mensen te helpen en niet om de beste, mooiste of laatste techniek te gebruiken.

Fig. 3: Wireframe example

4. UXD gaat niet alleen over bruikbaarheid De bruikbaarheid van een product verhogen is erg belangrijk, maar UXD gaat ook over gedrag. Je gebruikers moeten het product willen gebruiken. Het moet aantrekkelijk zijn en rekening houden met leerbaarheid en emoties. Een goede manier om deze aspecten weer te geven is Peter Morville’s UX honeycomb.

Wanneer gebruik je het? User Experience Design wordt toegepast op het moment dat er direct of indirect gebruikers bij het eindproduct betrokken zijn. Voor

5. UXD gaat niet alleen over de gebruiker De U van UXD staat voor “User”. Het staat centraal in deze methodologie. Maar deze eindgebruiker is niet het enige waar

18

MAGAZINE

UX

nodig. Net als dat je voor een gebroken voet niet naar de cardioloog gaat. Je kunt niet verwachten dat alle UXD professionals voor alle expertises een antwoord hebben. 10. UXD is niet een keuze Ik kan het me niet voorstellen dat een bedrijf bewust kiest voor een slecht UX ontwerp. Maar het gebeurt onbewust. Het is een risico. Daarbij beschouwen helaas nog steeds veel bedrijven UXD als een toevoeging, niet als een basisbehoefte. Wanneer je het verschil moet maken met de concurrentie, is UXD essentieel. Techniek zal op den duur het verschil niet meer maken, aangezien elk bedrijf kwalitatief op hetzelfde niveau komt door de continue ontwikkelingen van de frameworks. Het is daarom essentieel om nu te gaan werken om UXD binnen de projecten te krijgen om straks het verschil te maken.

Fig. 4: Honeycomb rekening mee gehouden moet worden. UXD gaat namelijk over de zoektocht naar de beste combinatie van gebruikerservaring mét de business doelstellingen. Het is namelijk wel de bedoeling dat de applicatie bedoeld is om werk mee te verrichten. Daarnaast moet er ook rekening gehouden worden met bedrijfsspecifieke onderdelen zoals bijvoorbeeld de interne werkprocessen en de huisstijl.

Conclusie User Experience Design is niet de rol van één persoon of afdeling. Het is een bewustwording dat het volledige team ondersteund voor een optimaal functionerend resultaat voor opdrachtgever en eindgebruikers. Je zorgt voor volledigere en getoetste requirements waarmee beter wordt gecommuniceerd, waardoor ontwikkeltijd wordt verkort, waar de applicatie meer oplevert tijdens operatie, en waarbij er een verlengde levensduur is voordat het uitgefaseerd kan worden. UXD is de toegevoegde waarde bij applicatieontwikkeling die het verschil gaat maken in de nabije toekomst. Referenties • 10 Most Common Misconceptions About User Experience Design, 9 Januari 2009, door Whitney Hess, http://mashable.com/2009/01/09/user-experience-design/ •

6. UXD is niet prijzig Het gebruiken van UXD in je project hoeft niet veel te kosten. Elke project is afhankelijk van beschikbare mensen, mogelijkheden, tijd en geld. Daarop moet worden aangesloten en bepaald worden in hoeverre je UXD kunt gaan toepassen. Het is onverstandig om er direct bij het eerste project volledig voor te gaan. Probeer het stapsgewijs in te voeren, zodat op gegeven moment het een standaard in de projecten wordt. 7. UXD is niet makkelijk Helaas is het niet zo dat één methode alle antwoorden biedt voor het ontwerp. De grootste valkuilen zijn dat je aannames doet over hoe je eindgebruiker werkt. Het kost tijd om ze te leren kennen. Samen kun je vervolgens, op iteratieve wijze, komen tot het beste ontwerp. Daarbij wil je de juiste mensen gebruiken om die behoeftes te faciliteren. 8. UXD is niet de rol van één persoon of afdeling Binnen een project is het niet aan één specifieke persoon of een bepaalde groep om met UXD het product succesvol te maken. Iedereen moet hier aan meewerken. Echter omdat rollen en methodes nog niet gestandaardiseerd zijn, is het nu lastig hier volledig vorm aan te geven. Als je het niet kunt benoemen wordt het moeilijk hiervoor expertise aan te trekken. Er komt hier echter wel meer duidelijkheid in. Meer rollen worden algemeen erkend en krijgen daarmee ook de verantwoordelijkheden binnen het UX ontwerp. Maar voor een succesvol product, zal elk projectlid mee moeten doen met User Experience Design. 9. UXD is niet één discipline Afhankelijk van het product zijn er meerdere expertises nodig. Dit is ook van toepassing op UXD. Voor een webshop werk je naar een totaal andere gebruikerservaring dan bij een systeem voor een helpdesk. Hiervoor heb je ook mensen met andere expertises

Andries van der Meulen Andries knows a lot about the presentation side of applications. He works regularly with subjects as graphical and interaction design for many different customers and projects. He also is a (certified) developer and knows multiple programming languages. By knowing both sides, he has the rare combination of creativity and logic. This regularly places him in the position of an integrator, which stands between designer, developer, requirements engineer and architect.

UX

TIP:

jQTouch iPhone applicaties maken maar geen zin om met Objective-C aan de slag te gaan. Het kan ook met HTML en JavaScript! Kijk eens naar jQTouch dat de kracht van HTML 5, jQuery en JavaScript combineert om iPhone applicaties te maken. En ze kunnen zelfs ofﬂine werken. Zie http://www.jqtouch.com/ voor meer info.


DATABASES

Johan Machielse

SQL Server Integration Services in de Praktijk SQL Server Integration Services (SSIS) is de Microsoft implementatie voor ETL (Extract, Transform, Load) waarmee je complexe data-integratie- en transformatie-oplossingen kunt bouwen. Met behulp van de Business Intelligence Development Studio (BIDS) kan de ontwikkelaar met standaard bouwblokken een enterprise oplossing bouwen. Dit artikel beschrijft de belangrijkste bouwblokken van SSIS, gevolgd door een beschrijving van de verschillende fasen van het ETL-proces aan de hand van een voorbeeldapplicatie. Daarna zal er een greep gedaan worden uit een aantal praktijksituaties waar je als SSIS ontwikkelaar mee te maken kunt krijgen.

Een ETL-proces bestaat uit Tasks en pijlen die de flow aangeven

Standaard bouwblokken Bij het maken van een SSIS-applicatie heeft de ontwikkelaar een aantal standaard bouwblokken tot zijn beschikking. Een SSISsolution bestaat uit één of meerdere uitvoerbare packages met daarin de functionaliteit om het ETL-proces te kunnen bouwen. Deze functionaliteit bouw je op met tasks en pijlen die de flow tussen tasks aangeven. De structuur van de package wordt beschreven in de control flow en het werkelijke inlezen, transformeren en laden van de data gebeurt in de data flow. Connection managers zijn de verbinding tussen een bron of doel en worden door de tasks gebruikt om data in te lezen resp. weg te schrijven. Je kunt de packages configureren met zgn. package configurations, en je kunt gebruik maken van event handlers voor het afhandelen van verschillende gebeurtenissen. SSIS voorbeeldapplicatie De voorbeeldapplicatie in dit artikel verzamelt elke week de kosten die zijn gemaakt voor de verschillende projecten binnen een bedrijf. Projecten worden uitgevoerd op diverse locaties in de wereld, waardoor kosten in verschillende munteenheden worden uitgedrukt. De manager van het bedrijf wil elke week een rapport hebben waarin alle projectkosten gesommeerd zijn uitgedrukt in euro’s. De wekelijkse kosten van alle projecten worden aangeleverd in een CSV bestand met meerdere regels per project. SSIS genereert hier een rapport van waarin de projectkosten per land en per project gegroepeerd zijn.

Fig. 2 : Schematische weergave van de SSIS voorbeeldapplicatie

Fig. 1 : Overzicht van SQL Server Integration Services

20

MAGAZINE

Fase 1: Extract In de eerste fase van het ETL-proces leest de package de brondata in. SSIS kan de brondata van verschillende soorten bronnen lezen, zoals een externe SQL Server database, een SAP-systeem of in ons geval een CSV-bestand. De data die het ETL-proces inleest, moet betrouwbaar zijn voor het doel en dus is het belangrijk om de

DATABASES

kwaliteit van de brondata te valideren. Voorbeelden van validatie zijn de controle op de lengte van een reeks karakters, de controle van het data type of op een onder- en bovengrens. Een ETL-oplossing maakt vaak gebruik van een staging area, een database die je gebruikt voor de tijdelijke opslag van data gedurende alle fases van het ETL-proces. Deze database kan data bevatten van verschillende bronnen, ingelezen op verschillende tijdstippen, die wordt gegroepeerd tot één resultaat. Om de opgehaalde data door het gehele proces te kunnen volgen kun je een Lineage ID veld gebruiken, een unieke reeks van karakters die wordt gebruikt om een set van data uniek te maken. Dit is zeer bruikbaar voor audit doeleinden, foutafhandeling, systeemherstel en het gemakkelijk kunnen selecteren van data tussen de verschillende stappen in het ETL-proces.

van berekeningen, het groeperen van data, het uitvoeren van functionele validaties en het toepassen van business rules. Tijdens de transformatiefase converteert de voorbeeldapplicatie de kosten van de verschillende projecten naar euro’s en sommeert deze kosten vervolgens. Met een Lookup task zoekt het proces de wisselkoers op, waarna het de kosten omzet naar euro met een Derived Column task. Selecteer altijd alleen de velden (dus geen ‘SELECT *’) die je gebruikt voor het opzoeken; dit kan veel performancewinst geven. Om de kosten per land en per project te sommeren gebruik je de Aggregate task.

In de voorbeeldapplicatie gebruiken we een Flat File Source task om brondata uit een CSV-bestand te lezen. Het ETL-proces valideert tijdens het ophalen van de data de waarden op datatype en of deze het juiste aantal karakters bevatten. Ook wordt de Lineage ID toegevoegd aan de dataflow om de gehele set van data uniek te maken.

Fig. 6 : Een Lookup task die de wisselkoers (Rate) bij een bepaalde eenheid opzoekt

Fig. 7 : De conversie van de kosten naar de eenheid Euro (kosten x wisselkoers) Fig. 3: De technische en functionele validaties die worden uitgevoerd tijdens de Extract fase Voor de validatie maak je gebruik van Data Conversion tasks. Voor het voorbeeld is gekozen om elk type validatie in een aparte task onder te brengen, waardoor de applicatie overzichtelijk is en gemakkelijk onderhoudbaar blijft.

Fig. 8 : Sommeren van de kosten per land, per project

Met een Derived Column task kun je de Lineage ID aan de datastroom toevoegen.

Fase 3: Load De derde fase van het ETL-proces is het wegschrijven van de data naar een doel, zodat het bruikbaar is voor andere gebruikers en systemen. Het formatteren van de data speelt hierbij een belangrijke rol. De voorbeeldapplicatie genereert een rapport dat de kosten laat zien per project en per land. Het rapport bevat de namen van de landen en projecten en de daarbij behorende kosten afgerond op twee decimalen.

Fig. 5 : Het toevoegen van de Lineage ID kolom aan de datastroom

Fig. 9 : De kosten worden afgerond op twee decimalen

De OLE DB Destination task laadt de gereedstaande data in de SourceData tabel in de staging area. Deze eerste tabel die de opgehaalde data bevat, wordt de “landing” tabel genoemd.

Het proces schrijft de geformatteerde data met een Flat File Destination task weg naar een rapport in CSV-formaat.

Fig. 4 : De datatype- en lengte-validatie

Fase 2: Transform De tweede fase van het ETL-proces is de transformatie van de brondata. Het komt vaak voor dat de brondata niet in het juiste formaat wordt aangeleverd. Om de data betekenis te geven voor het doelsysteem moet je deze data transformeren. Veel voorkomende taken die je hier voor kunt gebruiken zijn het opzoeken van waarden, het doen

Foutafhandeling Tijdens het ETL-proces kunnen zich allerlei fouten voordoen. Om deze fouten op een goede manier af te kunnen handelen is het noodzakelijk om deze fouten te loggen en de verantwoordelijke gebruikers op de hoogte te brengen. Hierbij maken we onderscheid tussen functionele en technische fouten, onderstaande tabel geeft kort de kenmerken van beiden.


DATABASES

Functionele fouten Business gerelateerd De business gebruikers zijn verantwoordelijk voor de afhandeling (mogelijk met de tussenkomst van de systeembeheerder) Uitkomst van functionele validaties Fouten worden gelogd in een tabel De gebruikers worden op de hoogte gebacht middels een e-mail Voorbeelden: een waarde heeft een onjuist datatype, een waarde ligt buiten de vereiste grenzen

Technische fouten Systeem gerelateerd De systeembeheerder is verantwoordelijk voor de afhandeling Deze fouten activeren de OnError event handler Fouten worden gelogd in de Windows Application Eventlog De beheerder wordt op de hoogte gebracht middels een e-mail Voorbeelden: database verbinding verbroken, account gegevens verlopen

Omdat fouten op meerdere plaatsen in het ETL-proces kunnen voorkomen, moet het proces de fouten verzamelen en pas op het eind een e-mail versturen. De e-mail kan een lijst met alle fouten bevatten of een verwijzing naar een locatie waar de fouten kunnen worden bekeken en afgehandeld.

Een andere optie is het opzoeken van een naam in een XML-bestand dat de package beschrijft. Hier ben je onafhankelijk van de relatie tussen ErrorColumn en veldnaam. Wel moet je een script bouwen om het XML-bestand te doorzoeken en ben je afhankelijk van de locatie van het XML-bestand. Selecteer het element “outputColumn” waarvan het attribuut “id” overeenkomt met de waarde van de ErrorColumn; het attribuut “name” bevat de veldnaam.
Een laatste mogelijkheid is een tabel met de ErrorColumn en veldnaamgegevens, waardoor je een duidelijk overzicht hebt van de relatie tussen ErrorColumn en veldnaam. Hier ben je weer afhankelijk van wijzigingen in de relatie tussen ErrorColumn en veldnaam. Zoek de “ID” waarde van een veldnaam op in de Input and Output Properties tabblad en schrijf deze in een tabel. Met een Lookup task kan je aan de hand van de ErrorColumn de bijbehorende veldnaam opzoeken.

Fig. 12 : Lookup tabel Fig. 10 : De gegenereerde fouten worden verzameld en vervolgens per e-mail verstuurd

Met SSIS is het een uitdaging om de veldnaam te achterhalen van de onconverteerbare waardes De Extract-fase valideert een aantal velden op datatype met een Data Conversion task. Wanneer het proces een waarde niet kan converteren, stuurt het de rij door naar de error output. Om een duidelijke omschrijving van de fout te kunnen maken moet je de veldnaam in de beschrijving opnemen. Met SSIS is het echter een uitdaging om de veldnaam te achterhalen van de waarde die het niet kon converteren. De error output van de Data Conversion task stuurt onder andere de numerieke waarde van de ErrorColumn door, wat een verwijzing is naar het veld waarvan de conversie niet lukte. Met deze ErrorColumn waarde ben je in staat de bijbehorende veldnaam op te zoeken waarbij je gebruik kan maken van één van de volgende oplossingen. De eerste optie is een Derived Column task. Zo’n task is eenvoudig te maken en snel te implementeren. Helaas is een expressie onoverzichtelijk en heeft deze een afhankelijkheid op de relatie tussen ErrorColumn en veldnaam. De “ID” waarde van een veldnaam (opzoeken in Input and Output Properties tabblad) komt overeen met de ErrorColumn die de Data Conversion task naar buiten stuurt. Deze “ID” waarde kun je in de expressie van de Derived Column task gebruiken om de relatie ErrorColumn - veldnaam te leggen.

Variabelen Zoals we gewend zijn bij programmeertalen, kunnen ook binnen packages variabelen gedeclareerd worden. Het gebruik van variabelen wordt interessant als deze ook gebruikt worden in child packages. Een variabele die je declareert in een parent package kan je met package configurations doorgeven aan een child package; daarbij wordt een kopie van de waarde doorgegeven. In de child package moet je een variabele declareren die de kopie van de doorgestuurde waarde bewaart.

Fig. 13 : M.b.v. package configurations wordt een waarde doorgegeven naar de child package Als het ene child package de resultaten van een andere child package wil gebruiken, los je dat op door: • Declareer in de parent package een variabele (ParentVariable); • De eerste child package kent een waarde toe aan de variabele; • De parent package geeft de aangepaste waarde van variabele met package configurations door aan de tweede child package.

Fig. 14 : De variabele wordt gevuld door child package 1 en vervolgens gelezen door child package 2

Fig. 11 : De relatie tussen de ErrorColumn waarde en de bijbehorende veldnaam

22

MAGAZINE

Installatie (bestandssysteem of SQL Server) SSIS kan een package vanaf het bestandssysteem of een SQL Server instantie laden. Tijdens het bouwen van packages staan de packages op het bestandssysteem, terwijl de packages in de productie omgeving in een SQL Server instantie staan. Bij het aanroepen van child packages vanuit een parent package, gebruikmakend van een Execute Package task, dien je rekening te houden

DATABASES

met de fysieke omgeving waar de child package is opgeslagen. Voor een child package dat SSIS vanaf het bestandssysteem laadt, is namelijk een ander type connection manager nodig dan voor een SQL Server instantie. Dit is eenvoudig op te lossen met een variabele, gekoppeld aan package configurations, en door het definiëren van de expressies Connection en PackageName van de Execute Package task. In deze expressies selecteer je afhankelijk van de waarde van de variabele de juiste connection manager. In de voorbeeldapplicatie is de variabele IsProduction gedeclareerd als van het type Boolean dat aan de package configurations gekoppeld is. Er zijn twee connection managers toegevoegd, één File connection manager die verwijst naar de package ExtractData.dtsx op het bestandssysteem en één OLE DB connection manager die verwijst naar een bepaalde SQL Server instantie. De Execute Package task “ExtractData” voert een child package uit waarvan de expressies Connection en PackageName zijn gedefinieerd.

heb je alléén de keuze uit Visual Basic.NET. Gelukkig kan er in SQL Server 2008 wel naar hartelust in C# gebouwd worden. Conclusie Als doorgewinterde .NET ontwikkelaar krijg je bij het bouwen van een SSIS applicatie al vrij snel het gevoel dat je beperkt wordt in je bewegingsvrijheid. Met een aantal standaard bouwblokken moet de gehele functionaliteit worden gebouwd. Echter, als je eenmaal aan het bouwen bent met SSIS, heb je snel iets werkends in elkaar gezet en leer je vrij snel waar welke trucs nodig zijn om bepaalde uitdagingen op te lossen. Tijdens het ontwikkelen kom je zo nu en dan situaties tegen waarin je simpele functionaliteit op een vrij omslachtige manier moet bouwen; de Script task en het Script component bieden hier vaak een uitkomst. Gelukkig zijn er veel bedrijven die al dan niet open source SSIS componenten aanbieden waardoor deze omslachtige methoden niet meer nodig zijn. Ondanks dat SSIS hier en daar nog zijn eigenaardigheden heeft, is SSIS uitermate geschikt om op een productieve manier en snel een goede ETL-oplossing te bouwen. Referenties Op het internet is ontzettend veel informatie te vinden over SSIS; hieronder zijn de belangrijkste bronnen bij elkaar gezet.

Fig. 15 : De Connection en PackageName expressies van de Execute Package task De Connection expressie selecteert de OLE DB connection manager (CM_SQL_ExtractData) of File connection manager (CM_FILE_ExtractData), afhankelijk van de IsProduction waarde. De PackageName expressie is leeg voor de File connection manager, en bevat de naam van de package voor de OLE DB connection manager. Indien de package naam een punt bevat, moet je er rekening mee houden dat deze punten automatisch worden vervangen door spaties wanneer je deze packages op een SQL Server instantie installeert. Een best practice is dan ook om geen punten te gebruiken in package namen. Mee leren leven... En dan zijn er nog zaken waar de wenkbrauwen van menig SSIS-ontwikkelaar van gaan fronzen, maar waar we mee moeten leren leven: • Packages kun je voorzien van commentaar met annotations. Deze annotations kun je helaas niet kopiëren en ze zijn niet gekoppeld aan tasks; • Indien je een aantal keurig uitgelijnde tasks van de ene package naar een andere package kopieert, verandert de layout van deze tasks in de doel package; • Als je de metadata van een package met meerdere tasks verandert (er veranderen bijvoorbeeld datatypes van bepaalde velden), zul je de meeste tasks moeten verversen. De Union task is echter een vreemde eend in de bijt, omdat je deze task niet kunt verversen. De enige manier om dit op te lossen is door de task te vervangen door een nieuwe; • In de control flow zijn er genoeg situaties te bedenken die simpel met een if-then-else opgelost zouden kunnen worden. SSIS bevat helaas geen if-then-else of case task. Een workaround is om een Script task met bijbehorende Constraints en expressies te gebruiken of een For Loop Container task waarin de EvalExpression expressie de oplossing biedt; • In de control flow kun je Script tasks debuggen, zoals elke ontwikkelaar gewend is (breakpoints, watches, etc.). In de data flow kun je de Script componenten echter niet debuggen waardoor allerlei trucs nodig zijn, zoals door gebruik te maken van de oude, vertrouwde messagebox of door de fouten middels een error output naar buiten te sturen; • SSIS ondersteunt het .NET Framework, maar als C# ontwikkelaar

• Microsoft MSDN: http://msdn.microsoft.com/en-us/library/ms141026(SQL.90).aspx • Microsoft Communities: http://www.microsoft.com/communities/newsgroups/en-us/default.aspx?dg=microsoft.public.sqlserver.integrationsvcs • http://social.msdn.microsoft.com/Forums/en-US/sqlintegrationservices/threads/ • Microsoft Team Blog: http://blogs.msdn.com/mattm/about.aspx • SQL Server Central: http://www.sqlservercentral.com/articles/Integration+Services •

Johan Machielse Johan Machielse is Solution Developer bij Avanade en is gespecialiseerd in Microsoft technologiën, zoals .NET en SSIS. Voor vragen of opmerkingen is hij te bereiken via [email protected].

Core Systems

TIP:

CUT en PASTE commando’s (ISPF) Om veelvuldig hetzelfde blok tekst in een source te kunnen plakken kan handig gebruik worden gemaakt van de CUT en PASTE macro’s. Selecteer de gewenste tekst en gebruik het commando CUT om deze tekst op het clipboard te plaatsen. Met het commando PASTE is de tekst op de gewenste plek in de source te kopiëren. Om te voorkomen dat PASTE de tekst van het clipboard verwijdert, kun je het volgende doen: open voordat je PASTE gebruikt het clipboard m.b.v. CUT DISPLAY; selecteer met de optie “O” (Toggle read-only) en verlaat het clipboard (PF3); kopieer vervolgens de tekst zo vaak als je wil met het commando PASTE .


Advertentie Bergler

.NET ASP

Michiel van Otegem

ASP.NET onder de Motorkap: ASP.NET 4.0 op bezoek bij je browser Het is je vast niet ontgaan dat Microsoft druk bezig is met de volgende versie van .NET en Visual Studio. Op het moment dat dit SDN-Magazine op de mat ligt zou het best kunnen zijn dat Beta 2 al beschikbaar is. Op 25 september is de Nederlandse community getrakteerd op een voorproefje van Beta 2 door niemand minder dan Scott Guthrie, de bedenker van ASP.NET, die te gast was bij dotNED. Toen ik Scott Guthrie in 2000 leerde kennen was hij de lead developer van ASP.NET, maar hij is in sneltreinvaart hogerop geklommen binnen Microsoft en is inmiddels Corporate Vice President. Ondanks dat hij op dat niveau is aanbeland staat Scott nog zelf met z’n poten in de modder en geeft hij zelf zijn demo’s en kan hij op veel technische vragen antwoord geven. Aan de hand van een veelheid aan demo’s behandelde Scott op 25 september een hoop, maar het meest opvallende voor ASP.NET, afgezien van allerlei verbeteringen aan Visual Studio, ging over dat wat zich in de browser afspeelt, terwijl ASP.NET toch bij uitstek een server gebaseerde technologie is. Microsoft heeft echter begrepen dat de slag om het internet zich niet meer afspeelt rond de mogelijkheden van de servertechnologie, maar verplaatst is naar dat wat je in de browser kunt doen en hoe goed je standaarden kunt ondersteunen. Het beste voorbeeld hiervan is een nieuwe feature van ASP.NET AJAX die Client Template Rendering (CTR) genoemd wordt. Met CTR kun je een HTML-sjabloon definiëren dat in de browser voorzien wordt van data. Eigenlijk is dit net als een ListView-control die je aan een gegevensbron koppelt, maar dan gebeurt de DataBinding in de browser. Aanpassingen op bijvoorbeeld de sortering zijn daardoor vrijwel onmiddellijk, omdat er geen request naar de server hoeft te gaan voor andere data. Wanneer je CTR toepast op lijstdata, dan doe je dit met de zogenaamde DataView-control.

<style type="text/css"> .sys-template { display:none; } .selecteditem { color: Red } <script type="text/javascript" src="http://ajax.microsoft.com/ajax/beta/0909/ MicrosoftAjax.debug.js"> <script type="text/javascript" src="http://ajax.microsoft.com/ajax/beta/0909/ MicrosoftAjaxTemplates.debug.js"> <script type="text/javascript" src="ContactsService.svc/jsdebug">

{{ Firstname }}

Voornaam: <strong>{binding Firstname}

Achternaam: <strong>{binding Lastname}

Fig. 1: Master-Detail met Client Template Rendering Het vreemde voor “old school” ASP.NET ontwikkelaars is dat dit geen server control is, maar een client control. Je kunt deze simpelweg koppelen aan ieder JavaScript array, ongeacht of je die statisch definieert, programmatisch opbouwt of ophaalt met een webservice-aanroep.

Als je wilt kun je de DataView control ook direct, declaratief, koppelen aan een webservice en kun je zonder een regel code Master-Detail schermen maken zoals in figuur 1. De HTML die nodig is voor figuur 1 vind je hierboven. Merk op dat hier geen ASP.NET code in zit … het is dan ook een gewone HTML-pagina, maar wel met het een en ander aan referenties naar ASP.NET AJAX-scripts en naar een webservice! Vind je dit zo cool dat je er nu al mee aan de slag wilt? Op http://aspnet.codeplex.com/Release/ProjectReleases.aspx? ReleaseId=32770 kun je de meest recente release en voorbeelden downloaden. Veel plezier! •


CORE SYSTEMS

Christiaan Heidema

XML-Parsing in COBOL Sinds de intrede van de SOA-principes is XML in de praktijk de standaard geworden voor gegevensoverdracht tussen applicaties. Met behulp van XML worden gegevens gestructureerd vastgelegd en zijn ze leesbaar voor zowel mens als machine. Ook COBOL-applicaties hebben te maken met gegevensstromen die op XML gebaseerd zijn. Het realiseren van een XML-parser in COBOL is echter geen eenvoudige klus. Bovendien hebben de UNSTRING en STRING statements de naam een zware claim op het CPU-gebruik te leggen. In veel transactie georiënteerde omgevingen - waarin een hoge verwerkingssnelheid een vereiste is - heeft men daarom in het verleden besloten om de XML-parsing buiten de COBOL-applicaties te houden. Maar de ontwikkelingen op het gebied van COBOL staan niet stil. Mede door de introductie van ISO-2002 COBOL worden steeds meer COBOL-compilers uitgerust met functionaliteit voor het parsen en genereren van XML. Een voorbeeld hiervan is de Enterprise COBOL compiler. Tijd om de in het verleden gemaakte keuzes met betrekking tot XML-parsing te evalueren. Keuzes Grofweg zijn de aanvankelijk gekozen oplossingen vanuit de keuze om XML-parsing buiten COBOL te houden in twee groepen onder te verdelen (zie figuur 1). In beide gevallen wordt gebruik gemaakt van een externe XML-parser danwel -generator.

In de tweede oplossing (II) wordt de data wel in XML-formaat aan het programma aangeboden, maar roept het programma zelf een externe XML-parser aan. Deze parser vertaalt de XML-data naar een COBOLdatastructuur en geeft deze terug aan het programma. De data wordt verwerkt en eventueel aan een XML-generator aangeboden die de data vanuit een COBOL-datastructuur vertaalt naar XML. Het programma geeft deze data in XML-formaat terug. De XML-parser danwel -generator wordt aangeroepen met een complete verzameling aan regels voor het vertaalproces. XML-Statement Beide oplossingen hebben zich in de loop van de jaren bewezen, en COBOL is gebleken een overlever te zijn en is meegegaan met de nieuwe technologieën. Een van de speerpunten hierbij is de integratie met XML. Hiervoor is de verzameling van statements uitgebreid met het XML-statement. Voor het parsen van XML: XML PARSE identifier PROCESSING PROCEDURE [IS] procedure-name [THROUGH|THRU procedure-name] [[ON] EXCEPTION imperative-statements] [NOT [ON] EXCEPTION imperative-statement] [END-XML]

Voor het genereren van XML:

Fig. 1: Traditionele keuzes XML-parsing In het eerste geval (I) wordt de te verwerken XML aangeboden aan een XML-parser die vervolgens de inhoud van de XML-data omzet naar een COBOL-datastructuur. Deze datastructuur wordt aan het COBOL-programma doorgegeven, die vervolgens deze data verwerkt. Wanneer data in XML-formaat moet worden teruggegeven, dan retourneert het COBOL-programma de data in een COBOLdatastructuur. Deze wordt vervolgens aangeboden aan een XMLgenerator die deze datastructuur omzet naar XML. In dit geval weet het COBOL-programma niet dat de data oorspronkelijk in een XMLstructuur is aangeleverd. De enige functie van het programma is het verwerken van de data en eventueel het retourneren van data.

26

MAGAZINE

XML GENERATE identifier FROM identifier [COUNT [IN] identifier] [[ON] EXCEPTION imperative-statements] [NOT [ON] EXCEPTION imperative-statement] [END-XML]

De werking van XML PARSE verschilt nogal ten opzicht van XML GENERATE. Aan de hand van een voorbeeld wordt de werking van beide statements uitgelegd. XML PARSE Statement Met behulp van het XML PARSE statement wordt de interne XML-parser aangeroepen. Deze parser controleert of de XML well-formed is en geeft de besturing terug aan het aanroepende programma, o.a. bij elk begin en einde van een document, element, attribuut en content. Deze event-driven benadering is de grote kracht van deze parser. Hierdoor

CORE SYSTEMS

is het mogelijk om de besturing over de verwerking van de aangeleverde data volledig in het aanroepende programma te houden.

XML Parsing werkt op basis van een event-driven benadering Listing 1 toont een voorbeeld van het gebruik van het XML PARSE statement. Parse-XML section. * * *

Parse XML within XMLin using internal parser XML Parse XMLin processing procedure is XML-event-handler on exception perform XML-Error not on exception Display 'XML succesfully processed' End-XML.

Listing 1: Aanroep van de interne XML-parser De gespecificeerde processing procedure (in dit geval XML-eventhandler) wordt voor elk event door de parser aangeroepen. Een event kan b.v. gevonden content zijn of het einde van een element. Voor de communicatie tussen de parser en de processing procedure is een aantal special registers in het leven geroepen. De meest gebruikte zijn weergegeven in tabel 1. XML-EVENT

De naam van het opgetreden event

XML-CODE

Een numerieke waarde die status van de parsing weergeeft

XML-TEXT

Aanvullende informatie over het event, is afhankelijk van de waarde van het event

Tabel 1: Meest gebruikte special registers voor XML PARSE De event-handler De processing procedure is in feite een event-handler voor de parser. Listing 2 toont een voorbeeld van een event-handler. XML-event-handler section. * * * * *

XML PARSE processing procedure. This procedure is called every time an event occurs evaluate XML-Event when 'START-OF-DOCUMENT' perform startOfDocument-Handler when 'END-OF-DOCUMENT' perform endOfDocument-Handler when 'START-OF-ELEMENT' perform startOfElement-Handler when 'END-OF-ELEMENT' perform endOfElement-Handler when 'CONTENT-CHARACTER' when 'CONTENT-CHARACTERS' perform contentCharacters-Handler when 'ATTRIBUTE-NAME' perform attributeName-Handler when 'ATTRIBUTE-CHARACTERS' perform attributeCharacters-Handler when 'EXCEPTION' perform exception-Handler when other display 'Unknown event : ', XML-Event end-evaluate.

Listing 2: Voorbeeld van een event-handler

Het register XML-EVENT bevat de naam van het event dat opgetreden is. Afhankelijk van deze waarde wordt een subhandler aangeroepen. Zo wordt startOfElement-Handler aangeroepen op het moment dat het event ‘START-OF-ELEMENT’ optreedt. In dit geval bevat XMLTEXT de waarde van het element. Op deze wijze kan het programma zelf bepalen welke elementen al dan niet verwerkt worden. Als ontwikkelaar krijg je hier een leuke uitdaging voor je kiezen. De parser geeft namelijk alleen de naam van het element mee en niet de namen van de elementen waar het onderhanden element onderdeel vanuit maakt. Als we kijken naar de XML in listing 3, dan zien we een aantal elementen met dezelfde naam onder de verschillende groepselementen voorkomen, zoals en . De event-handler moet hier rekening mee houden en is zelf verantwoordelijk voor het bijhouden van het pad naar de verschillende elementen. Op basis van dit pad kan de handler besluiten om data te negeren of juist te valideren en te verwerken. De events ‘CONTENT-CHARACTER’ en ‘CONTENT-CHARACTERS’ treden op bij het parsen van de content van een element. Per element kunnen deze events meerdere keren optreden. Dit heeft te maken met de afhandeling van karakters met een specifiek doel binnen XML (<,>,&,' en ") . Voor deze karakters zijn aparte entity references gedefinieerd (< - < - & - ' - "). De tekst “Jip & Janneke taal” wordt in well-formed XML weergegeven als volgt: “Jip & Janneke taal”. 2009-06-12 83738 26736 J. van Couver
86353 The Best of ABBA 2 24.89 94432 COBOL 2002 Standards 54.55

Listing 3: Voorbeeld XML voor verkoop van order Wanneer we deze tekst door de parser halen, dan treedt eerst het event “CONTENT-CHARACTERS” op. XML-TEXT bevat in dit geval de waarde “Jip ” (let op de spatie). Vervolgens treedt het event “CONTENT-CHARACTER” op. De parser heeft de entity reference “&” vertaald naar “&” en in XML-TEXT geplaatst. Vervolgens treedt “CONTENT-CHARACTERS” weer op voor het laatste deel van de naam “ Janneke taal”. Om de volledige naam te kunnen formeren, moet bij het afhandelen van deze events moet de waarden van XML-TEXT aan elkaar geplakt worden (zie listing 4). contentCharacters-Handler section. * * *

Append content of XML-Text to content-buffer string XML-Text( 1 : Length Of XML-Text ) delimited by size into contentBuffer with pointer contentBufferPtr end-string.

Listing 4: Afhandelen event CONTENT-CHARACTER(S) magazine voor software development 27

CORE SYSTEMS 03 SalesLogEntry

Op het moment dat het event “END-OF-ELEMENT” optreedt, bevat contentBuffer de volledige content van het betreffende element. De initialisatie van de variabelen contentBuffer en contentBufferPtr moet plaats vinden bij het begin van de verwerking van de content, dus als het event “START-OF-ELEMENT” optreedt. Exceptions en controles De XML-parser van COBOL voert alleen controles uit om vast te stellen of de XML-code goed is opgezet. Is dit niet het geval dan treedt het event “EXCEPTION” op. Bovendien treedt dan de ON EXCEPTION clause van het XML PARSE statement in werking. In het register XMLCODE wordt met een cijfer aangegeven wat de oorzaak van de fout is (het cijfer 5 betekent ‘start-tag en end-tag komen niet overeen’ ). De afhandeling van deze exceptions ligt bij het programma zelf. De parser stopt zodra XML-CODE een waarde anders dan nul heeft. Er zijn situaties denkbaar dat je dit niet wil. Voor bepaalde waarden van XML-CODE kun je forceren dat de parser doorgaat nadat er een EXCEPTION-event is opgetreden. De parser controleert namelijk in deze gevallen nádat de event-handler is aangeroepen of XML-CODE de waarde 0 heeft. Door de handler voor het afhandelen van het EXCEPTION-event XML-CODE de waarde 0 te laten geven, geef je een signaal aan de parser dat het probleem is verholpen. Je forceert hiermee dat de parser doorgaat daar waar hij is gebleven.

05 05 05 05

01 entryCount

Handle exception event display 'XML Parse Error'. display 'Error code : ', XML-Code. display 'Current path : ', elementPath.

*

force parser to proceed. move zero

to XML-Code.

pic 9(03) binary.

Listing 6: Datastructuur Saleslogboek mutaties De event-handlers uit listing 2 dragen zorg voor het vullen van deze datastructuur. Op het moment dat het event “END-OFDOCUMENT” optreedt zijn er geen producten meer en kunnen de mutaties naar het logboek worden geschreven. Het genereren van de XML om deze mutaties aan het logboek toe te voegen is vrij eenvoudig (listing 7). endOfDocument-Handler section. * * *

End of XML reached, generate XML for Saleslog XML generate XMLout

from SalesLog count in XMLout-length

on exception Display 'Error during generating XML' not on exception perform Send-XML End-XML.

exception-Handler section. * * *

SalesLogCategory SalesLogProduct SalesLogAmount SalesLogValue

occurs 10 depending on entryCount. pic x(01). pic 9(10). pic 99. pic 9(05)v9(02).

Listing 7: Voorbeeld XML GENERATE Het XML GENERATE statement genereert op basis van zowel de structuur als de inhoud de XML. De uitvoer is weergegeven in listing 8. <SalesLog> <SalesLogDate>2009-06-12 <SalesLogEntry>

Listing 5: Exception handler

<SalesLogCategory>2

Het programma voert zelf ook validaties op de data uit. Wanneer blijkt dat een bepaald element een onjuiste waarde bevat, kun je er voor kiezen om de parser te laten weten dat er een fout is opgetreden door XML-CODE de waarde -1 te geven. Op het moment dat de parser de besturing weer terugkrijgt wordt het parse-proces dan afgebroken. De parser controleert niet of de content voldoet aan de specificaties. De verantwoordelijkheid voor deze controles ligt bij het programma dat de parser aanroept. Dit betekent dat wanneer strikte XML-controles noodzakelijk zijn, alle controles in het programma gecodeerd moeten worden.

<SalesLogProduct>86353 <SalesLogAmount>2 <SalesLogValue>49.96 <SalesLogEntry> <SalesLogCategory>1 <SalesLogProduct>94432 <SalesLogAmount>1 <SalesLogValue>54.55

Genereer XML vanuit een COBOL datastructuur met één statement XML GENERATE Statement Naast het parsen van XML bestaat ook de mogelijkheid om XML door COBOL te genereren. Hiervoor is het XML GENERATE statement in het leven geroepen. Met behulp van één aanroep naar dit statement is het mogelijk om een complete COBOL datastructuur naar XML om te zetten. Om dit te illustreren wordt op basis van de voorbeeld XML in listing 3 elke verkoop van een product geregistreerd in een saleslogboek. De mutaties op dit logboek worden met behulp van XML aangeleverd. We gebruiken hiervoor de datastructuur in de workingstorage section van listing 6. * * *

Datastructure for saleslog 01 SalesLog. 03 SalesLogDate

28

MAGAZINE

pic x(10).

Listing 8: Uitvoer XML Generate De tag-namen worden door de compiler afgeleid uit de definitie van de datastructuur in de working-storage section. De inhoud van de datastructuur wordt ontdaan van voorloopnullen en –spaties en de speciale karakters worden vertaald naar entity references. Lege velden, velden gevuld met spaties, worden in de XML opgenomen als elementen met een waarde gelijk aan één spatie. De DEPENDING ON clausule bij de OCCURS zorgt ervoor dat alleen de gevulde occurences van de tabel worden meegenomen bij het genereren van de XML. Laat je deze weg, dan wordt voor de gehele tabel XML gegenereerd. Hoewel dit een krachtig en eenvoudig mechanisme is om XML te genereren, missen we ook een aantal zaken. Zo is het bijvoorbeeld niet mogelijk om attributes te genereren. In het voorbeeld van listing 3 bevat het element “product” een attribuut “category”. Met het XML GENERATE statement is het niet mogelijk om onderscheid te maken tussen attributen en elementen. Enterprise Cobol ondersteunt vanaf

versie V4.1 wel de generatie van attributen door de toevoeging van de clause WITH ATTRIBUTES. Hierbij worden alle elementaire velden niet als element maar als attribuut opgenomen. Tevens worden vanaf deze versie extra features ondersteund voor het gebruik van encoding, namespaces en namespace-prefixes. Nogmaals: keuzes Nu COBOL zelf krachtige functionaliteit biedt om XML-data af te handelen, moeten we dan de in het verleden gemaakte keuzes maar over boord gooien? Dat is nog maar de vraag. Vanuit architectuuroogpunt is hier wel veel voor te zeggen. De volledige afhandeling van XML vindt namelijk op één plek plaats. Maar ook voor de ontwikkelaar biedt het gebruik van de interne parser veel voordelen. Het biedt hem namelijk veel vrijheid bij het parsen van XML. Hij heeft veel controle over de mapping van XML-data op een COBOL-datastructuur. Validaties kunnen naar eigen inzicht gerealiseerd worden. Niet gebruikte elementen en attributen kunnen genegeerd worden. Maar wanneer de organisatie strikte eisen stelt aan b.v. XML-validatie aan de hand via een XSD, betekent het gebruik van deze parser wel een enorme workload voor de ontwikkelaar. Alle validatieregels moeten door de ontwikkelaar zelf worden gecodeerd. In deze situatie is het gebruik van een externe parser te rechtvaardigen of zelfs te adviseren. Het gebruik van slechts één statement om een volledige datastructuur om te zetten naar XML is wel een zeer krachtige manier om XML te genereren, maar er zijn ook beperkingen die door het gebruik van een externe parser opgelost kunnen worden. Denk ook hierbij aan XML-validatie tegen een XSD. Ook hierbij geldt dat de eisen die de organisatie stelt aan de XML bepalend kunnen zijn voor de keuze van de XML-generator.

De COBOL XML-parser scoort zeer hoog op verwerkingssnelheid Advertentie Aladdin Conclusie COBOL vierde dit jaar zijn 50ste verjaardag en is daarmee een van de langst levende en meest gebruikte talen. Met de toevoeging van functionaliteit voor integratie met XML komt COBOL nog steviger in het zadel te zitten om deze positie te handhaven. De interne XML-parser presteert goed als het gaat om CPU-tijd en verwerkingssnelheid. Hierdoor is deze parser bijzonder geschikt voor transactie-georiënteerde applicaties, omgevingen waar COBOL de standaard is. De keuze voor het gebruik van de COBOL-functionaliteit ten opzichte van de externe parsers en generatoren zal voornamelijk gebaseerd worden op de eisen vanuit de organisatie. De ontwikkelingen op dit gebied staan echter niet stil. Wellicht dat de in het verleden gemaakte keuzes in de toekomst nog eens geëvalueerd moeten worden. •

Christiaan Heidema Christiaan Heidema is Mainframe Software Guru at Sogeti Nederland BV. During the last 12+ year Christiaan has worked in several mainframe environments as DBA, Engineer and Change- and Configuration-manager. He developed a passion for mainframe software solutions. His expertise encloses o.a. COBOL, DB2, IMS, CICS and JCL.

.NET UX

Dennis Vroegop

Surface development Veel mensen die Surface voor het eerst zien ervaren het als iets ‘magisch’. De gebruikers zien een Surface niet als een PC maar als een gebruiksvoorwerp, en uiteraard is dit precies wat de bedoeling is. Ook ontwikkelaars denken er zo over. Doordat de user interface niet lijkt op wat we gewend zijn van PC’s is de koppeling tussen PC- en Surface-ontwikkeling verbroken. Toch is het ontwikkelen van Surface-applicaties niet moeilijker dan het bouwen van andere applicaties met Windows Presentation Foundation (WPF). De moeilijkheid van het bouwen van Surface-applicaties ligt meer in het concept, de form factor en het maken van applicaties die van alle kanten benaderd kunnen worden. Liever gezegd: de ‘wat’ vraag is moeilijker te beantwoorden dan de ‘hoe’ vraag. De specifieke Surface-uitdaging Het ontwikkelen voor Surface is anders dan het schrijven van Windows of Web applicaties. Er zijn een aantal dingen die het zo anders maken: • Er is geen boven en onderkant van het scherm: de applicaties moeten in principe van alle kanten te benaderen zijn; • Er is niet één gebruiker met één muiscursor: er kunnen (horen?) meerdere gebruikers tegelijkertijd aan het werk (te) zijn die ieder hun eigen ding doen; • Alles vindt plaats in één scherm: je kunt beter geen gebruik maken van andere schermen en popup windows; • De resolutie is beperkt tot 1024 bij 768 pixels, je hebt dus niet al te veel schermuimte; • Maak weinig gebruik van tekstinvoer: Surface is geen ‘data entry’ platform; • Hou rekening met de fysieke beperking van de gebruikers: met een vinger is het moeilijk om heel nauwkeurig een element te selecteren. Vingers zijn minder nauwkeurig dan een muis! Dit klinkt allemaal nogal beperkend, maar in de praktijk valt dat best mee. Zeker de resolutie klinkt als een belemmering maar als je het ziet draaien op je 30” Surface machine ziet het er allemaal toch goed uit. Je kunt alleen niet al te veel elementen op je scherm kwijt. Ontwikkeltools Een Surface-machine is te krijgen in twee varianten: de commercial uitvoering en de developer uitvoering. Indien je bij Microsoft de laatste koopt, krijg je, naast de indrukwekkende hardware, ook alle tools die je nodig hebt om applicaties te schrijven. Ook mensen met een Academic Alliance MSDN abonnement (de MSDNAA leden) hebben toegang tot de software. Deze software bestaat uit een aantal onderdelen: 1. De simulator: deze gebruiken we om onze code op te testen als we niet direct bij de Surface unit kunnen komen; 2. Een SDK: alle libraries, samples en dergelijke zijn hier te vinden; 3. Een aantal tools: denk hierbij aan een tool om tags te printen en om je applicatie een stress test te laten ondergaan. De SDK draait momenteel alleen op 32-bitsversies van Windows Vista Business en hoger, en ook op Windows 7. Een 64 bits versie is er niet maar met enige hacken kun je dat wel aan de praat krijgen. Let wel op: dit is geen supported omgeving!

30

MAGAZINE

Je hebt uiteraard Visual Studio nodig, maar de C# Express-editie volstaat (dat is ook de versie die je bij je Surface-machine krijgt). Download wel SP1 en de XNA-toolkit; zonder deze installeert de SDK niet. XNA of WPF? Als je de SDK geïnstalleerd hebt, krijg je in je ‘New Project…’ dialoog in Visual Studio een paar extra templates te zien. Je kunt hier kiezen tussen een nieuw Surface-project in WPF of in XNA.

Fig. 1: Project-templates in VS2008 met Surface SDK Wat moet je nu kiezen? Ga je voor XNA of voor WPF? En waarom hebben we die keuze? Het antwoord daarop ligt in het verleden.

XNA of WPF: voor Surface maakt het niet uit Microsoft had ooit bedacht dat XNA het platform zou worden voor het ontwikkelen van applicaties voor devices. Als eerste was er de omgeving voor de XBox. Als je applicaties wilt ontwikkelen voor de XBox doe je dat in de XNA-omgeving. Later is daar de Zune bij gekomen: ook daarvoor moet je gebruik maken van de XNA-templates.

.NET UX Aangezien Surface gezien werd als device, lag het voor de hand om XNA in te zetten als ontwikkelplatform. Echter, tijdens de ontwikkeling van de SDK bleek dat er eigenlijk weinig verschil was tussen het bouwen voor Surface en voor normale Windows-applicaties. Toen is besloten om WPF als platform in te zetten als ontwikkelomgeving voor Surface. Het maakt niet zoveel uit welk van de twee je kiest, hoewel XNA iets meer gericht is op het low-level programmeren. Als je bijvoorbeeld de ruwe input van de camera’s wilt afvangen, moet je dat via XNA doen. WPF daarentegen biedt meer tools voor het schrijven van de business logic in je applicatie. Daarnaast, maar dat is een persoonlijk gevoel, vind ik het vreemd om een serieuze applicatie te schrijven waarbij de hoofdregels de code ‘Game app = new Game()’ bevatten. In de praktijk kiezen de meeste ontwikkelaars voor WPF.

Om applicaties te ontwikkelen heb je meer nodig dan alleen de Simulator. Na installatie krijg je dan ook nieuwe Visual Studio templates, een aantal tools en een nieuw stel WPF-controls. Controls Naast de standaard WPF-controls heb je na installatie van de SDK een extra set controls tot je beschikking. Deze controls zijn onder te verdelen in 3 categorieën: 1. Afgeleide controls, deze zijn varianten van de standaard WPFcontrols; 2. Surface-specifieke controls, oftewel controls die je alleen voor Surface-applicaties kunt gebruiken; 3. Non-Visual controls, die extra functionaliteit bieden. Je ziet de controls in figuur 3.

De simulator

Fig. 2: De simulator aan het werk Als je de SDK geïnstalleerd hebt, krijg je ook de Surface Simulator erbij. Deze tool stelt je in staat om je code op je werkstation te testen zonder dat je echt naar een Surface-machine moet gaan. Het is wel belangrijk dat je je werk regelmatig op een fysieke Surfacemachine draait: het is erg lastig om vanaf je desktop te controleren of je User Interface vanaf alle kanten van de tafel goed te gebruiken is. Ook het testen van je tags gaat makkelijker op de tafel zelf dan in de simulator. Toch zul je merken dat, naarmate je meer ervaren wordt in Surfacedevelopment, de Simulator een enorm goede tool is. Bij Microsoft zelf hebben ze bij het Surface-team slechts één Surface-machine per ongeveer 8 ontwikkelaars: 90% van de tijd werken zij in de Simulator. In de simulator kun je met meerdere muizen tegelijkertijd werken. Op die manier kun je meerdere gebruikers nadoen, maar in de praktijk is dat vrij lastig. Ik kan niet echt werken met een muis in iedere hand, maar misschien lukt het jou wel. Nodig is dit niet: je kunt met je muis een vinger nadoen, vastzetten en dan er een tweede vinger aan toevoegen. Je kunt je bewegingen opnemen en later weer afspelen zodat je een soort van test kunt maken. Je kunt vingers en objecten simuleren en uiteraard van bijna alle mogelijkheden van de Surface-omgeving gebruik maken. Je kunt niet bij de ruwe camerabeelden komen: de Simulator heeft immers geen echte fysieke camera’s aan boord. Voor de rest werkt de Simulator uitermate goed en is het een mooie manier om de bulk van je werk te doen. Alleen het fine-tunen en het testen van je applicaties hoef je dan nog op de Surface-machine zelf te doen.

Fig. 3: De toolbox met Surface-items Afgeleide controls Als je WPF gewend bent, ken je de standaard controls wel. Veel ervan kun je direct gebruiken in je Surface-applicatie; onze applicatie is immers een WPF-applicatie. Toch zijn er een paar dingen anders: Surface stelt speciale eisen aan de applicaties. Surface-applicaties zijn bedoeld om door (meerdere) mensen gebruikt te worden, met behulp van vingers en objecten. Dit betekent dat de standaard controls niet voldoen. Denk b.v. aan een standaard checkbox. Door het aanklikken van deze control kun je een vinkje plaatsen of verwijderen. Dit vakje echter is vrij klein, te klein om met je vingers te bedienen. Voor Surface is dus een grotere control gemaakt. Ook een Button is anders dan je gewend bent. Naast het grotere formaat is het gedrag van een button ook anders. Stel je eens voor: iemand plaatst zijn vinger op de button. Een tweede persoon plaatst zijn vinger ernaast, op dezelfde button. De eerste persoon verwijdert zijn vinger weer. Wat moet er nu gebeuren? In standaard Windowsapplicaties kennen we dit probleem niet: er is immers maar één muis. De Surface Button control zorgt ervoor dat dit soort gebeurtenissen goed afgehandeld worden (voor de volledigheid: er is een ContactRemoved event dat afgevuurd wordt voor iedere vinger die van de control af gaat, maar het Click-event wordt pas afgevuurd als alle vingers weg zijn.)


.NET UX De afgeleide controls staan in de volgende tabel: Control SurfaceScrollBar SurfaceButton SurfaceCheckBox SurfaceContextMenu SurfaceInkCanvas SurfaceTextBox SurfaceMenu SurfaceMenuItem SurfaceSlider SurfaceListBox SurfaceListBoxItem SurfaceRadioButton SurfaceScrollViewer SurfacePasswordBox

Opmerkingen

Bij voorkeur niet gebruiken Indien deze control geactiveerd wordt, verschijnt er een keyboard op het scherm. Er kan slechts één keyboard tegelijk aanwezig zijn. Bij voorkeur niet gebruiken Bij voorkeur niet gebruiken

Ook hier verschijnt bij het activeren een keyboard, echter de toetsaanslagen zijn niet zichtbaar. In een multi-user omgeving kun je twijfelen aan het nut hiervan (iedereen kijkt mee terwijl je het wachtwoord invoert...)

Bij een aantal van deze controls (vooral de menu’s) heb ik vermeld dat je ze beter niet kunt gebruiken. De reden hiervoor is dat het gebruik van menu’s niet intuïtief werkt, het staat de acceptatie van je applicatie in de weg. Indien je toch een menu wilt gebruiken, kun je beter voor de speciale ElementMenu kiezen. Surface specifiek Een aantal controls zijn speciaal ontwikkeld voor Surface. Momenteel zie ik hier en daar al open source libraries verschijnen met meer controls, dus je bent niet beperkt tot dit lijstje. Control ElementMenu ElementMenuItem LibraryBar LibraryBarItem LibraryStack LibraryStackItem LibraryContainer

ScatterView ScatterViewItem

Opmerkingen Een speciaal menu voor Surface. Werkt meer intuitief dan de standaard context menu maar is functioneel vergelijkbaar Dit zijn de items in het ElementMenu Een speciale container Items in de LibraryBar Een soort ListBox, maar dan met elementen over elkaar heen geplaatst. Items in de LibraryStack Een mengvorm van de LibraryBar en de LibraryStack: de gebruiker kan tijdens gebruik switchen tussen de LibraryBar en de LibraryStack modus Een soort ListBox waarbij de elementen vrij over het scherm kunnen worden verplaatst, geroteerd en vergroot of verkleind. De items die in de ScatterView zitten. Hier kun je per item aangeven of ze mogen worden verplaatst, van grootte veranderd en/of geroteerd.

In figuur 4 zie je een voorbeeld van een LibraryBar, met daarin 3 LibraryBarItems. De gebruiker kan deze met de vingers selecteren en ze eventueel ergens naar toe slepen.

gebeurt. Dit maakt het mogelijk om objecten te herkennen, iets wat met een aanraak-systeem niet zou kunnen. In je code moet je uiteraard ook bij de contacten kunnen. Veel contactgebaseerde events worden al opgevangen door de Surface-controls: een SurfaceButton b.v. kan zelf omgaan met de contacten die op het scherm geplaatst worden en er weer vanaf gehaald worden. Soms moet je echter zelf iets met de contacten doen. Het is b.v. mogelijk om te detecteren welke gebruiker iets op de machine doet. Nou ja, niet echt detecteren maar je kunt een aardige gok maken.

Surface is Vision Based, niet Touch Based Als iemand zijn vinger op het scherm plaatst, ziet het systeem dat. Het leuke is dat als je je vinger op het scherm neerzet, er een schaduw ontstaat onder je vinger; deze schaduw wordt lichter naarmate je vinger verder van het scherm is. Op deze manier ontstaat er een plaatje wat een beetje op een komeet lijkt: een duidelijke afdruk bij het puntje van de vinger met een vager wordende staat in de richting van de hand. Op basis daarvan kan de Surface-omgeving de hoek bepalen waaronder de vinger op het scherm staat, en daarmee kun je dus raden waar de gebruiker staat (mensen leggen hun vinger meestal in het verlengde van hun arm neer). private void OnContactDown(DependencyObject sender, ContactEventArgs e) { // Is het een vinger? if (e.Contact.IsFingerRecognized) { // Wat is de hoek? double angle = e.Contact.GetOrientation(this); // Bereken het kwadrant if (angle....) } }

Mocht je nu een contact op het scherm hebben wat geen vinger is, dan kun je de locatie, de bounding-rectangle enz. opvragen. Op die manier kun je alle soorten objecten herkennen en er iets mee doen. Tags Als je een Surface-machine koopt krijg je er een groot vel bij, met daarop 255 stickers. Deze stickers, voorzien van een stippenpatroon, kun je gebruiken om objecten te ‘taggen’. De stickers worden door Surface herkend en behandeld als Contacts. Dit stippenplaatje noemen we de tags.

Fig. 4: De LibraryBar in actie Non-Visual Controls Momenteel is er maar één non-visual control, en dat is de TagVisualizer. Hier ga ik later in dit artikel dieper op in. Hij staat hier alleen even voor de volledigheid.

Byte Tags Er zijn twee soorten tags: we kennen de byte tag en de identity tag. De byte tags bevatten, zoals de naam al suggereert, een bytewaarde. Ze kunnen dus waardes tussen 0 en 255 bevatten. Figuur 5 laat een voorbeeld van zo’n byte tag zien, in dit geval met de waarde 42 (2A hexadecimaal) Fig. 5: ByteTag 42

Contacts De kracht van Surface zit hem in het gebruik ervan. Een goede Surface-applicatie moet uitnodigen tot gebruik; mensen moeten er graag aan zitten. Nu is ‘eraan zitten’ niet zo’n probleem, maar het is wel prettig als we in onze applicaties ook iets kunnen doen met die aanrakingen. Surface is geen touch-systeem. Veel mensen noemen het een aanraakscherm maar dat is niet correct. Surface is, zoals dat zo mooi heet, vision based. Met andere woorden: er zitten camera’s in het systeem die door het scherm naar buiten kijken en detecteren wat er

32

MAGAZINE

Door het contrast tussen de witte stippen en de zwarte achtergrond kan Surface dit herkennen als een byte tag en de waarde daarvan doorgeven aan je applicatie. En hier komt de non-visual control TagVisualizer om de hoek kijken.

.NET UX De TagVisualizer control is een control die je ergens op je scherm plaatst. Je kunt hem het hele scherm laten beslaan of slechts een deel ervan. Op het moment dat het systeem at runtime een tag op een TagVisualizer ziet, zal het de juiste events afvuren zodat je weet waar de tag geplaatst is en welke waarde deze bevat. Kijk eens naar het volgende stukje XAML code: <s:TagVisualizer VisualizationAdded="TagVisualizer_VisualizationAdded" VisualizationRemoved="TagVisualizer_VisualizationRemoved"> <s:TagVisualizer.Definitions> <s:ByteTagVisualizationDefinition Value="#2A"/> <s:ByteTagVisualizationDefinition Value="#F0"/>

Hier plaatsen we in het scherm (het hele scherm om precies te zijn) een TagVisualizer. We geven hem twee event-handlers mee: één om af te vangen dat er een tag geplaatst wordt, en één om af te vangen dat de tag weer van het scherm genomen wordt. Verder definiëren we dat hij alleen mag reageren op de byte tags met de waardes #2A en #F0. Alle andere worden genegeerd. Meer heb je niet nodig om je systeem te laten reageren op tags! Nu is dit leuk, maar als je dit zou gebruiken krijg je op het moment dat de tag geplaatst wordt een standaard plaatje op je scherm, in de vorm van een draadkruis zoals we dat in schietspelletjes kennen. Dat is meestal niet wat je wilt: je wilt meestal een afbeelding, een stel controls of iets anders betekenisvols op je scherm plaatsen. Om dat voor elkaar te krijgen moeten we een speciaal soort UserControl definiëren, de zogenaamde TagVisualization class. Dit is gewoon een UserControl met wat extra waardes. Op het moment dat we dan een tag op het systeem zetten die herkend wordt, zal Surface een instance maken van deze UserControl en plaatst deze op de plek van de tag. Als je de tag draait, zal de UserControl mee draaien. Als je de tag verwijdert, verdwijnt ook de User Control. Dit is overigens instelbaar: je kunt er ook voor kiezen hem te laten staan, of pas na 10 seconden te laten verdwijnen, enz. <s:TagVisualization x:Class="SurfaceApplication2.MyTagVisualization" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/ presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="http://schemas.microsoft.com/surface/2008" Loaded="MyTagVisualization_Loaded" Width="200" Height="150"> <StackPanel Orientation="Horizontal"> <StackPanel> <StackPanel>

In bovenstaand voorbeeld definieer ik een TagVisualization class. Het is een user-control die twee labels weergeeft: een naam en een bedrijfsnaam. Op het moment dat deze aangemaakt wordt, wordt het MyTagVisualization_Loaded event afgevuurd. Hierin kunnen we dan kijken wat de bijbehorende Tag-waarde is zodat we de labels kunnen voorzien van zinnige data. Het enige wat we nu nog moeten doen is de ByteTagVisualization Definition die hoort bij de TagVisualizer, aanpassen zodat hij de nieuwe

control gebruikt. Dit doen we door de Source Property in te vullen met de naam van de XAML van de UserControl. Als we het systeem nu draaien en we plaatsen er de juiste tag op, ziet het er zo uit:

Fig. 6: Tags in action Het rode vierkantje is de gesimuleerde geplaatste tag van de Surface Simulator. Ik heb hem iets gedraaid zodat je ziet dat onze UserControl mee draait. Ik geef toe, echt zinvol is deze applicatie niet, maar met een beetje fantasie kun je zelf andere toepassingen bedenken. In de TagVisualization kun je ook nog aangeven waar de sticker zit op het fysieke object: het lukt namelijk vrijwel nooit (of is ook niet wenselijk) om je tag precies recht en in het midden van je object te krijgen. Identity Tags Byte Tags kunnen, zoals de naam al suggereert, een bytewaarde bevatten. Als je echter b.v. brieven naar al je klanten wilt sturen, en op die brieven een unieke tag wilt printen die ze dan in je winkel op de Surface kunnen leggen voor hun speciale, persoonlijke aanbieding, dan heb je aan 255 waardes waarschijnlijk niet genoeg. Je wilt meer mogelijkheden hebben, en om aan die wens tegemoet te komen is er in Service Pack 1 van de SDK de Identity Tag toegevoegd. De waarde van een Identity Tag is een GUID, dus een getal tussen de 0 en 2^128. Je hebt ruwweg 3.4e+38 mogelijkheden. Dat moet, zelfs voor de grootste bedrijven, voldoende zijn om alle klanten een unieke code te geven ;-). Identity Tags zijn groter dan Byte Tags. Ze worden ook iets minder snel herkend. Daarom is het aan te raden om Byte Tags te gebruiken voor objecten die veel verplaatst worden en Identity Tags voor objecten die vrij statisch op het scherm blijven staan. Voor je code maakt het niet veel uit of je Byte Tags of Identity Tags gebruikt: in de TagVisualizer schrijf je in plaats van een ByteTagVisualizationDefinition een IdentityTagVisualizationDefinition en je bent klaar. Oh ja, een Byte Tag heeft een value property, een Identity Tag heeft een Series (de eerste 64 bits) en een Value (de laatste 64 bits) property, maar voor de rest zijn ze gelijk. Ze zien er uit als in figuur 7.

Fig. 7: Identity Tag Deployment Het installeren van een applicatie op Surface gaat iets anders dan je wellicht gewend bent. De Visual Studio Template genereert een XMLbestand voor je met daarin een aantal settings die je nodig hebt voor het uitrollen van je applicatie naar de Surface-machine.


.NET UX Dit bestand ziet er als volgt uit: <ss:ApplicationInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ss="http://schemas.microsoft.com/Surface/2007/ ApplicationMetadata"> <Application> <Title>SDN Surface Demo applicatie voor de SDN <ExecutableFile> c:\apps\SurfaceApplication2.exe c:\apps\Resources\icon.png c:\apps\Resources\iconPreview.png

In dit XML-bestand zet je een aantal zaken: 1. De titel: deze verschijnt boven het menu-item in het Surfacemenu; 2. Een omschrijving: deze verschijnt onder het menu-item in Surface; 3. Het pad naar de executable: dit moet een absoluut pad zijn; 4. Eventuele argumenten om je applicatie mee op te starten; 5. Een pad naar een plaatje wat als icoon gaat werken: dit is geen echt Windows ioon, deze plaatjes zijn groter dan dat; 6. Een Preview: dit is wat getoond wordt als je applicatie de focus krijgt in het menu. Dit kan ook een video zijn waarin je laat zien wat je applicatie doet! Daarnaast heb ik in deze XML ook de tags gedefinieerd. Ik heb de Tag 2A (42 dus...) gekoppeld aan onze applicatie. Dit houdt in dat als iemand, wanneer dan ook, een bytetag op het systeem plaatst met deze code, hij de mogelijkheid krijgt om de applicatie direct op te starten. Dus: de applicatie kan gestart worden simpelweg door een object met de juiste tag te plaatsen.

Dit biedt enorm veel mogelijkheden: denk b.v. eens aan het onderwijs. De onderwijzer geeft aan een groepje kinderen een kaartje met daarop de tag die de rekenapplicatie start. Daarna krijgt een ander groepje een kaartje die de taal-applicatie toont. Geen moeilijke menu’s meer maar simpelweg iets op het scherm neerzetten en je applicatie draait! Om je applicatie uit te rollen moet je alle bestanden kopiëren naar de locatie die in het XML-bestand staat aangegeven. Daarna moet je het XML-bestand zelf plaatsen in de directory C:\ProgramData\Microsoft\Surface\Programs. Als je dat gedaan hebt, en je hebt geen fouten in je XML-bestand gemaakt, dan verschijnt je applicatie in het menu en je gebruikers kunnen er mee aan de gang!

De tools zijn er, de hardware is er, nu de ideeën nog! Conclusie Dit is slechts een korte introductie van de hulpmiddelen die je hebt als je gaat ontwikkelen voor Surface. Maar, als je eenmaal gewend bent aan de omgeving, zul je merken dat de techniek, hoewel uitdagend en spannend, niet de beperkende factor is. Het bedenken van goede Surface-oplossingen, die gebruik maken van de 360 graden interface, van objecten en het verschil tussen de fysieke en virtuele wereld wegneemt, dat is een stuk lastiger. Surface is typisch een omgeving voor mensen die niet (willen?) weten dat ze met een computer werken, hou daar rekening mee in je ontwerp. De tools zijn er, de hardware is er, nu de ideeën nog! De SDK is een goed stuk software waarmee je in staat bent om snel productief te zijn. Dus bedenk een goede oplossing, vind een Surface-machine om op te testen en leef je uit! •

Dennis Vroegop Dennis Vroegop is software architect bij Detrio, waar hij onder andere verantwoordelijk is voor het begeleiden van .NET projecten. Hij is een programmeur in hart en nieren en is een echt community mens. Momenteel is Dennis naast zijn normale werkzaamheden ook voorzitter van de Nederlandse dotNET gebruiksgroep .NET.

AGENDA 2009/2010 SDN Event – Hotel Houten, Houten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 december SDN Magazine Nr. 104 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 februari Microsoft SharePoint Connections 2010 – RAI Amsterdam . . . . . . . . . . . . . . .18 & 19 januari SDN Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 maart SDN Magazine Nr. 105 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 mei TechEd USA, New Orleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 – 11 juni SDN Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 juni Genoemde data onder voorbehoud 34

MAGAZINE

GENERAL

Interesting Things:

Writing Better Software Faster Looking back on twenty years of software development, I must have spent most of that time trying to improve the quality and productivity of software development. Ever since I started to write small applications in Turbo Pascal in 1988 I got infected with the writing-better-software-faster virus. Right after I finished the second of fourteen of these applications, I wrote my first framework. It took some effort, but writing the following twelve applications took me less time than building the first two. Darkening perspectives There are good reasons for increasing productivity and quality. First of all, we have to increase productivity by a hundred-fold to meet up with current demands, says Gartner. Furthermore, technology is becoming increasingly complex. Ten years ago I was working in both Microsoft and Java projects. Anno 2009, I’ve let go of the idea that I even have an overview of either one of them. It is hard enough working with a small subset of frameworks. A Silverlight designer is not likely knowledgeable in NHibernate. Being a Spring guru does not guarantee foxy JavaFX user interfaces. Despite this darkening perspective, there’s techniques and technologies that might keep you from drowning, by simply raising the level of abstraction. Good frameworks help. Smart use cases certainly do. And even UML assists. And then there’s model driven development a.k.a. model driven architecture a.k.a. model driven engineering a.k.a. domain specific languages. Different names for generating code and other deliverables from a model. What model? To be honest, any model will do the trick. Business process models, use case diagrams, user interface models, domain models, and last but not least data models. DIY Eight years ago I was helping a customer set up the domain model for a help desk application. After that I started to build the software in ASP.NET. Having modeled all domain objects, their properties and their services, I was typing them out in C#. Then, as any decent developer would do, I wrote a code generator. That helped. I suspect most code generation efforts have a similar empirical start. That’s probably why there are so many approaches to generating code. Some really high-brow, squeezing everything-and-thekitchen-sink into a model, and then trying to generate the whole application. From front to back. Or, at the very low and of the spectrum, inspecting the database, generating create-read-update-delete screens in a flat two-tier architecture. Where’s the value? Recently I was invited in a panel on model driven development, together with some academic and commercial experts. For starters, each of the panel members introduced their position briefly to the audience. This noteworthy event learned me two things. One: never allow four enthusiastic innovators talk freely on their innovations. The word ‘brief’ is not in their vocabulary. Two: coming from a business background, I didn’t have a clue to what model driven development does in the academic world. A whole new spectrum of approaches met my eye. So where’s the value in this? Following the good old Scrum adagio I’d say: it depends. Model driven development can be highly rewarding for projects. But I’ve also witnessed projects that

made a terrible mess of it. In my opinion, being successful at model driven development requires some preconditions to be met: • Embed approach. Successful model driven development projects share a single principle: it’s all in a day’s work. Model driven development is never a goal. It’s just a means to an end. Making better software faster. No guru’s, no heroes. • Allow changes. Projects go through changes. That’s a fact of life. Model driven development should never be blocking changes, but rather should stimulate creativity, by allowing projects to show quickly what effect new or changing requirements have. • Stabilize architecture. Knowing how to model and where to generate what code is key. Set up a stable (layered) software architecture, pick frameworks that match it, and only then elaborate on code generation. • Be pragmatic. My general advice in life also holds for model driven development. Be pragmatic. Never overdo it. Don’t try to squeeze the whole world in your model. It’s not necessarily a bad thing to still have to write some code manually. Skepticism? Having said all that, and having seen projects that very successfully apply model driven development, why is there still so much skepticism? After all, the paradigm really helps to deliver high quality at high productivity. After witnessing both highly successful and extremely failing model driven development projects recently, I have given this some consideration. The vast majority of projects are in the middle of the wide spectrum of approaches. They run smoothly, being fairly practical. But it’s the failing projects at either end of the spectrum that draw the attention. Highly complex, slow moving, rigor projects on the one end, and oversimplified, bug-absorbing, underestimated projects on the other end. It’s no fun at either end. No Jedi knight My team and I have always adopted a highly pragmatic approach to model driven development, modeling smart use cases, applying domain driven design, run the model through our code generators (Tobago MDA) and we’re set to go. We do make better software faster. Can life be this simple? It certainly can. We have applied this approach to all kinds of projects, and generated code in a variety of languages and frameworks, from Visual Basic to C#, from PHP and Java to Cobol. At the last SDC I checked out a combination of Silverlight, .NET RIA Services, ADF and (maybe) Fluent NHibernate. It was fun! To leave you with some words of wisdom (ahum). If there’s one thing I’ve learned from being successful at model driven development, it’s this: modeling and generating code should be everyday practice in your project. There’s no such thing as a “model driven development project”. There’s only software development projects. You don’t have to be a Jedi knight to steer a code generator. It’s all in a day’s work. Sander Hoogendoorn blog.sanderhoogendoorn.org •


Advertentie Avanade

DELPHI

Cary Jensen

Introduction to

LINQ, part 2

In part 1 of this 2 part series I provided you with a basic introduction to Language Integrated Query, or LINQ. In this second part I take a look at several specific implementations of LINQ, including LINQ to Objects, LINQ to DataSets, and LINQ to XML. I also have an opportunity to introduce iterator methods, special methods that you implement to return a sequence for use by LINQ queries. LINQ to Objects LINQ to Objects is any version of LINQ that does not employ a LINQ provider. Consequently, all LINQ queries that were shown in part 1 of this series were examples of LINQ to Objects. Here is another example. var Customers := GetCustomers; var query := from c in Customers where (c.Age > 10) and (c.Age < 40) and (c.Active = true) select c; for each m in query do ResultsList.Items.Add(String.Format("Name: {0}, Age={1}" [m.Name, m.Age]));

method GetLowDigits: sequence of Integer; iterator;

Next, the implementation of the iterator includes one or more calls to yield, which, like exit, can be used to return a value (though yield does not cause a return from the method in the same way that exit does): method MainForm.GetLowDigits: sequence of Integer; begin for i: Integer := 1 to 9 do yield i; end;

The following code demonstrates the use of this iterator: If you had wanted to create a query that produced a sequence of objects that only included the Name and Age members, you could have used the technique shown in part 1, where the select clause returned a newly created object (which was an anonymous object in that example, but could have been any compatible type). In the preceding query, a sequence of Customer objects is returned by the GetCustomers function. This particular function is an example of an iterator method. Iterator methods are discussed in the following section. Granted, this is a simple example. However, there are many different methods in the .NET framework class library that return arrays, collections, and other queryable data sources. As a result, it is possible to use LINQ to perform a wide variety of useful tasks.

Examples of some of these uses can be found in the Windows SDK for .NET 3.5 Examples of some of these uses can be found in the Windows SDK for .NET 3.5. For example, there are a number of examples of how to use LINQ to explore files and directories on the local file system. This is possible because method such as System.IO.Directory.GetFiles return an array of strings containing the names of the files in a given directory. Arrays, as you’ve seen, can be used in LINQ queries.

var numbers := GetLowDigits; for each n in numbers do MessageBox.Show(n.ToString);

Iterator methods are not executed when the sequence is assigned to a sequence reference. Specifically, the var declaration and initialization in the preceding code segment did not cause the GetLowDigits iterator to execute. Instead, it was the specific iteration over the sequence in the for each loop that caused the iterator to be executed. Furthermore, the iterator was not executed all at once. Specifically, the iterator is executed up until it returns the first element of the sequence (using yield), that element is then used by the for each loop, which will then call back to the iterator to get the next value in the sequence, and so on. The yield keyword can be used to return either a single element of the sequence or a reference to a sequence (which could be an array, a method that returns an array, or other similar reference). Here is another example of an iterator and a sequence. This code requires a type declaration, which looks like the following: Customer = class private FName: String; FAge: Integer; public property Name: String read FName write FName;

Iterator Methods and Yield Statements Iterators are special methods that return a sequence. You declare an iterator by including the iterator modifier in the method signature. Each element in the sequence is specifically returned by the iterator through a call to yield. This is demonstrated in the following code sample. First, the iterator is declared using the following statement.

property Age: Integer read fAge write FAge; end;

Here is the declaration of the iterator: method GetCustomers: sequence of Customer; iterator;


DELPHI

And here is the implementation of the iterator: method MainForm.GetCustomers: sequence of Customer; begin yield new Customer(Name:= 'Allan', Age := 10); yield new Customer(Name := 'Bob', Age := 25); yield new Customer(Name := 'Craig', Age := 18); end;

Finally, here is the iteration over the sequence: var Customers := GetCustomers; for each c in Customers do MessageBox.Show(c.Name);

The implementation of the iterator in this case used the new named parameters feature of constructors to return each of the customers (which in reality would have probably been populated with data from an external source, such as a database). Also, the Customers type declaration used type inference to determine that Customers variable was a sequence of Customer. What is LINQ to DataSets? LINQ to DataSets is a LINQ provider that permits you to use LINQ queries against DataTables, DataRows, and other classes in the ADO.NET framework. In order to use LINQ to DataSet, you must add the System.Data.DataSetExtensions assembly to the references section of your Delphi Prism project. This section is designed to provide you with a brief introduction to LINQ to DataSet. As such, it does not go into ADO.NET, which is the data connectivity framework in .NET. As a side note, LINQ to DataSet should probably be called LINQ to DataTable or LINQ to DataRows, or even LINQ to ADO.NET. None of the operations in LINQ to DataSet are performed on instances of the DataSet class. Instead, they are performed on DataTables and DataRows.

Adapter := new DataStoreDataAdapter ('SELECT * FROM CUSTOMER',connection); DataTable1 := new DataTable; DataTable1.TableName := 'Customer'; Adapter.Fill(DataTable1); var query := from cust ibn DataTable1.AsEnumerable where cust['ON_HOLD'].Equals(DbNull.Value) and (cust.Field<string>('STATE_PROVINCE') = 'CA'); for each c in query do begin ResultsList.Items.Add(String.Format ('Customer Number: {0}' + ' Company Name: {1}', c['Cust_No'].ToString, c['Customer'].ToString)); end; finally Connection.Close; end; end;

Once the DataTable has been populated with data from the SQL query, the AsEnumerable method of the DataTable is called, and this object is used in the LINQ query. Interestingly enough, the object returned from the AsEnumerable method is a generic IEnumerable, where the type is a collection of DataRows. The following figure shows how the sample application looks after the preceding code is executed.

LINQ queries can be performed on any object that implements the IEnumerable interface As you learned earlier in this series, LINQ queries can be performed on any object that implements the IEnumerable interface. DataTables (and DataRows) do not implement IEnumerable directly. However, they both have extension methods that support IEnumerable. These are defined in the DataTableExtensions class, which is located in the System.Data.DataSetExtensions namespace. This last point is an important one, as far as writing applications that use LINQ to DataSet is concerned. Specifically, you must add the System.Data.DataSetExtensions assembly to your project references folder (if it is not already there) before you can use LINQ to DataSet in a project. There are only three extension methods in the DataSetExtensions class. These are AsDataView, AsEnumerable, and CopyToDataTable. For DataTables, the key method is AsEnumerable, which returns an enumerable collection of DataRows (records). This is demonstrated in the following segment code. method MainForm.LINQToDataSet_Click(sender: System.Object; e: System.EventArgs); vabr Connection: DataStoreConnection; Adapter: DataStoreDataAdapter; DataTable1: DataTable; begin Connection := new DataStoreConnection(conStr); Connection.Open; try

38

MAGAZINE

As you consider this code segment, you might conclude that you would be better off using a SQL statement that performs the filtering of the results, rather than use a LINQ query. While that may be true in some instances, if you want to load a DataTable once, and perform numerous queries on the returned value, the LINQ query offers performance benefits. (Note that another alternative is to use a DataView to filter and sort the DataTable results.) It’s worth mentioning that in addition to LINQ to DataSet, the .NET framework provides the LINQ to SQL provider. Unlike LINQ to DataSet, which can be used against any database for which there is a .NET data provider, LINQ to SQL is specifically designed to work only with Microsoft SQL Server. LINQ to Entities is another LINQ provider that can be used against supported databases. What is LINQ to XML? LINQ to XML provides a programming model, similar to XPath, with which you can create, edit, query, and save XML documents. LINQ to XML provides you an alternative to using the XML DOM (document object model), which is what is used by the XMLDocument class in the .NET framework. Similar to the XMLDocument the DOM, LINQ to XML works with the XML document in memory. From there you can read,

DELPHI

query, and write data to the XML document, after which you can stream it to a service or write it to a file, if you desire.

LINQ to XML provides a programming model, similar to XPath, with which you can create, edit, query, and save XML documents As is the case with the LINQ to DataSet topic that precedes this section, this discussion is designed to provide you with a basic introduction to LINQ to XML. It does not, however, cover general XML issues. LINQ to XML is far more involved than LINQ to DataSet. This is because LINQ to XML not only supports features necessary for querying, but as mentioned earlier, an entire programming model for working with XML. As a result, this section will cover just enough information to get you started. Unlike LINQ to DataSet, where most of the functionality is found in extension methods added to DataTable and DataRow, LINQ to XML, found in the System.Xml.Linq namespace, includes a large number of concrete classes that you can use to work with XML documents. Of these classes, there are three that you are likely to use most often. These are XDocument and XElement, which descend from XNode, and XAttribute, which descends from XObject. (XNode, by the way, also descends from XObject.) You can create a valid XML document using either XDocument or XElement, though XDocument provides a little more support for this. Specifically, there are certain advanced features of XML documents that you can access through the XDocument class which are unavailable through the XElement class. XAttribute, by comparison, is used to define attributes of XML elements. But before you get started, at a minimum you will need to add the System.Xml.Linq namespace to your uses clause. In addition, you may have to add one or more of the following additional namespaces, depending on what features your code will use: System.Xml, System.Xml.Schema, System.Xml.XPath, and System.Xml.Xsl. Creating XML Documents using LINQ to XML As mentioned previously, you can create XML documents using either the XDocument or the XElement class. The following example demonstrates how to create an XML document using the XElement class. element := new XElement('customers', new XElement('customer', new XAttribute('custno', 1001), new XElement('name', 'John Doe'), new XElement('address', '101 Broadway Avenue'), new XElement('city', 'New York'), new XElement('state', 'NY'), new XElement('zip', '00123') ), new XElement('customer', new XAttribute('custno', 1002), new XElement('name', 'John Doe'), new XElement('address', '1001 Main Street'), new XElement('city', 'Los Angeles'), new XElement('state', 'CA'), new XElement('zip', '90123') ) ); element.Save(XmlFileName);

This code creates an XML file with a root element named customers. The root element has two child elements named customer. Each child element has one attribute and four child elements. The following is how the XML file created by this code looks. <customers> <customer custno="1001"> John Doe
101 Broadway Avenue
New York <state>NY 00123 <customer custno="1002"> John Doe
1001 Main Street
Los Angeles <state>CA 90123

Creating this same file using an XDocument looks similar, though there are differences. An example of using XDocument appears in the code sample. The documentation for LINQ with XML includes a large number of demonstrations of XML definition using declarations like the one provided previously. These declarations, however, are anything but flexible. In other words, they always create the same XML file, which is rarely useful. The following example, which obtains its data from an ADO.NET data reader, produces an XML file similar in structure to the preceding one, except that its data is entirely based on the results of a SQL query. Connection := new DataStoreConnection(conStr); Connection.Open; try Command := Connection.CreateCommand; Command.CommandText := 'select cust_no, customer, address_line1, ' + ' city, state_province, postal_code ' + 'from customer'; DataReader := Command.ExecuteReader; try document := new Xdocument (new XElement('customers')); while DataReader.Read do begin attribute := new XAttribute('custno', DataReader.GetString(0)); element := new XElement('customer', new XElement('name', DataReader.GetString(1)), new XElement('address', DataReader.GetString(2)), new XElement('city', DataReader.GetString(3)), new XElement('state', DataReader.GetString(4)), new XElement('zip', DataReader.GetString(5)) ); element.Add(attribute); document.Root.Add(element); end; finally DataReader.Close; end; document.Save(XmlFileName); finally connection.Close; end; document.Save(XmlFileName);


DELPHI

Querying with LINQ to XML Querying using LINQ to XML is similar to other LINQ queries, though there are classes and methods that you use in LINQ to XML that are not found in other LINQ technologies. In short, once you have a reference to a queryable object (an IEnumerable, a sequence, or other similar construct), you use query statements to retrieve the data you are interested in. The following example demonstrates a LINQ to XML query.

document := XDocument.Load(XmlFileName); var childList := from el in document.Descendants where String(el.Element('state')) = 'CA' order by String(el.Attribute('custno')) desc select el; //make changes for each e in childList do begin

element := XElement.Load(XmlFileName); var childList :=

e.Element('state').SetValue('California'); end;

from el in element.Elements

//save the changes

where String(el.Element('state')) = 'CA'

document.Save(XmlFileName);

order by String(el.Attribute('custno')) desc select new XElement('document', new XElement('CustomerName', el.Element('name')), new XElement('Address', el.Element('address')), new XElement('CityStateZip', el.Element('city').Value + ', ' + el.Element('state').Value + ' ' + el.Element('zip').Value)); for each e in childList do begin ResultsList.Items.Add(e.Element("CustomerName").Value); ResultsList.Items.Add(e.Element("Address").Value); ResultsList.Items.Add(e.Element('CityStateZip').Value); ResultsList.Items.Add(String.Empty); end;

This query returns a sequence of XElement references, which have a structure similar to, though different than, the original XElements. For example, the new XElements are not named customer, they are named document. Furthermore, there are no attributes in the new XElements, and there are only three child nodes.

There is an important characteristic of the preceding code that you should note. Specifically, the select clause of the LINQ to XML query returned a sequence of XElements from the original XDocument. While these represent a possible subset of all XElements returned by the Descendants method of the XDocument, they are still child elements of the original XDocument. When changes are made to the items in the sequence returned by the query, those changes are actually being made to the corresponding XElements in the XDocument. This is why the changes are preserved when the subsequent call to XDocument.Save is made. By comparison, if the select clause had created new XElements, similar to how the last query in the preceding section demonstrated, the subsequent changes would have been performed on the newly created objects, which are not child elements of the XDocument. Summary This two part series has provided you with a brief introduction to LINQ with Delphi Prism. Here you have learned how to construct LINQ Queries, the nature of LINQ to Objects, define and implement iterators, and have been given a preview of LINQ to DataSets and LINQ to XML. •

The preceding example demonstrated a query using the XElement class. The following code shows the same basic query, however an XDocument is used in this example. document := XDocument.Load(XmlFileName); var childList := from el in document.Descendants where String(el.Element('state')) = 'CA' order by String(el.Attribute('custno')) desc select new XElement('document', new XElement('CustomerName', el.Element('name')), new XElement('Address', el.Element('address')), new XElement('CityStateZip', el.Element('city').Value + ', ' + el.Element('state').Value + ' ' + el.Element('zip').Value)); for each e in childList do begin

Cary Jensen Cary Jensen is President of Jensen Data Systems, Inc., a training and consulting company that won the 2002 and 2003 Delphi Informant Readers Choice Awards for Best Training. He is an award-winning author of 20 books, including Advantage Database Server: A Developers Guide (2007, Sybase), Building Kylix Applications (2001, Osborne/McGraw-Hill), JBuilder Essentials (1998, Osborne/ McGraw-Hill), and Delphi in Depth (1996, Osborne/McGraw-Hill). For information about onsite training or consulting services, you can contact Cary at [email protected] or visit his web site at www.JensenDataSystems.com.

ResultsList.Items.Add(e.Element("CustomerName").Value); ResultsList.Items.Add(e.Element("Address").Value); ResultsList.Items.Add(e.Element('CityStateZip').Value); ResultsList.Items.Add(String.Empty); end;

Windows 7

Modifying XML using LINQ to XML Once XML is in memory, you can add elements or attributes, remove elements or attributes, as well as modify the data for elements or attributes. If you load the XML from an existing source, such as a file, make modifications, and then save the XML back to the original source, you have effectively changed the XML. This is demonstrated in the following code.

40

MAGAZINE

TIP:

Windows 7: Show Desktop De button voor het tonen van de desktop is verplaatst en zit nu naast de klok aan de rechterkant.

DOT NET NUKE

Brandon Haynes

Under the Hood: Security Services in

DotNetNuke 5.1 DotNetNuke is a highly robust web-application framework that is ideally suited for a wide variety of purposes, from simple websites to enterprise applications. Associated with the framework is a team of security professionals who are dedicated to ensuring that third-party developers are able to create secure modules (and that the DotNetNuke framework itself is maximally secured against external threat). In this way, DotNetNuke developers are able to quickly leverage security services provided by the core framework, allowing for more rapid development and increased overall quality. While in some cases these services serve merely to expose an easy-to-consume interface to already-existing .NET functionality (e.g. encryption and permissions), in many instances these services would not be available at the ASP.NET level without significant additional work (or by the consumption of an external library). Additionally, extensions which rely on core functionality are able to benefit from subsequent enhancements to the framework, typically without any modifications to the extension itself. Because of this, DotNetNuke developers are often able to design and deploy modules and extensions that are more secure, more quickly, and with less development effort expended.

DotNetNuke developers are often able to design and deploy modules and extensions that are more secure, more quickly, and with less development effort expended Herein we review some of the security-related services that are offered by the core DotNetNuke framework and discuss their ability to defend against real-world threats. Framework-Managed Authorization and Lifecycle DotNetNuke handles much of the routine authorization and instantiation logic on behalf of a developer. When a module is installed, it may register one or more controls that require explicit permission to access. When the module is later added to a page, an authorized party associates the ability to view and edit that instance with one or more security roles. Thereafter DotNetNuke manages this association; users who are not a member of one of the authorized roles will not only be disallowed from utilizing the associated control, but the control itself will not even be instantiated by the framework. The fact that the control is neither instantiated nor added to the control hierarchy ensures that some forms of attacks are made more difficult, and, most saliently, moves the responsibility for authorization out of the hands of the module developer and into the framework (where it should be). Only in specific scenarios will a module developer need to implement additional authorization logic at all.

The DotNetNuke.Security.PortalSecurity Class The PortalSecurity class contains a number of methods that may be leveraged by developers. In general, these methods may be categorized into groups that address input sanitization, encryption, privacy, and authorization. These methods are summarized in table 1. We explore each of these in more detail below. PortalSecurity Method InputFilter Encrypt Decrypt CreateKey ForceSecureConnection SignOut ClearRoles

Description Used to prevent malicious cross-site scripting (XSS) or SQL injection attacks. Encrypts a string given a key and value. Decrypts a string given a key and value. Creates a key of a given size using a cryptographically-strong algorithm. Requires that the current page be requested via the HTTPS protocol. Deauthorizes a user from the ASP.NET forms authentication system and clears all DotNetNuke-related cookies. Clears all cached role cookies associated with the current user.

Table 1: The public methods of the DotNetNuke.Security.Portal Security class PortalSecurity.InputFilter By far the most commonly-used method by module developers, DotNetNuke offers an InputFilter method that is designed to aid in reducing some of the most common data sanitization issues an extension developer is likely to experience. A flag specifies which of the five filter types are performed; we explore the subtleties of these flags in turn. FilterFlag.NoMarkup When this flag is set, the text is returned HTML-encoded if and only if the source text contains one or more tags (i.e. elements with an opening and closing marker such as ). This is by far the most secure filter with which to sanitize untrusted input, as it effectively fully mitigates the risk of malicious markup. Note that for data that are intended to be displayed as HTML (e.g. a forum post that by-design allows for limited markup), this method might not be suitable, as it will encode everything, including authorized markup. Table 2 illustrates some of the transformations that are performed by this filter method.


DOT NET NUKE Input Regular Text Text with <Markup /> Text without markup: 5 > 3

InputFilter(Input, FilterFlag.NoMarkup) Regular Text Text with <Markup /> Text without markup: 5 > 3

Table 2: Some sample HTML transformations using InputFilter with FilterFlag.NoMarkup FilterFlag.NoScripting When this flag is set, the InputFilter method attempts to remove any malicious markup within the input, as defined by a set of blacklisted HTML tags (e.g. form, script, and object). An appropriate use for this flag would be in instances where some limited HTML input was permitted (for example, a forum post) but malicious script must nonetheless be defended against. Because this configuration utilizes a blacklist set of disallowed tags, as opposed to a stronger whitelist set of allowed tags, this flag should only be used over FilterFlag. NoMarkup when specific use-scenario warrants its use. FilterFlag.NoSQL In a manner similar to the FilterFlag.NoScripting flag above, setting this flag causes a blacklisted set of dangerous SQL tokens to be removed from an untrusted source. In this manner, a developer may protect against SQL injection attacks - especially when the input text is used in conjunction with ad-hoc or dynamic SQL execution. Note, however, that many modern development techniques (such as parameterized stored procedures) offer greatly increased protection over that which is afforded here. Whenever possible, these techniques should be relied upon, and the FilterFlag.NoSQL filter should be used a secondary line of defense. FilterFlag.MultiLine and FilterFlag.RemoveAngleBrackets These flags exist, respectively, for legacy and one-off scenarios, and as such should rarely (if ever) be used during development. The MultiLine flag was historically utilized to replace newlines with a HTML line-break tag (“
”); this flag is no longer used within the core framework and exists as a likely candidate for deprecation. Similarly, the RemoveAngleBrackets flag simply removes angle brackets (“<” and “>”) from the input if and only if a RemoveAngleBrackets key is specified in the appSettings portion of the web.config. This flag does not provide any meaningful security (especially over the NoMarkup flag discussed above), and was included at the request of a major customer (1). As such, few if any circumstances exist that would warrant its use. Combining Flags and Caveats Because the flags associated with the InputFilter method exist as a bit field, multiple flags may be specified within a single call. An example of this is demonstrated in listing 1, where the input data will be encoded (via the FilterFlags.NoMarkup bit) and all blacklisted tags will be stripped (via the FilterFlags.NoScripting bit). Dim untrustedText =_ “
Markup
<script>alert(‘’);” Dim sanitizedText = New PortalSecurity() .InputFilter(untrustedText, _

noted – whenever the NoSQL flag is specified, the NoMarkup, NoScripting, and Multiline flags are ignored. Since the NoSQL flag is designed to be used whenever a dynamic or ad-hoc SQL statement is about to be executed this is generally acceptable, but a developer should nonetheless be aware of this subtle behavior. PortalSecurity.Encrypt, PortalSecurity.Decrypt, and Portal Security.CreateKey These two methods, given a key and input, encrypt and decrypt the input and return it as a base64-encoded string. In this way, module developers may quickly obfuscate data that may be recovered elsewhere. However, due to concerns about backward-compatibility, both of these methods internally utilize the DES algorithm. This algorithm is largely considered to be weak, and has been widely deprecated (3). Because of this, developers who require cryptographically-secure protection are advised to utilize other algorithms (such as AES or Triple-DES) until the DotNetNuke framework is enhanced to utilize a stronger encryption method; this is likely to occur in future release. Finally, the PortalSecurity.CreateKey utilizes the RNGCryptoServiceProvider to generate a sequence of n pseudo-random bytes; these bytes are encoded as a hexadecimal string before being returned. This algorithm is considered to be secure, and may safely be utilized for cryptographic purposes (4). A code sample demonstrating the generation of a 128-bit key is illustrated in Listing 2. Dim myKey As String = _ New PortalSecurity().CreateKey(128 / 8)

Listing 2: Sample code illustrating the generation of a 128-bit cryptographically-strong key PortalSecurity.ForceSecureConnection While DotNetNuke offers robust privacy options at the page level, allowing an administrator to require a private and confidential exchange (via SSL), there is currently no such option exposed at the module level. Thus, for modules which might present information that must not be viewed by third parties, it is up to the developer to ensure that privacy is maintained. The PortalSecurity.ForceSecureConnection may be utilized for this purpose; when called, it will ensure that the HTTPS-protocol is in use for the current request, and, if not, will redirect to a URI that utilizes a HTTPS-connection. Developers should carefully consider the sensitivity of the data presented in a module in determining if data privacy should be a precondition of display. PortalSecurity.SignOut and PortalSecurity.ClearRoles The PortalSecurity.SignOut method may be utilized to de-authorize a user from the DotNetNuke application. In addition to making a call to FormsAuthentication.SignOut, this method explicitly clears all DotNetNuke-related cookies (e.g. current language, authentication type, and cached portal association). Similarly, the PortalSecurity.ClearRoles method clears the security roles associated with a user that might be cached in that user’s cookies. This method is useful when a role is added or removed from the current user; a call to ClearRoles will ensure that the change is reflected immediately (rather than after cache expiration).

FilterFlag.NoMarkup Or Filterflag.NoScripting) Debug.Assert(sanitizedText = “
Markup
”)

Listing 1: A sample InputFilter call specifying two flags In general, the flags may be combined in any way that an enddeveloper desires, though in virtually all circumstances dealing with untrusted or user-supplied text the FilterFlag.NoMarkup bit will be set. However, there is one important exception to this rule that should be

42

MAGAZINE

PortalSecurity.IsInRole and PortalSecurity.IsInRoles As their names suggest, these methods are used to determine if the currently-authorized user is a member of a given role (or roles). When utilizing the plural version, a semicolon-separated list of roles is expected (e.g. “All Users;Subscribers”). Deny permissions may be included by including a “!” prefix on any role. For example, “!Subscribers” would return false for any user who was a member of the Subscribers role.

DOT NET NUKE Listing 3 illustrates some uses of these methods. If(PortalSecurity.IsInRole(“Administrators”)) Then Response.Write(“You are an administrator.”) Else If(PortalSecurity.IsInRoles(“Gold User;Subscribers”)) Then Response.Write(“You are a gold user OR you are a subscriber.”) End If

Listing 3: Sample code illustrating the use of the PortalSecurity. IsInRole and PortalSecurty.IsInRoles methods. File System Services DotNetNuke exposes a robust set of classes and static utility methods that may be used to interact securely with the file system. In many cases the appropriate leveraging of these services will save a developer considerable time and effort in effectuating a design, and at the same time serve to increase overall application-security. In this section we briefly examine the objects and utilities available to such a developer.

Exceptions, Logging, and Disclosure-Prevention The Common Weakness Enumeration (CWE) classifies error information message leaks as being one of the most dangerous securityrelated programming errors (5), yet many developers remain unaware of the consequences associated therewith. To this end, DotNetNuke offers a number of logging and exception-handling methods designed to properly deal with errors and present minimal information useful to an attacker. Developers will typically utilize the methods in the ExceptionLogController class and Exceptions module when preventing the disclosure of exceptions. The ExceptionLogController exposes a single method, AddLog, with several overloads for specific situations. Developers will typically utilize this method in situations where an exception needs to be logged but the module is otherwise able to handle the issue and proceed. Listing 4 illustrates one such example. Try Using myReader As New StreamReader("myFile.txt") ' Use the stream ... End Using

The low-level classes used to interact with the file system through DotNetNuke are located in the DotNetNuke.Services.FileSystem namespace. At this level, the most commonly used classes will be the two controllers FileController and FolderController along with their respective entities, FileInfo and FolderInfo. However, DotNetNuke also exposes a set of (generally static) utility methods that are sufficient to meet the needs of most developers. Whenever possible, utilize these methods, located in the DotNetNuke.Common.Utilities.FileSystemUtils class.

Whenever possible, utilize the methods located in the DotNetNuke. Common.Utilities.FileSystemUtils class for file system manipulation In addition to files stored on the server’s file system, DotNetNuke offers two additional storage methods: the secure file system and database-secured files. Files persisted to the secured file system are persisted to the server file system as usual, except that the file has a “resources” extension appended to its name. Because files with this extension are not served by IIS, all such files are inaccessible by direct URI request, and may only be accessed via a special DotNetNuke HttpHandler (accessed via LinkClick.aspx) or through the DotNetNuke API. Database-persisted files are, as one would expect, stored directly inside the database, and like their secured file system counterparts, may only be accessed via API. Irrespective of storage strategy, the DotNetNuke API may be used to access all files within the application. To this end, all relevant methods require an instance of the enumeration FolderController.StorageLocationTypes to indicate which storage method is expected (unsecured, secured, or databasesecured). Table 3 summarizes these storage types. Storage Location Type InsecureFileSystem SecureFileSystem

DatabaseSecure

Description Files persisted under this storage type are written to the underlying file system as-is, and may be served directly by IIS (usually bypassing both DotNetNuke and ASP.NET). Files persisted with this type are written to the underlying file system with a “resources” extension, ensuring that it will not be served by IIS (and thereby is not accessible by direct URI). With this storage method, files are persisted directly in the DotNetNuke database. This is the arguably the most secure method of storage, but also the least efficient.

Table 3: Members of the StorageLocationTypes enumeration, used to indicate where a file is stored in a DotNetNuke installation.

Catch ex As FileNotFoundException Dim controller = New ExceptionLogController() controller.AddLog(ex) ' Recover and continue ... End Try

Listing 4: Sample code illustrating the use of ExceptionLog Controller.AddLog, where a module needs to log the issue, but is otherwise able to recover and continue. Some errors may be anticipated at design-time but aren’t otherwise handleable by a developer. In this case, the module should take advantage of the ProcessModuleLoadException method of the Exceptions module; this pattern is illustrated in listing 5. Note that uncaught exceptions, including those that are not anticipatable at design-time, will still be caught by the framework, where an appropriate error message will be displayed (with no risk of information leakage). Try DoSomethingThatMightCauseAnUnexpectedException() Catch ex As MyUnexpectedException ProcessModuleLoadException(myErrorMessage, Me, ex, True) End Try

Listing 5: Sample code illustrating the use of Exceptions.ProcessModuleLoadException method. Security Policy Services DotNetNuke is designed to run in a wide range of environments, including both medium trust and custom security configurations. For developers that need to take advantage of functionality that may not be authorized in a particular environment, the DotNetNuke framework offers several methods to aid in determining this fact. The DotNetNuke.Framework.SecurityPolicy class is used to this end. Table 4 summarizes the relevant methods available to developers. Method Name HasAspNetHostingPermission() HasReflectionPermission() HasWebPermission()

Description Indicates whether the application has been granted the AspNetHostingPermission permission Indicates whether the application has been granted ReflectionPermission Indicates whether the application has the WebPermission permission.

Table 4: Policy-Relatedmethods of the DotNetNuke.Framework. SecurityPolicy class


DOT NET NUKE

Brandon Haynes

Conclusion The DotNetNuke framework is designed with security in mind, and offers framework-level solutions to meet the most common concerns of extension developers. Through the judicious use of the DotNetNuke authorization, privacy, input filtering, policy, and exceptionmanagement services, developers may focus on the implementation of business functionality rather than often-tedious security details. Because of this, DotNetNuke developers are able to design and deploy extensions that are more secure, more quickly, and with less overall development effort. References 1. Cullmann, Stefan. Upcoming Form and List Features: Private Columns and Filters. DotNetNuke. [Online] November 15, 2008. [Cited: September 22, 2009.] http://www.dotnetnuke.com/ Community/Blogs/tabid/825/EntryId/2081/Upcoming-Form-andList-Features-Private-Columns-and-Filters.aspx. 2. Connolly, Cathal. DotNetNuke Module Security: Filtering UserEntered Text. The Mighty Blog. [Online] April 23, 2009. [Cited: September 25, 2009.] http://www.willstrohl.com/Blog/tabid/66/EntryId/377/DotNetNuke-Module-Security-Filtering-User-Entered-Text.aspx. 3. Kelly, S. Security Implications of Using the Data Encryption Standard (DES). 2006. RFC 4772. 4. Eastlake III, D., Schiller, J. and Crocker, S. Randomness Requirements for Security. 2005. RFC 4086. 5. The MITRE Corporation. 2009 CWE/SANS Top 25 Most Dangerous Programming Errors. Common Weakness Enumeration. [Online] 1.3, July 27, 2009. [Cited: September 15, 2009.] http://cwe.mitre.org/top25/. •

Brandon Haynes (brandonhaynes.org) is a member of the DotNetNuke core team, and serves primarily by providing security-related guidance. He is the chief executive officer at Everysport.net Inc., which delivers enterprise resource planning, web-presence, e-commerce, and integration-related functionality to recreational facilities. A graduate of the University of Illinois at Urbana-Champaign consistently ranked among the top-five computer-science programs worldwide - Brandon has a long history of intellectual curiosity and accomplishment. With more than twenty years of experience in software development, Brandon’s professional interests are currently focused on the nexus between intellectual property law, technology, and business. He is currently pursuing a graduate degree at Harvard University.

Windows 7

TIP:

Windows 7: Zoom Met Windows-toets plus (+) en min (-) kun je inzoomen op gedeelten van je scherm, erg handig bij het geven van presentaties.

Advertentie 4DotNet

INFORMATION

WORKER

Paul Keijzers

Create and use of

Google maps web part Dit artikel beschrijft de mogelijkheden van een Google Maps webpart in een SharePoint Portal omgeving en hoe deze o.a. gebruikt worden door het Spaarne Ziekenhuis. Het webpart heeft als doel het inzichtelijk maken van de huisartsen in de regio van het ziekenhuis. Een dergelijke webpart is niet beschikbaar als standaard voor een MOSS omgeving en is natuurlijk een leuke uitdaging om te bouwen. Rest de vraag wat heeft men allemaal nodig om dit webpart aantrekkelijk te maken en meerwaarde te geven? Vragen die hierbij naar boven kwamen waren onder andere: hoe kan men de locaties ophalen, wat voor iconen zijn intuïtief voor gebruiker en hoe wordt de plaats aangeven ...

De vraag van de klant Het Huisartsen-portaal wordt, onafhankelijk van het ziekenhuis, aangeboden in een eigen, beveiligde omgeving (conform NENnormen voor de zorg). Transport van data tussen de praktijken van huisartsen en zorginstellingen vindt plaats via een SSL-verbinding. Het portaal (gebaseerd op het Microsoft Office SharePoint Server 2007 platform) is ontwikkeld en wordt beheerd door de afdeling ICT van het Spaarne Ziekenhuis. Het Spaarne Ziekenhuis sponsort de ontwikkeling van dit portaal conform de wensen van de huisartsen, op basis van de bestaande technologie. Door gebruik te maken van al aanwezige techniek en kennis wordt het portaal kostenneutraal aangeboden aan de huisartsen. Het doel van het Spaarne Ziekenhuis ligt in de verbetering van de ketenzorg, waardoor zij haar interne processen verder kan optimaliseren. Het Google Maps webpart biedt de mogelijkheid om te zien welke huisartsen in een bepaalde regio actief zijn. Daarmee toont het informatie van zorgverleners in de regio, zodat in geval van b.v. vakantie de huisarts de zorg voor een cliënt tijdelijk kan overdragen. Waar te beginnen? Het vertrekpunt om een Google Map webpart te bouwen is inzicht krijgen in de werking, en hiermee API, van Google Maps. Google heeft uitgebreide informatie op de volgende site: http://code.google.com/intl/nl-NL/apis/maps/documentation/

Fig. 1: Google Maps documentatie Er zijn 3 versies van de Google API beschikbaar. Versie 2 is de meest recente productie versie. Versie 3 is een beta-versie en heeft met name voor applicaties voor de mobiele telefoon een aantal leuk features. Dit artikel is gebaseerd op het gebruik van versie 2. De API's van Google Maps zijn goed gedocumenteerd. In deze documentatie staat ook dat er per website een API key aangevraagd moet worden. Deze aanvraag geldt per root van de site. Aanvragen en registreren van de site gaat via de signup: http://code.google.com/intl/nl-NL/apis/maps/signup.html. Hiervoor dien je de beschikking te hebben over een Google account (zie figuur 2).

Fig. 2: Aanmelden bij Google Maps


INFORMATION

WORKER Er zijn vier belangrijke punten waarop gelet moet worden bij het bouwen en deployment van het webpart. Het eerste is dat het verwijderen of wijzigen van het webpart van/op de portal tot gevolg kan hebben dat er opnieuw een key aangevraagd moet worden. Omdat versie 3 nog in beta is, is daarvoor geen key nodig. In deze business case wordt er de portal aangeboden via een SSLverbinding en wordt de kaart opgevraagd in Internet Explorer 8. In deze situatie is een Premium Membership verplicht. Google heeft als doel de maps voor iedereen zichtbaar te maken. Het derde punt is dat Google Maps voornamelijk werkt met JavaScript, wat voor het webpart inhoudt dat er HTML gerenderd moet worden. Tenslotte worden plaatsbepalingen binnen een Google Map opgegeven (of uitgelezen) via de latitude- en longitude-coördinaten. Latitude beschrijft de locatie van een plaats op aarde ten Noorden of ten Zuiden van de evenaar, en longitude beschrijft de locatie van een plaats op aarde ten Oosten of ten Westen van een Noord-Zuid lijn (de nul meridiaan). Tom Tom en andere navigatie apperatuur werken ook met deze gegevens om je naar de juiste plaats te brengen. Vervolgens ben ik voor de zekerheid nog even op Codeplex gaan kijken of er niet al een kant en klare oplossing was die mij veel ontwikkeltijd zou kunnen schelen. Na het testen van verschillende mogelijkheden kwam ik elke keer met hetzelfde resultaat. Het resultaat was dat er een grijs vlak werd getoond met Google erin maar nergens een Map (dit komt waarschijnlijk omdat er wijzigingen zijn gedaan die niet getest zijn bij Google)? Omdat de adressen van de huisartsen bekend zijn, kunnen deze coördinaten opgehaald en opgeslagen worden. De coördinaten worden bij het gebruikersprofiel van de huisarts opgeslagen (huisartsen zijn de gebruikers van het portaal).

IW

TIP:

Een goede website om snel de coördinaten te vinden op basis van een adres is http://mygeoposition.com/

Het webpart zelf Het maken van het webpart kan eenvoudig via Visual Studio 2008. Hierbij is het aan te raden om met WSP-Builder te werken. Wanneer je WSP-Builder geïnstalleerd hebt, krijg je de mogelijkheid om projecten aan te maken van het type WSP. Zo’n project bestaat uit de volgende elementen: • een feature, bestaande uit het manifest (feature.xml) en een elements-file (elements.xml); • de webpart definitie (HiszMaps.webpart); • de webpart class (de logica). Het vertrekpunt is het maken van een feature waarmee de webpart geïnstalleerd kan worden. Het voordeel van een feature is o.a. de herbruikbaarheid. Het manifest beschrijft de applicatie (in dit geval het webpart) en geeft aan welke elementen (files) er nodig zijn om het webpart goed te installeren. Het manifest van de feature ziet als volgt uit.

MAGAZINE. IN DIT NUMMER O.A.:

Recommend Documents

Markup

Markup