Microsoft .NET - deel 1

quote:

Op zaterdag 31 juli 2010 11:02 schreef OEM het volgende:

[..]

De (network)credentials die je toekent aan die XmlResolver object wordt gebruikt om aan te kloppen bij de server aan de andere kant voordat er ook maar iets inhoudelijks gebeurt met je bericht. Bij private en public albums praat je met een service die alles doorlaten bij het aankloppen. Het meegeven van networkcredentials is dus nutteloos. Daarna wordt er gekeken in het bericht wat je wil doen:

Public album? Geen probleem.
Private album? dan moet er ook een authentication token in je bericht zitten.

Dus wat betreft de XmlResolver classes:

public album: everything goes, dus de XmlResolver-classes werken gewoon
private album: je zal eerst een sessie moeten starten via ClientLogin, en daarna de token die je krijgt elke keer meegeven. Dat is allemaal niet standaard, dus werken de XmlResolver classes niet meer. Dus je zal toch echt zelf twee webrequests moeten implementeren (zoald eerder iemand al gemeld heeft). Die kun je daarna evt ook gebruiken in het public geval.

Ah, dat maakt het wel duidelijker, en logischer idd.
Ik zal dat binnenkort eens proberen.
Dank je wel

Zo, even een soort van Best Practice vraag.

Het verhaal:
Ik haal bij picasa een lijst op van m'n fotoalbums.
Vervolgens sla ik die op in een tabel in m'n database, met daarbij een flag of ie wel of niet getoond mag worden op m'n website.

Nou wil ik, dat als ik later opnieuw ga syncen, uit m'n database een lijst van alle albums (zodat ik wijzigingen kan checken, en kan kijken of ze wel of niet gepubliceerd staan).

Wat is nou het beste object om deze lijst in op te slaan?
Ik zit zelf te denken aan een GenericList.
Hierin kan ik een verzameling "album-objecten" in opslaan, en deze is tevens m.b.v. FindIndex te doorzoeken. (als ik m'n lijst uit de picasa-xml uitlees, kan ik dan snel op ID achterhalen in m'n eigen lijst of een album bijvoorbeeld gepubliceerd is).

Of is hier een beter object voor?

quote:

Op maandag 2 augustus 2010 10:14 schreef Cryothic het volgende:
Zo, even een soort van Best Practice vraag.

Het verhaal:
Ik haal bij picasa een lijst op van m'n fotoalbums.
Vervolgens sla ik die op in een tabel in m'n database, met daarbij een flag of ie wel of niet getoond mag worden op m'n website.

Nou wil ik, dat als ik later opnieuw ga syncen, uit m'n database een lijst van alle albums (zodat ik wijzigingen kan checken, en kan kijken of ze wel of niet gepubliceerd staan).

Wat is nou het beste objec
Dictionaryt om deze lijst in op te slaan?
Ik zit zelf te denken aan een GenericList.
Hierin kan ik een verzameling "album-objecten" in opslaan, en deze is tevens m.b.v. FindIndex te doorzoeken. (als ik m'n lijst uit de picasa-xml uitlees, kan ik dan snel op ID achterhalen in m'n eigen lijst of een album bijvoorbeeld gepubliceerd is).

Of is hier een beter object voor?

Klinkt alsof System.Collection.Generic.Dictionary nodig hebt.

Best practice is om je code eerst zo "mooi" mogelijk te maken (=onderhoudbaar), en daarna pas gaan optimaliseren voor performance.

Maar voor een dictionary moet ik het dan opslaan als:

Generic.Dictionary[ album_id, album_object]

terwijl het ID ook al in het object zelf zit.
Al is dit met uitlezen misschien wel weer sneller dan de find-optie van een list.

quote:

Op maandag 2 augustus 2010 11:53 schreef Cryothic het volgende:
Maar voor een dictionary moet ik het dan opslaan als:

Generic.Dictionary[ album_id, album_object]

terwijl het ID ook al in het object zelf zit.

Dat klopt, en dat is niet erg: je albums worden geindexeerd op album_id (door middel van een hashtable), zodat het opzoeken van een album bij een bepaald id niet tot gevolg heeft dat de hele lijst van albums doorlopen hoeft te worden - de dictionary weet meteen waar hij heen moet springen.

Als je LINQ gebruikt: IEnumerable<T> heeft zelfs een speciale extension method om een collectie te indexeren op 1 bepaalde property van een object, waardoor je het volgende zou kunnen schrijven:

quote:

Al is dit met uitlezen misschien wel weer sneller dan de find-optie van een list.

In theorie wel in ieder geval. In de praktijk ligt het kantelpunt geloof ik op 10 elementen (bij meer dan 10 elementen is een dictionary sneller, bij minder zou een gelinkte lijst sneller moeten zijn).

Maar ik zou altijd voor de dictionary gaan, bij minder dan 10 elementen zijn beide oplossingen "ongeveer even snel", terwijl bij meer de dictionary veel sneller is.

Tja, bij het synchronizeren kom ik langs alle albums, dat zijn er (in m'n eerste account) 88.
Dus dan gaat een dictionary dat wel winnen ja.

Of ik Linq ga gebruiken weet ik nog niet.
Daar ben ik niet in thuis. 1x gebruikt voor een Twitter-feed op m'n site.
Op m'n werk wordt het iig ontmoedigd, maar het is me niet helemaal duidelijk waarom. Zal wel persoonlijke smaak zijn.

Dank je wel in ieder geval

quote:

Op dinsdag 3 augustus 2010 09:04 schreef Cryothic het volgende:
Tja, bij het synchronizeren kom ik langs alle albums, dat zijn er (in m'n eerste account) 88.
Dus dan gaat een dictionary dat wel winnen ja.

Of ik Linq ga gebruiken weet ik nog niet.
Daar ben ik niet in thuis. 1x gebruikt voor een Twitter-feed op m'n site.
Op m'n werk wordt het iig ontmoedigd, maar het is me niet helemaal duidelijk waarom. Zal wel persoonlijke smaak zijn.

Dank je wel in ieder geval

LINQ vind ik handig voor op een klein website`je, effe snel wat data op te halen uit een database en hier met behulp van IntelliSense gemakkelijk iets mee doen. Voor de wat grotere projecten maak ik toch sowieso zelf mijn eigen object classes en data layer. Overigens ben ik een voorstander van data die al zo gebruiksklaar mogelijk uit een database komt, in plaats van eerst een rommelige, ongesorteerde resultset op te halen en hier pas in de applicatie van alles mee doen.

Gewoon een non-sql database

Las daar van de week iets over op webwereld. CouchDB enzo, maar das apache.
Kwam wel RavenDB tegen, dat klinkt ook wel interessant.

Ik ben momenteel even aan een klein freelance project aan het 'bijspringen'. Het grove 'frame' van de applicatie stond er al en er moet nu van alles ingebouwd worden. Ik ondersteun een team van 3 developers. Nu werken deze developers allemaal met het Entity framework, en is mij gevraagd om daar ook zo veel mogelijk rekening mee te houden. Geen probleem hoor, ik pas me wel aan.

Maar tering, wat een rotzooi. Kan met niet voorstellen dat mensen dat hele Entity en LINQ-to-SQL / LINQ-to-object gebeuren fijn vinden werken. Okee, je maakt ongelooflijk snel d.m.v. een ADO.NET Entity model een soort van DAL en je hebt meteen interactie met je database. Maar ik ben er echt geen voorstander van om in uiteindelijke WebForms pas de 'queries' samen te stellen. Doet me een beetje denken aan mijn PHP 3.0 tijdperk. Sowieso die 'queries'.

Liever heb ik Database -> DAL -> meerdere BLL's -> Presentatie.

Wat houdt je tegen een repository te schrijven? Dat is gewoon je DAL (in dit opzicht, niet letterlijk). Voordeel van een repository is dat je ook nog een speciale implementatie van je repository (repository is meestal een interface) kan maken die niet van een database gebruik maakt maar gewoon hardcoded data teruggeeft. Voor het testen dus.

Dus dan heb je het volgende:

Database -> ORM/DAL LINQtoSQL/EF -> Repository-> BLL -> Presentatie
Database -> SQL -> DAL -> Repository -> BLL -> Presentatie

quote:

Op dinsdag 31 augustus 2010 11:00 schreef NikkelCobalt het volgende:
Wat houdt je tegen een repository te schrijven?

Wat hem tegenhoudt zijn waarschijnlijk die andere developers die fijn vanuit de presentatielaag in de datalaag zitten te frutten.

quote:

Op dinsdag 31 augustus 2010 11:04 schreef Catbert het volgende:

[..]

Wat hem tegenhoudt zijn waarschijnlijk die andere developers die fijn vanuit de presentatielaag in de datalaag zitten te frutten.

Dat inderdaad. Veel 'gelaagdheid' komt er niet bij kijken in dit geval.

En NikkelCobalt, dat is inderdaad ook een idee. Dan ben ik echter nog meer werk aan het verrichten dan wat ik normaal altijd doe en derhalve ontgaat mij het nut een beetje van deze methoden met LinQ / Entity. Ook het 'na proberen te bootsen' van échte SQL queries vind ik erg omslachtig, vooral in geval van LIKE en OR operators. Om nog maar te zwijgen over de optimalisatie van de uiteindelijke SQL queries.

Nope, met die Strong Typed versie inclusief Lambda Expressions ben ik ook bezig. Maar ik vind het nog steeds vrij omslachtig. Om een heel goed voorbeeld te noemen: Ik heb een heel groot overzicht (een GridView) met een heleboel velden daarin, en op vrijwel al die velden kan 'gefilterd' worden. Die filters en de daarmee corresponderende velden bestaan uit allerlei DropdownLists, Textboxes, Checkboxes, enzovoorts. Nu heb ik om die GridView te vullen altijd het volgende stukje code (effe namen aangepast voor duidelijkheid):

Oftewel een paar dingen kan ik in deze 'where clausules' al verwerken, met name de filters/selecties die altijd van toepassing zijn. Maar om bijvoorbeeld al die variabele filterwaarden er in te verwerken, krijg ik allemaal stukjes code als volgt:

Terwijl ik met mijn normale methode (dus SQL -> DAL -> BLL -> Presentatie) in mijn BL-classes allerlei static methods klaar zet waarmee allerlei selecties en filters verricht kunnen worden, denk dan aan methoden als:

Maar goed, voor kleine projectjes zal dit inderdaad handig zijn om snel interactie met je database te hebben vanuit je applicatie. Maar voor grotere projecten zou ik nooit voor een dergelijke aanpak kiezen.

Complexe where-clauses kunnen toch ook gewoon in linq?

quote:

Op woensdag 1 september 2010 12:44 schreef OEM het volgende:
Complexe where-clauses kunnen toch ook gewoon in linq?
[ code verwijderd ]

Mja, noem het een kwestie van smaak, maar ik vind het een heel gedoe allemaal voor simpele handelingen. Ik prefereer liever mijn eigen, kinderlijk eenvoudige methode waar er met een Stored Procedure gecommuniceerd wordt, waar dan weer een SQL query in staat waar ik gewoon LIKE operators e.d. kan gebruiken. Om nog maar te zwijgen over het feit dat mijn codebehinds en BLLS nu bulken van 'Queries' en Lambda Expressions'. Mij is geleerd om databasezaken in de database te houden.

Ook zullen er straks veel dingen in dit project gedaan moeten worden waar normaliter echt 'Dynamic SQL' voor gebruikt wordt, en zal er met Cross Database Queries gewerkt moeten worden. Daar zie ik erg tegenop met LINQ / Entity Framework.

[ Bericht 7% gewijzigd door Tuvai.net op 01-09-2010 13:52:59 ]

Volgens mij geef je zelf al deels het antwoord op je problemen: meer gebruik maken van de database: Aan views en functies gedacht? Die herkent LINQtoSQL namelijk gewoon.

En verder denk ik dat je gewoonweg te weinig met LINQ hebt gedaan om er iets zinnigs over te zeggen. Situaties die je oplost met directe queries kun je net zo goed oplossen met LINQ(tosql).

Absoluut zijn er situaties waarin LINQ minder goed van toepassing is, maar de situaties die jij beschrijft noem ik niet direct problematisch. Het kostte mij overigens ook wel tijd om LINQ en LINQtoSQL onder de knie te krijgen

Om nog even een concreet te noemen: ik heb nu in een project (op LINQtoSQL) ook iemand meegemaakt die nog nooit van LINQ heeft gehoord. ASP.NET classic project was het, en die ging lekker allemaal stored procedures maken ipv een LinqDataSource gebruiken. Daar word ik dan weer wat minder vrolijk van

Wat ik overigens erg leuk vind aan LINQtoSQL is de databasereflectie die je standaard kunt doorlopen. (Hoewel de gebruikssituatie wel weer vrij specifiek is)

quote:

Op woensdag 1 september 2010 15:11 schreef NikkelCobalt het volgende:
Volgens mij geef je zelf al deels het antwoord op je problemen: meer gebruik maken van de database: Aan views en functies gedacht? Die herkent LINQtoSQL namelijk gewoon.

En verder denk ik dat je gewoonweg te weinig met LINQ hebt gedaan om er iets zinnigs over te zeggen. Situaties die je oplost met directe queries kun je net zo goed oplossen met LINQ(tosql).

Absoluut zijn er situaties waarin LINQ minder goed van toepassing is, maar de situaties die jij beschrijft noem ik niet direct problematisch. Het kostte mij overigens ook wel tijd om LINQ en LINQtoSQL onder de knie te krijgen

Om nog even een concreet te noemen: ik heb nu in een project (op LINQtoSQL) ook iemand meegemaakt die nog nooit van LINQ heeft gehoord. ASP.NET classic project was het, en die ging lekker allemaal stored procedures maken ipv een LinqDataSource gebruiken. Daar word ik dan weer wat minder vrolijk van

Wat ik overigens erg leuk vind aan LINQtoSQL is de databasereflectie die je standaard kunt doorlopen. (Hoewel de gebruikssituatie wel weer vrij specifiek is)

Ik denk dat ie exact de essentie door heeft. Als je linq2sql gaat gebruiken in de presentatielaag wordt het een grote ellende die we nog kennen van sql queries in pagina's of de datasets variant ervan (1 op 1 kopieen van tabellen).

Linq is best handig, maar linq2sql hoort in je dal thuis, niet in je gui

.

quote:

Op dinsdag 31 augustus 2010 21:14 schreef Tuvai.net het volgende:
Nope, met die Strong Typed versie inclusief Lambda Expressions ben ik ook bezig. Maar ik vind het nog steeds vrij omslachtig. Om een heel goed voorbeeld te noemen: Ik heb een heel groot overzicht (een GridView) met een heleboel velden daarin, en op vrijwel al die velden kan 'gefilterd' worden. Die filters en de daarmee corresponderende velden bestaan uit allerlei DropdownLists, Textboxes, Checkboxes, enzovoorts. Nu heb ik om die GridView te vullen altijd het volgende stukje code (effe namen aangepast voor duidelijkheid):
[ code verwijderd ]

Oftewel een paar dingen kan ik in deze 'where clausules' al verwerken, met name de filters/selecties die altijd van toepassing zijn. Maar om bijvoorbeeld al die variabele filterwaarden er in te verwerken, krijg ik allemaal stukjes code als volgt:
[ code verwijderd ]

Zo?

Persoonlijk kies ik voor views wanneer LINQ queries te lang worden trouwens . Ook horen ze inderdaad thuis in de DAL (of een repository). Wel oppassen voor deferred execution.

quote:

Op woensdag 1 september 2010 15:11 schreef NikkelCobalt het volgende:
Volgens mij geef je zelf al deels het antwoord op je problemen: meer gebruik maken van de database: Aan views en functies gedacht? Die herkent LINQtoSQL namelijk gewoon.

En verder denk ik dat je gewoonweg te weinig met LINQ hebt gedaan om er iets zinnigs over te zeggen. Situaties die je oplost met directe queries kun je net zo goed oplossen met LINQ(tosql).

Absoluut zijn er situaties waarin LINQ minder goed van toepassing is, maar de situaties die jij beschrijft noem ik niet direct problematisch. Het kostte mij overigens ook wel tijd om LINQ en LINQtoSQL onder de knie te krijgen

Om nog even een concreet te noemen: ik heb nu in een project (op LINQtoSQL) ook iemand meegemaakt die nog nooit van LINQ heeft gehoord. ASP.NET classic project was het, en die ging lekker allemaal stored procedures maken ipv een LinqDataSource gebruiken. Daar word ik dan weer wat minder vrolijk van

Wat ik overigens erg leuk vind aan LINQtoSQL is de databasereflectie die je standaard kunt doorlopen. (Hoewel de gebruikssituatie wel weer vrij specifiek is)

Ik ben ben inderdaad geen meester als het op LINQ aankomt nee, maar ik heb er genoeg van gezien en mee geklooid om er een oordeel over te scheppen. Het hele LINQ gebeuren is voor mij gewoon een ander werkwijze voor iets dat ik al jarenlang op een, in mijn mening veel mooiere en snellere, eigen manier doe. Ik ben het de afgelopen 2 dagen actief aan het gebruiken en heb eens voor te proberen op een kopie van een eigen project alles functioneel omgezet van mijn eigen methode naar LINQ. De Codebehinds van mijn WebForms zijn nu afzichtelijk en groot, en het ophalen van gegevens duurt gewoon langer (weliswaar nog maar milliseconden op duizenden records, maar toch). De hele manier van werken met LINQ e.d. spreekt mij gewoon niet aan. Als ik met LINQ werk krijg ik een beetje het gevoel dat de database een ruwe blok met platte gegevens is, waarvan ik de eindjes pas op applicatieniveau aan elkaar begin te knopen.

Ik vind het mooi hoe je met ADO.NET Entities d.m.v. een paar keer 'Volgende' klikken een heel model met daarin meerdere 'Business Objects' kunt genereren in een paar seconden tijd. Voor een klein website`je met een gastenboek waar ik alleen een tabel met reacties uit hoef te lezen, lijkt LINQ mij ideaal. Maar voor grote applicaties waar vaak met relationele data wordt gewerkt en je soms wel tot 6 niveau's diep moet 'joinen' in je queries, vind ik het onpraktisch. De hele manier van het aanspreken / benaderen / ophalen / koppelen van de Entities vind ik gewoon lomp.

quote:

Op woensdag 1 september 2010 20:48 schreef Tuvai.net het volgende:

[..]

Ik ben ben inderdaad geen meester als het op LINQ aankomt nee, maar ik heb er genoeg van gezien en mee geklooid om er een oordeel over te scheppen. Het hele LINQ gebeuren is voor mij gewoon een ander werkwijze voor iets dat ik al jarenlang op een, in mijn mening veel mooiere en snellere, eigen manier doe. Ik ben het de afgelopen 2 dagen actief aan het gebruiken en heb eens voor te proberen op een kopie van een eigen project alles functioneel omgezet van mijn eigen methode naar LINQ. De Codebehinds van mijn WebForms zijn nu afzichtelijk en groot, en het ophalen van gegevens duurt gewoon langer (weliswaar nog maar milliseconden op duizenden records, maar toch). De hele manier van werken met LINQ e.d. spreekt mij gewoon niet aan. Als ik met LINQ werk krijg ik een beetje het gevoel dat de database een ruwe blok met platte gegevens is, waarvan ik de eindjes pas op applicatieniveau aan elkaar begin te knopen.

Ik vind het mooi hoe je met ADO.NET Entities d.m.v. een paar keer 'Volgende' klikken een heel model met daarin meerdere 'Business Objects' kunt genereren in een paar seconden tijd. Voor een klein website`je met een gastenboek waar ik alleen een tabel met reacties uit hoef te lezen, lijkt LINQ mij ideaal. Maar voor grote applicaties waar vaak met relationele data wordt gewerkt en je soms wel tot 6 niveau's diep moet 'joinen' in je queries, vind ik het onpraktisch. De hele manier van het aanspreken / benaderen / ophalen / koppelen van de Entities vind ik gewoon lomp.

LINQ to entities is even wennen, maar ik vind het juist een mooie manier om tegen je database aan te programmeren. Er wordt een conceptueel model van je database gegenereerd, dat houdt bijvoorbeeld in dat meer op meer relaties geabstraheerd worden. Ook subtypes/overerving in je database wordt netjes afgehandeld. Verder kun je ook gebruik maken van code templates, waarbij je heel makkelijk code kunt genereren op basis van de metadata van je database

quote:

Op woensdag 1 september 2010 20:48 schreef Tuvai.net het volgende:
Maar voor grote applicaties waar vaak met relationele data wordt gewerkt en je soms wel tot 6 niveau's diep moet 'joinen' in je queries, vind ik het onpraktisch.

Ja en m.i. zit daar je denkfout. LINQ betekend niet dat je al het werk van de database door je .NET applicatie moet laten oplossen.

Je kunt die 6 niveau diepe join query gewoon in een stored procedure/view/functie stoppen. Als jij ontzettend veel variabele parameters hebt wordt het een ander verhaal maar dan moet je sowieso veel code schrijven, ook zonder LINQ.

Ik vind overigens de uitbreidbaarheid en flexibiliteit van Entity Framework een beetje tegenvallen tov LINQ. De queries daarentegen zijn wel mooier, dit vind ik het grootste nadeel van LINQ. Maar dat is goed op te vangen met diezelfde views/sp's /functions.

quote:

Op vrijdag 3 september 2010 19:11 schreef NikkelCobalt het volgende:
Ja en m.i. zit daar je denkfout. LINQ betekend niet dat je al het werk van de database door je .NET applicatie moet laten oplossen.

LINQ in lokt dat wel een beetje uit vind ik, en veel mensen doen dat ook. Noem me ouderwets, maar ik vind dat mijn database moet dienen als de plek waar alle gegoochel met data plaats moet vinden, en die mij een kant en klare, bruikbare output / resultset retourneert waar ik in mijn applicatie direct mee aan de slag kan. Op databaseniveau gaat dat gewoon sneller en gemakkelijker. Wat ik vaak zie in applicaties die bulken met LINQ, is dat er hele grove resultsets van database naar applicatie geslingerd worden, die vervolgens op applicatieniveau pas gesorteerd, gegroupeerd, gelimiteerd (bijv. ingedeeld in pagina's met een beperkt aantal items) en/of geabstraheerd worden.

Ik bedoel maar, je kunt er zeker mooie applicaties mee maken waar je ook nog goed rekening houdt met snelheid, performance en logica. Maar LINQ spoort mijns inziens wel aan om het toch lekker op de quick 'n dirty manier te doen, omdat het oh zo gemakkelijk is om 'queries' direct tegen je database aan te gooien.

quote:

Op vrijdag 3 september 2010 19:11 schreef NikkelCobalt het volgende:
Je kunt die 6 niveau diepe join query gewoon in een stored procedure/view/functie stoppen.

Dan kan ik net zo goed met mijn eigen DAL class verder gaan die dat al doet.

quote:

Als jij ontzettend veel variabele parameters hebt wordt het een ander verhaal maar dan moet je sowieso veel code schrijven, ook zonder LINQ.

'Dynamic SQL' in Stored Procedures is helemaal niet veel werk. In grove lijnen is het gewoon jouw 'normale' SQL query maar dan in een NVARCHAR variabele gestopt, waar nodig eventuele 'statische' stukken afgevangen met andere variabelen. Ik gebruik dit vooral veel in enterprise systemen waar je één database hebt met applicatiegegevens (gebruikers, rechten, enz.) en per klant / omgeving een database hebt met daadwerkelijke data. In LINQ / met Lambda Expressions is dit aanzienlijk meer werk dan even een query 'dynamisch maken', om nog maar te zwijgen over complexiteit. Maar goed, dat laatste is weer een kwestie van smaak.

Ik ben hier niet om je wel/niet te overtuigen van LINQ hoor Maar ik zou het jammer vinden (nouja, je hebt mij er niet mee natuurlijk ) als je bepaalde dingen links laat liggen op basis van een eerste indruk.

In grote applicaties gebruik ik zelf liever geen LINQ omdat ik meer controle wil hebben over het aantal queries dat wordt uitgevoerd. Want LINQ gebruiken en de profiler op je database loslaten is als een continue stroom aan overlijdensberichten.

Op internet zijn weinig goede voorbeelden over LINQ te vinden, ben ik met je eens. Maar dat heb je sowieso met .NET en meer geavanceerde zooi. Om nog maar niet te spreken van die Indiërs die complete goochelcode artikelen schrijven. Brrr

quote:

Noem me ouderwets, maar ik vind dat mijn database moet dienen als de plek waar alle gegoochel met data plaats moet vinden, en die mij een kant en klare, bruikbare output / resultset retourneert waar ik in mijn applicatie direct mee aan de slag kan.

Dit pleit overigens toch juist voor LINQ(toSQL)?