Vorige week had ik het er over dat de standaard dbml-bestanden die je kunt maken in Visual Studio 2008 niet goed genoeg zijn, aangezien je die lastig in een n-tier situatie kunt gebruiken.

Hier moet ik weer op terug komen.

Ik ben nu iets meer ervaren in het hele L2SQL gebeuren en zie nu dat ik niet gelijk had. Je kunt een dbml-bestand prima gebruiken in een n-tier situatie.

Je kunt dus gewoon via de user-interface je spullen blijven bewerken, zonder gebruik te maken van SQLMetal.

Dit is uiteraard goed nieuws, afgezien van het feit dat ik nu al een week zit te prutsen met SQLMetal.

Ok, hierdoor heb ik wel wat ervaring opgedaan hoe L2SQL werkt en dergelijke.

Het is dus niet volledig verloren tijd en ik ben blij dat ik er nu met m’n thuis-project achter kom in plaats van op het werk.

Nou ja, nu ga ik dan maar weer m’n dbml-bestand aanmaken en de rest weggooien.

Eigenlijk kan alles gelijk blijven aan wat ik nu heb. Waarschijnlijk moet er her en der wat aan worden gepast, maar dat zal niet enorm erg zijn.

Dus wanneer je gebruik gaat maken van L2SQL, maak dan gewoon een dbml-bestand aan en ga niet eigenwijs je eigen spullen aanmaken.

Nu de techniek van de back-end wel werkt voor m’n nieuwe weblog ben ik eerst even naar de front-end gegaan, zodat ik ook zie wat ik aan het maken ben.

Uiteraard moet er gebruik worden gemaakt van masterpages en van themes, want dat is cool.
Nu ben ik even met die themes aan het stoeien en het lijkt wel interessant te zijn.

Er zijn, voor mij, nieuwe skin-bestanden waar je de stijl van alle ASP.Net controls kunt definierern.
Eigenlijk is het net als CSS, maar het zal wel enorm veel voordelen hebben.
Hoe de themes gebruikt kunnen/moeten worden valt hier in het kort te lezen: https://msdn2.microsoft.com/en-us/library/ykzx33wh.aspx

Wat ik wel enorm irritant vond is dat er standaard geen IntelliSense in de skin-bestanden zit.
Toevallig kwam ik achter deze, https://weblogs.asp.net/bclaridge/archive/2005/12/06/432507.aspx, pagina en nu kan er wel gebruik worden gemaakt van IntelliSense.

Echt voordelen ten opzichte van CSS kan ik (nog) niet echt ontdekken, maar ze zijn er vast wel.

Vandaag had ik een raar probleem in m’n web-applicatie.

Ik had een zoekvenster gemaakt en hier stond maar 1 tekstbox en 1 zoekknop op. Wanneer ik in de tekstbox een zoekstring plaatste en dan op de knop ‘Zoek’ drukte werden m’n resultaten gevonden.

Wanneer ik echter op de [Enter]-knop op het toetsenbord drukte werd de pagina wel herladen, maar werd het knop-event niet geactiveerd.

Op zich kon ik dit wel verklaren doordat er geen default knop in het form was gedefinieerd. Het rare was echter dat wanneer ik 2 of meer textboxen in het zoekvenster had, dat het zoeken met de [Enter]-knop wel lukte. Nadat ik hier voldoende tijd aan had besteed vond ik het wel welletjes geweest, aangezien ik het probleem niet kon vinden.

Tijdens m’n zoektocht kwam ik wel de volgende pagina tegen: https://www.beansoftware.com/ASP.NET-Tutorials/Accept-Enter-Key.aspx

Het blijkt dat je vanaf ASP.Net 2.0 je een DefaultButton kunt opgeven aan een Panel. Je geeft het ID van de zoek-knop op en dan werkt het.

Zo heb ik nu dus ook m’n zoekvenster gemaakt, door alle textboxen in een panel te plaatsen met een defaultbutton die refereert naar m’n zoekknop.

Nadat ik nu enkele malen heb gewerkt met VS.Net 2008 ben ik er uit dat het pakket ReSharper nu echt een must is om te installeren.

Voorheen moest ik er niet zoveel van hebben, aangezien ik de voordelen er niet zo van in zag.

Nu ik de IntelliSense niet goed werkend kon krijgen in VS.Net 2008 heb ik besloten om toch maar ReSharper weer eens te installeren.

Programmeren is nu weer een stuk eenvoudiger geworden. Ik wil namelijk dat wanneer je een (-teken intikt, dat je dan ziet welke parameters je aan de functie moet meegeven. Ook wanneer je een .-teken intikt, wil ik zien welke functies, attributen of events kunnen worden gebruikt.

Met ReSharper is dit allemaal weer mogelijk gemaakt. Het kan waarschijnlijk ook wel zonder, maar na het aan- en uitvinken van allerei opties in VS.Net 2008 was ik daar wel klaar mee.

Dus, wanneer je VS.Net 2008 koopt, zorg dan wel dat je nog een paar euro’s in je budget overhoud voor de aanschaf van ReSharper.

Gelukkig hebben ze bij de lokale politiekorpsen ook door dat november, december en januari dure maanden zijn. Daarom controleren ze extra veel op snelheid, zodat mensen het extra voelen. En ook natuurlijk een beetje om hun boete-marges te halen.

Vandaag kreeg ik weer eens een boete via de mail binnen. 1 december heb ik te snel door Koufurderigge gereden op de Jeltewei. Dat is een provinciale weg waar je normaliter 80km/h mag rijden. De weg zelf lokt echter uit om 120km/h te rijden. Dit keer reed ik nog op een redelijk sociale snelheid, namelijk 98km/h (na aftrek van allerlei correcties).

Boetebedrag is 76 euro. Een forse. Ook wordt ik nog extra genaaid door de lease-maatschappij. Er moet namelijk 5,95 euro administratiekosten worden betaald. M’n collega kreeg vandaag ook een boete binnen en die hoefde dat niet. Zal waarschijnlijk alleen moeten als je meerdere malen per jaar een bekeuring krijgt.

Nou ja, weer een dag voor niets gewerkt.

Voor zover ik na kan gaan komt er zeker weten nog 1 snelheidsboete van december, dus ik maak m’n borst maar nat. Dat wordt namelijk ook een dikke.

Voordeel voor de verkeersveiligheid is wel dat ik nu de komende dagen weer gewoon 123km/h rij op de snelweg en 82km/h op de provinciale wegen.

Zo, ik heb het voor elkaar.

Met de methode hoe ik nu LINQ to SQL heb toegepast in m’n solution kan ik toch de aloude n-tier architectuur blijven behouden.

Om dit te bewerkstelligen moet je jammergenoeg wel afstappen van de eenvoudige grafische user interface die Visual Studio 2008 aanbied. Je moet nu namelijk van de console applicatie SQLMetal.exe gebruik maken.

Ook wel te doen natuurlijk, maar het is een beetje jammer dat dit niet standaard in VS.Net 2008 kan.

Eerst heb ik vandaag enkele posts van Scott Guthrie doorgelezen.

De belangrijksten waren deze wel.

Using LINQ to SQL (Part 1)
https://weblogs.asp.net/scottgu/archive/2007/05/19/using-linq-to-sql-part-1.aspx

LINQ to SQL (Part 2 - Defining our Data Model Classes)
https://weblogs.asp.net/scottgu/archive/2007/05/29/linq-to-sql-part-2-defining-our-data-model-classes.aspx

LINQ to SQL (Part 3 - Querying our Database)
https://weblogs.asp.net/scottgu/archive/2007/06/29/linq-to-sql-part-3-querying-our-database.aspx

LINQ to SQL (Part 4 - Updating our Database)
https://weblogs.asp.net/scottgu/archive/2007/07/11/linq-to-sql-part-4-updating-our-database.aspx

In een van deze posts stond een linkje naar een video post van Mike Taulty. Op zijn weblog heb ik het volgende filmpje bekeken:

https://mtaulty.com/videos/nuggets/l2s/04_mt_l2s_codegentools.wmv

Dit is een enorm informatief stukje over LINQ to SQL.
Wanneer je dit filmpje hebt gezien kun je met een beetje fantasie wel begrijpen hoe je nu een n-tier architectuur kunt toepassen.

Ten eerste maak je de mapping XML en mapping CS bestanden aan.
Zelf heb ik dit gedaan door de volgende command-line te gebruiken in de Visual Studio 2008 Command Prompt in te tikken:

Vandaag ben ik naar Amersfoort gereden, omdat daar een zaakje zit waar ze me waarschijnlijk nieuwe speakers en versterkers wilden verkopen.

Uiteraard bleek dat ook het geval te zijn, maar tijdens het lopen van de parkeergarage naar die zaak zag ik ook de naam Nedgame boven een winkeltje staan.

Dat is leuk, een goede game-zaak op m’n route. Deze kans kon ik natuurlijk niet onbenut raken, aangezien ik niet dagelijks in Amersfoort kom.

Nadat ik enkele speakers had beluisterd ben ik naar Nedgame gegaan.

Het viel me op dat het een behoorlijk klein winkeltje was met veel bezoekers.

Het mooie aan deze winkel is dat ze ook nog oude games verkopen.

Rekken vol met Playstation en Playstation 2 spellen, special editions van PC games, Gameboy Advance spellen, maar ook nog Dreamcast en de klassieke consoles.

Aangezien m’n legale Dreamcast collectie behoorlijk karig is heb ik maar weer even wat ingeslagen.

Nu heb ik weer 5 extra games voor dit platform er bij. Ook zag ik Final Fantasy Origins liggen. Nog wel prijzig, maar ach, het is als verzamelaar toch een schande dat ik deze titel nog niet in m’n bezit had.

Dus weer een nutteloze aanschaf gedaan. Eigenlijk kon het niet meer deze maand, maar ja….

Ja, het is wat.

Dit maal was ik zelf een keer de stomme gebruiker. Al ongeveer 2 jaar dacht ik dat m’n rear-speakers van m’n Philips LX8500W setje kapot waren. Dit omdat er geen geluid meer uit kwam tijdens het luisteren naar radio, kijken van films of tv.

Dit begon nadat de garantie was afgelopen van de set, dus daar baalde ik wel van.

Nu had ik de set vorige week op Marktplaats gezeg. Vandaag was er een reactie op, maar niet echt een gunstige voor mij dan.

Door deze reactie ben ik gaan kijken of m’n hoop voor de verkoopprijs wel reeel was. Hierdoor kwam ik ook op de Philips website.

Hier even de handleiding gedownload, aangezien daar waarschijnlijk wel specificaties in staan.

Hier stond ook een volgend blokje:

Hey, dat is precies wat ik heb.

Nou, proberen kan geen kwaad. Even naar beneden gelopen en op de [SURR]-knop gedrukt. Ja hoor, het werkt!

Nu heb ik weer geluid uit de achterste 2 speakers. Nog wel een beetje ruis, maar dat kan wel worden verholpen door de spullen wat anders te plaatsen of een ander kanaal te kiezen.

Wow, gewoon 2 jaar voor niets gebaald, gewoonweg omdat ik te eigenwijs was om een handleiding door te lezen.

Tijdens het werken aan een van onze nieuwste producten op het werk, kwam ik achter een leuke feature.

Wanneer je in een ASP.Net 2.0 website een bestand met de naam app_offline.htm plaatst, dan wordt al het verkeer naar die ene pagina geleid.
Dit is uitermate handig wanneer je bijvoorbeeld je website update of iets dergelijks. Ook zorgt het framework er volgens mij voor dat alle openstaande variabelen (garbage) wordt opgeruimd, alle SQL-connecties worden gesloten, etc.

Enorm handige feature dus.

Het zal ook weer eens niet zo zijn, maar Scott Guthrie had dit al eens gevonden en er een post over gemaakt. https://weblogs.asp.net/scottgu/archive/2005/10/06/426755.aspx
Nou ja, dan zit ik in ieder geval al op ongeveer hetzelfde niveau als hij 6 oktober in 2005 was…..

Hoewel LINQ to SQL me gisteren wel het ei van Columbus leek ben ik daar vandaag niet meer zo zeker van.

Vanavond heb ik een beetje gezocht hoe je LINQ to SQL in een n-tier architectuur kunt gebruiken. Wanneer je dit in Google opzoekt zie je veel probleem verhalen en weinig successen.
Op de MSDN-site staat wel globaal beschreven hoe je het zou kunnen paar een echt real-life voorbeeld is niet echt aanwezig. Tenminste niet zoals ik het graag wil zien.

Via deze link https://msdn2.microsoft.com/en-us/library/bb882661.aspx krijg je wel weer genoeg leesvoer.

Vooral de hoofdstukken Implementing Business Logic (LINQ to SQL) ( https://msdn2.microsoft.com/en-us/library/bb882671.aspx ) en Data Retrieval and CUD Operations in N-Tier Applications (LINQ to SQL) ( https://msdn2.microsoft.com/en-us/library/bb546187.aspx ) vond ik enigzins interessant.

Het lijkt alsof je de objecten die je vanuit je dbml bestand (LINQ) krijgt worden ge-detached wanneer je ze in een andere laag gebruikt. Zodra je de wijzigingen wilt opslaan moet het gehele originele object weer terug worden gekoppeld, samen met een kopie van het originele object met daarin de wijzigingen. Of je maakt de wijzigingen in de LINQ-laag, maar dan kan het zijn dat je zo’n 40 parameters aan een functie moet toevoegen. Dat is natuurlijk ook niet echt overzichtelijk.