In de data access laag van m’n projecten werd het nu toch wel een drukke boel met verschillende LINQ to SQL queries. Aangezien je namelijk niet goed dynamische LINQ-queries kunt maken, moet je eigenlijk voor iedere ‘uitzondering’ een aparte query maken. Je krijgt dan zoiets als dit:
if (criteria.PeriodeVan != null && criteria.PeriodeTot != null)
{
var query = (from post in dataContext.GetTable()
where post.Item.CreatieDD >= criteria.PeriodeVan &&
post.Item.CreatieDD <= criteria.PeriodeTot
orderby post.Item.CreatieDD descending
select post)
.ToArray();
if (criteria.TopList > 0)
{
return query.Take(criteria.TopList);
}
else
{
return query;
}
}
else
{
var query = from post in dataContext.GetTable()
orderby post.Item.CreatieDD descending
select post;
if (criteria.TopList > 0)
{
return query.Take(criteria.TopList);
}
else
{
return query;
}
}
Dit is een hele lap code voor eigenlijk maar 2 acties, namelijk een periode kiezen en een selectie van de bovenste items. Voor mijn relatief kleine projecten is dat wel te doen, maar bij grotere projecten zeker niet. Zelfs dit vind ik al lastig qua onderhoud. Nu ben ik vandaag op zoek gegaan naar een goed alternatief.
Als vrij snel kwam ik op een Chris Rock z’n weblog waar hij dit probleem ook beschrijft in de post die hier is te vinden: https://www.rocksthoughts.com/blog/archive/2008/01/24/linq-to-sql-dynamic-queries.aspx Eerst komt hij met het voorstel om de Dynamic LINQ Query Library te gebruiken. Deze had ik zelf ook al een keer gezien, maar dat is eigenlijk iets wat je totaal niet wilt gaan gebruiken. Je krijgt dan gewoon tekst queries in je code welke niet meer door je compiler worden gecontroleerd. Dit haalt Chris ook al aan. Daarna begint hij over de LINQ Predicate Builder.
Read more →Vandaag ben ik veel interessante artikelen tegen gekomen op het internet. Een daarvan is een LINQ to SQL performance test. Blijkbaar had Derik Whittaker wat tijd over en heeft een performance test gedaan met verschillende manieren van de data-access op te bouwen. Het volledige artikel is op z’n weblog te lezen: https://devlicio.us/blogs/derik_whittaker/archive/2008/03/14/playing-with-linq2sql-and-various-performance-tests.aspx
Z’n conclusie is dat wanneer je een generieke DataContext gebruikt in je code, je enorm veel performance verlies hebt. Het hoe en waarom is hij nog niet achter, maar de uitvoer is ongeveer 7x langzamer dan wanneer je een ‘goede’ DataContext gebruikt.
In dit bovenste voorbeeld wordt een generieke DataContext gebruikt, de tweede een specifieke welke alleen voor de betreffende tabel kan worden gebruikt.
DataContext db = new DataContext(new SqlConnection(connectionString));
IEnumerable sports = from s in db.GetTable()
select s;
SportsDemoDataContext db = new SportsDemoDataContext(new SqlConnection(connectionString));
IEnumerable sports = from s in db.Sports
select s;
Na 10.000 keer de query uit te voeren blijkt dat het 2e voorbeeld met een gemiddelde van 13022 miliseconden wordt uitgevoerd en het 1e voorbeeld met een gemiddelde van 78042 miliseconden wordt uitgevoerd.
Een behoorlijk verschil dus. Zelf maak ik ook gebruik van zo’n generieke DataContext uit het eerste voorbeeld. Dit omdat je dat mooi in je Base.cs kunt opnemen. In de eerstvolgende performance-tuning update zal ik dit aanpassen zodat iedere klasse z’n eigen, juiste, DataContext krijgt.
Het is toch mooi dat sommige mensen hier de tijd voor nemen om te testen. Zelf zou ik dat namelijk nooit doen, maar ik doe er wel weer m’n voordeel mee.
Read more →Vandaag kwam ik een website met een vette applicatie tegen, namelijk LINQpad. Zoals de naam misschien wel doet vermoeden, kun je met deze ‘pad’ zelf LINQ queries maken en uitvoeren. Deze applicatie ondersteunt LINQ to SQL, LINQ to XML en LINQ to Objects. Door het uitvoeren van verschillende queries (op je eigen data) kijken of het resultaat dat je krijgt gewenst is. Zo kun je dus mooi oefenen om de LINQ-syntax te beheersen. De website is te bereiken op http://www.linqpad.net/
Read more →Afgelopen week kwam ik in m’n RSS-feeds een mooi artikel tegen met daarin enkele richtlijnen hoe en wanneer je LINQ kunt gebruiken. Om eerlijk te zijn heb ik het alleen maar even snel door gescanned, omdat ik nogal druk ben de laatste tijd, maar het lijkt me een interessant stukje om te lezen. De link van het artikel is https://blogs.msdn.com/mirceat/archive/2008/03/13/linq-framework-design-guidelines.aspx. Zodra ik zelf tijd heb zal ik het ook doorlezen, maar dat zit er vandaag waarschijnlijk niet meer in.
Read more →Onlangs heb ik iets ‘uitgevonden’ bij het maken van LINQ-queries. Deze queries worden namelijk uitgevoerd zodra je een item zoekt in de verzameling van objecten, dus eigenlijk pas in een foreach-loop.
Ik had een ‘kleine’ fout gemaakt tijdens het ontwikkelen van dit weblog, waardoor het voor kon komen dat de database meer dan 7000x in een kwartier kon worden aangeroepen als er 2 gebruikers 20 pagina’s bekeken. Dat is natuurlijk niet echt bevorderlijk voor de performance, waardoor je soms wel tussen de 10 en 30 seconden moest wachten voordat er een pagina zichtbaar was.
Nadat ik dit design issue er uit had gewerkt, waardoor de database een stuk minder wordt aangeroepen en de performance dus ook is verhoogd, ben ik op zoek gegaan hoe ik LINQ-queries direct kan uitvoeren. Dit blijkt niet zo enorm lastig te zijn. Je kunt de query gelijk in een array zetten, waardoor alle objecten gelijk worden opgehaald, dus de database wordt aangeroepen. Nadat de objecten in de array staan zal de database niet nogmaals te hoeven worden aangeroepen.
Bij deze een voorbeeld query van zo’n cast.
var query = (from collectie in dataContext.GetTable() orderby collectie.Item.CreatieDD ascending select collectie).ToArray();
Een voordeel hiervan is dat alle database acties in de DAL blijven. Nog wel belangrijk om te weten is dat er nog steeds een IEnumerable wordt teruggegeven. Je hoeft dus verder niets in je code te wijzigen.
Read more →Vandaag was ik bezig met het maken van m’n basis weblog functies.
Nu was ik belandt bij het aanmaken van posts, toch wel een essentieel onderdeel. Als identifier maak ik gebruik GUID’s en in SQL heb ik dan de newsequentialid() gebruikt.
Uiteraard is dit enorm handig, maar niet direct in combinatie met L2SQL.
Wanneer je zelf geen actie onderneemt dan wordt er gewoon een lege guid toegevoegd.
Gelukkig vond ik al redelijk snel een oplossing hiervoor op Nick Kusters z’n weblog (https://www.nickkusters.com/ViewArticle.aspx?ArticleID=29)
Je moet dus zelf in de designer aangeven dat de waarde in de database wordt berekend.
Dit kun je zelf ook aangeven in je mapping.xml, maar dan zou je dit iedere keer moeten doen wanneer je deze update.
Aangezien ik daar niet zoveel zin in heb, moest ik maar weer eens testen of een dbml-bestand toch geen optie is.
Gezien m’n vorige post hier, is dat dus ook weer gelukt.
Zo zie je maar weer dat je toch een beetje vertrouwen moet hebben in Microsoft development en niet eigenwijs bezig gaan.
Read more →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.
Read more →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:
Read more →Aangezien ik bezig ben m’n weblog opnieuw te ontwikkelen, maar dan in .Net, heb ik maar gelijk gekozen voor het nieuwste framework, namelijk 3.5.
Momenteel ondersteund de provider dit nog niet, maar aaangezien ze ook behoorlijk snel waren met .Net 3.0 te installeren zal 3.5 binnenkort ook wel werken.
Als eerste wil ik de DataAccess-laag maken. Eerst was ik van plan dit precies doen zoals op het werk, maar dan met geautomatiseerde tools.
Nu bedacht ik me dat je in .Net 3.5 uiteraard ook gebruik kunt maken van LINQ. Dit is nieuw, dus ook vet om te gebruiken.
Of het echt goed is zullen we in de loop der jaren wel achter komen, maar ik wil het toch wel eens even gebruiken voordat er een subjectief oordeel over kan worden geveld. Iedereen vind de features natuurlijk wel enorm leuk, maar is het ook werkbaar?
Om dit uit te vinden heb ik zojuist heel wat teksten gelezen op bekende en onbekende weblogs en MSDN-subsites.
De website https://www.hookedonlinq.com/ heeft een duidelijk verhaal. Hier werd me in een keer duidelijk wat de verschillende LINQ versies doen. Hiermee bedoel ik dus LINQ to SQL, LINQ to XML en LINQ to Objects.
Momenteel wil ik alleen LINQ to SQL gebruiken, dus daar heb ik de meeste leestijd aan besteedt.
Read more →