Gebruik geen Dynamic Data Web Application projecten?

Na enkele maanden in beta te zijn geweest, is er nu eindelijk Visual Studio
2008 Service pack 1. Op zich waren veel features al bekend maar de beta had ik
laten schieten en dus ben ik best onder de indruk van wat er allemaal in zit.
Wil je het allemaal nog eens nalezen dan mag je best wel de tijd nemen. Na drie pogingen en enkele uren installeren (tijd genoeg dus voor het leeswerk) stond het weer netjes op de harde schijf en het voelt dan toch een beetje alsof je een kadootje uitpakt.

Nu zit er genoeg in SP1 voor vele avonden uitzoekwerk maar ik wil hier het
Dynamic Data Web Application project bespreken. Het is een hele mond vol terwijl de project de eenvoud zelfe is / kan zijn.

Wat doet het dan? De DDWA genereert aan de hand van een opgegeven Entity Data Model context of een LINQ to SQL context voor alle opgegeven tabellen navigatie, gefilterde overzichten en CRUD onderhoudschermen. En dit alles is nog configurabel ook. Voordat u nu direct alle webontwikkeling wilt stilleggen, wil ik er toch even op wijzen dat dit niet de ‘silver bullet’ is. Zoals met veel
zaken moet ook dit met mate toegepast worden.

Na het starten van een DDWA project (voor LINQ to SQL) of de DDEWA
project (voor het Entity framework) zijn er maar twee handelingen nodig! Eerst
moet de database in een model gevangen worden. Genereer dus binnen het project voor een (SQL Server) database een ADO.NET Entity Data Model (Model.edmx) of een verzameling LINQ to SQL klassen (DataClasses.dbml). Voor beide handelingen is een wizard aanwezig dus daar kom je wel uit.

Dan start de magie: ga naar de Global.asax en haal het commentaar weg voor de
regel beginnende met model.RegisterContext.

model.RegisterContext(typeof(EntitiesContext),
  new ContextConfiguration() { ScaffoldAllTables = true }); // Let op: True

OF

model.RegisterContext(typeof(DataClassesDataContext),
  new ContextConfiguration() { ScaffoldAllTables = true }); // Let op: True

Een scaffold is een steiger. Door de ScaffoldAllTables waarde op true te
zetten worden automatisch alle in de context aangetroffen tabellen ‘in de
steigers’ gezet. Start de applicatie en zie wat er allemaal gegenereerd
wordt.

En ja, het ziet er aardig uit maar hoe pas je het in je project toe? Mijn
eerste gedacht is dat nu op een heel Agile manier het onderhoud van b.v.
stamtabellen toegevoegd kan worden aan het project. Dit betekent wel dat er een
tweede webapplicatie opgeleverd wordt maar er zijn mogelijkheden om een dynamic data website met maatwerk te combineren. Ook is het zo mogelijk om ‘power’ tester een simpel kijkje in de database keuken te geven. Hierbij wordt het dan ook mogelijk om b.v. bepaalde velden te wijzigen. Wellicht ideaal om toch te kunnen anti-dateren?

Wil je meer of minder tabellen zien, pas dan gewoon je context aan. Maar hoe
kunnen tabellen uit het onderhoudscherm weglaten worden welke in een bestaand model aanwezig zijn? Dit kan via het scaffolding (steigeren?) gedaan worden. De tabellen worden ieder door een entity vertegenwoordigd. Maak een partial class aan voor de tabel welke verborgen moet worden. Zet hierna op de klas het attribuut [ScaffoldTable(false)]. Er is overigens een aardige wisselwerking met ScaffoldAllTables om in te stellen welke tabellen wel en niet zichtbaar
zijn.

Als een kolom onzichtbaar gemaakt moet worden, is er net iets meer werk
nodig. Er is wel een attribute [ScaffoldColumn(false)] maar het is niet mogelijk
om op de partial class de eigenschap te herhalen om het attribuut daarop te
herhalen.

Hiervoor maken we eerst een extra klas aan met eenzelfde eigenschap als de te
verbergen kolom.

[ScaffoldTableAttribute(true)]  // steiger
public class EntiteitMetadata
{
  [ScaffoldColumn(false)]
  public Object Waarde { get; set; }
}

Deze klas is een meta beschrijving en wordt op de partial klas geplaatst via
het MetaDataType attribuut.

[MetadataType(typeof(EntiteitMetadata))]
public partial class Entiteit
{
  // plaats hier b.v. een property beschrijving met extra attributen
}

Binnen het project is in de map \DynamicData\FieldTemplates een verzameling
usercontrols opgenomen. Dit zijn de controls (default field templates) welke
gebruikt worden voor het representeren en onderhouden van de waarden in de
kolommen. Deze zijn te wijzigen maar die wijzigingen gelden dan voor alle
pagina’s in de gegenereerde website.

Er wordt bij Dynamic Data Web applicaties veel met conventies gewerkt. Voor
de field templates geldt dat templates, aanwezig met _Edit in de naam, specifiek
bij wijzigen van kolommen worden toegepast. De templates zonder _Edit zijn voor alleen-lezen gebruik.

Wat betreft conventies is het ook nog mogelijk om specifiek voor bepaalde
tabellen aparte schermen te definieren. Meer hierover wordt hier uitgelegd. Maar je kunt je hierbij al snel verliezen in het ‘goldplaten’ binnen het redelijk strikte keurslijf van de Dynamic Data Web application conventies.

Conclusie, wat een gouden greep lijkt om snel een user interface op te
leveren richting de klant kan al snel tegen je keren als je meer wilt dan alleen
maar wat data ophoesten. Zo is het lastig om data b.v. alleen maar readonly aan
te bieden. Maar al met al is het handig om functionaliteit voor het onderhoud
van stamtabellen hiermee op te leveren totdat deze typische adminstrator
schermen binnen het project een echte invulling hebben gekregen.

Advertenties

WPF en CamSpace, een leuke combinatie

Zo, de vakantie van 2008 is weer voorbij. In het Tatra gebergte is geen enkele
mogelijkheid voor een online verbinding en dat had best nog even mogen zo duren maar op een gegeven moment gaat het toch weer kriebelen.

De vakantieperiode is een uitgelezen moment om eens wat anders te onderzoeken dan wat je de rest van het bij de klant tegenkomt. De waan van de dag, zeg maar.
Zo kwam ik enige tijd geleden een demo tegen van een startup welke d.m.v.
beeldherkenning de gebruiker applicatie kon laten besturen. Dit zou met een
doodnormale webcam kunnen en daardoor kon ieder glimmend voorwerk een soort van Wii controller worden.

http://www.youtube.com/watch?v=v0srY37kkMw

Tijdens mijn vakantie kreeg ik de uitnodiging voor het beta traject dus de
afgelopen week ben ik er eens ingedoken.

Het is echt knap gemaakt, het werkt!

Met mijn Trust webcam van 14,95 en met vier fps (‘savonds bij kunstlicht)
blijkt het opeens mogelijk om een virtuele xylofoon te besturen met twee
markers. Wat ze doen is via een agent de webcam input omzetten naar een virtuele muis, joystick of toetsenbord. Het ondersteunt zelfs multi point input en er zijn veel variabelen in te stellen. Deze instellingen kunnen dan aan een
executable gehangen worden waardoor tijdens het opstarten van die executable, de input doorgegeven wordt.

Het was even zoeken maar er zat ook een SDK bij. Hiermee kunnen ontwikkelaars de huidige telemetrie uitlezen en de CamSpace host applicatie enigzins manipuleren. Helaas is er geen handleiding en ook de wiki is vooral leeg, maar het is redelijk zelfbeschrijvend. Helaas werkt het ontvangen van de input niet via callbackfunctionaliteit, ik moet hiervoor met een Timer werken. Aan de andere kant, we krijgen maar maximaal zo’n dertig keer per seconde gegevens door (ik dus maar vier keer onder slechte omstandigheiden) dus die timer werkt prima.

En zoals gezegd, het werkt als een fluitje en de waarden komen meestal door
als relatieve waarden voor hwet gemak. Zo geeft CamSpace door dat b.v. de X
waarde van een coordinaat op een derde van de breedte van het scherm staat.

Ik heb er eerst een met een WinForm applicatie tegenaan geprogrammeerd, maar helaas, daar zijn buttons niet te draaien. Dit gaf mij dus eindelijk een reden
om eens echt met WPF aan de gang te gaan. Ik had het in het verleden al wel eens vluchtig bekeken maar dit is dan toch weer in het diepe stappen.

Ik maakte eerst de fout om de verkeerde Timer te kiezen (system.Timers.Timer)
want die draait los van de UI thread. Dus zelfs het uitlezen van this.Width
werkte niet. Pas na de keuze voor de System.Windows.Threading.DispatcherTimer
begon het lopen en bleek ook de binding toch nog mee te vallen.

Zie hier het huidige resultaat van een paar avondjes knutselen:

Een beetje subtiel, maar CamSpace geeft ook de breedte door (dichtbij/veraf)
en die kan mooi in een smallere of bredere knop vertaald worden.

Wat nog fraaier was, bleek bij het uitzoeken van de rotatie. Dit was even
zoeken, maar die werden in radialen doorgegeven. En het mooie is dat CamSpace echt onthoudt hoeveel keer het ‘input device’ geroteerd is. Na vijf slagen linksom, kan je ook weer aftellen naar vijf slagen rechtsom. De simulatie van een schroevendraaier is daarbij dus een stuk dichterbij gekomen 😉

En hiermee komen we dus direct bij de conclusie: leuk stukje speelgoed, maar
wat kan je er mee. Datzelfde was ook de reactie op de eerste berichten over de
Wii controller…