MS certificering: 70-483, deel 11

Ingediend door Dirk Hornstra op 14-mei-2018 21:16

In mijn eerste post van 6 maart had ik al beschreven dat ik het boek uitgelezen had en in een nieuwe post de links / extra informatie in een aparte post zou bespreken. Vervolgens ben ik eerst de video's gaan bekijken, de laatste post daarover dateert alweer van 9 april, we zijn alweer een maand verder. Zo zie je maar hoe snel de tijd gaat, in de tussentijd ben ik bezig geweest met het exporteren van foto's van Facebook, connectie maken met mySQL via het Entity Framework en met de koppeling met mijn Fitbit (gelukt!), de koppeling met de api van mijn Polar-horloge (nog niet gelukt, ik krijg geen data terug). Dat laatste punt vreet tijd en je schiet er nog niets mee op, daarom het besluit om dat dan eerst te laten liggen en met de certificering door te gaan.

Voordat het boek begint wordt verwezen naar een pagina waar Errata en Boek-ondersteuning geboden wordt, link. Op zich wel goed om die nog even door te lezen als je net als mij het boek hebt, er zijn wat aanpassingen in de code en er zijn een aantal antwoorden bij vragen in het boek goed gerekend terwijl ze dat niet zijn. 

Het eerste hoofdstuk gaat over Threading. Er is een link opgenomen naar een MSDN-pagina waar je meer informatie kunt vinden over de thread pool en hoe je deze kunt configureren, link.

In het boek wordt bij het deel over "jump-statements" verwezen naar de MSDN-pagina met meer informatie: link. Één tip, gebruik nooit en te nimmer het goto-statement :)

In het deel over delegates wordt gesproken over covariance en contravariance. Als je een methode toewijst aan een delegate hoeft de signatuur van de methode niet exact overeen te komen. Covariance is de mogelijkheid om de methode een dieper afgeleide klasse mee te geven. Contravariance is juist de mogelijkheid om parameter mee te geven die minder overgeërfd zijn dan die van het delegate type. Een redelijk abstract verhaal, daarom verwijst Wouter naar de blog-posts van Eric Lippert die hier dieper in gedoken is: link.

In hoofdstuk 2 worden types besproken. Zo ook pointers en "unsafe code". Een hele tijd geleden ben ik bezig geweest met een "voetpedaal" wat gebruikt werd voor het afspelen van teksten die met een dictafoon opgenomen waren. De secretaresse(s) typten de tekst in, maar moesten de "player" zo nu en dan kunnen pauzeren. Volgens mij zaten daar Win32-libraries bij en zou daar nog wel gebruikt gemaakt kunnen worden van pointers. Dus mocht je het voor dergelijke specifieke voorvallen nodig hebben, er wordt verwezen naar deze pagina: link.

Er worden twee voorbeelden gegeven van een functie, het berekenen van de te rijden afstand. In de eerste methode wordt de volledige "klant" meegegeven, in de tweede methode alleen het adres van de klant. Wijzigingen in de class van de klant "ebt" dan niet door naar deze functie die daar eigenlijk niets mee nodig heeft. Dit wordt de "law of demeter" genoemd, daar was ie weer: een soort design-pattern. Er wordt verwezen naar deze pagina, http://msdn.microsoft.com/en-us/magazine/cc947917.aspx#id0070040, maar die staat niet (meer) online. Maar... we worden wel netjes doorverwezen naar https://msdn.microsoft.com/magazine/msdn-magazine-issues MSDN magazines die je onder andere als PDF kunt downloaden. 

Er volgt een paragraaf over constructors. Daarbij wordt verwezen naar deze MSDN-pagina waarin de "best practise" voor het opbouwen van je constructors wordt besproken: link. Ook komt het "big-ball-of-mud" principe voorbij, waarbij wordt verwezen naar de codinghorror.com-website waarop dingen staan die je zelf niet moet willen bouwen of onderhouden: link. Bij het plaatsen van mijn blog over design patterns noemde mijn collega Menno ook het SOLID-principe, dat wordt ook in hoofdstuk 2 benoemd. Deze afkorting staat voor:

Single responsibility principle (laat je code één ding afhandelen).

Open/closed principle (een object mag uitbreidbaar zijn, maar de basis-werking mag van buitenaf niet aan te passen zijn).

Liskov substitution principle (het basis-type zou in elke situatie vervangbaar moeten zijn met een afgeleid type. Mooi voorbeeld is dat een eend altijd kan zwemmen, maar een afgeleide speelgoed-eend alleen kan zwemmen als de batterijen opgeladen zijn (je moet ineens gaan checken of het type speelgoed-eend is om mogelijk lege batterijen te gaan vervangen).

Interface segregation principle, gebruik cliënt-specifieke interfaces in plaats van het gebruik van een algemene interface waarin je tig functies definieert die in 9 van de 10 gevallen niet gebruikt worden).

Dependency inversion principle, bouw op basis van abstracties. De basis van een class moet liggen in een abstract class of interface zodat je minder afhankelijk bent van de daadwerkelijke implementatie in de class.

De goeroe van deze principes is natuurlijk "Uncle Bob". Op deze pagina is het SOLID-principe beschreven en staan nog meer toelichtingen, link.

Soms moet je een externe component toevoegen. Ik heb dat zelf gehad bij een applicatie voor de fitness, daarbij wilde ik zaken exporteren naar Word. Je kunt in Visual Studio een reference toevoegen en kiezen voor een COM-component, VS maakt hier dan zelf een wrapper voor. Mocht dat niet lukken, of wil je zelf de koppeling naar een externe bron bouwen, dan moet je gebruik maken van de IUnkown. Op deze pagina is meer info te vinden: link. In hoeverre dit relevant is, dat moet je zelf maar even bekijken. Als ik naar de link ga wordt ik namelijk doorverwezen naar "retired VS 2003 documentatie". Dat klinkt redelijk oud :)

Ook wordt reflection besproken. Als je DLL's die dynamisch in een map toegevoegd worden wilt gebruiken, een soort plug-in systeem, dan kun je een kijkje nemen naar het Managed Extensibility Framework, link

Moest je vroeger bij delegates een losse functie maken, met anonymous methods kun je een blok code meegeven en is dat niet meer nodig, uitleg staat hier: link.

Bij de code over expression trees wordt verwezen naar http://msdn.microsoft.com/en-us/library/bb397951.aspx. Deze pagina toont alleen een linkje naar de VB-code en naar de C#-code. Omdat ik zelf met C# werk, hier even de rechtstreekse link.

Een class die erft van IDisposable. We houden er van, want met een using... heb je een object wat zichzelf weer netjes opruimt. Hoe je zelf IDisposable en de finalizer implementeert kun je hier nalezen: link.

Strings. Je plakt de boel aan elkaar vast, je vervangt waardes. En uiteindelijk zit je het systeem flink te belasten. Dus schakel je over naar de StringBuilder die net even wat slimmer met de resources om gaat. Maar misschien moet het nog anders. Op deze pagina kun je de "best practices" van het werken met strings nalezen: link.

Hoofdstuk 3. Hier wordt verwezen naar nuget, als het goed is gebruik je dit allang in Visual Studio. Mocht dat niet zo zijn, neem dan maar eens even een kijkje: link.

Het Entity Framework. We gebruiken het, het werkt prima. Maar Microsoft heeft er flink wat pagina's aan gewijd. In het boek wordt er naar verwezen, misschien toch nog maar eens wat beter doorlezen. Want bij een quick scan lees ik zaken als "optimistic concurrency patterns", "performance considerations" en "no-tracking query's", link.

Je komt het wel eens tegen, je krijgt een stuk tekst binnen, maar het is eigenlijk een datum, soms ook met een tijd. Bijvoorbeeld een feed uit Twitter, waarbij je dan ook nog de "T" in de string zit. Volgens mij heb ik in het verleden daar zelf wel zaken in zitten splitsen en met DateSerial zitten werken om zaken goed te krijgen (want je wilt niet dat de Amerikaanse notatie gebruikt wordt, waarbij maand en dag net andersom staan dan de Nederlandse notatie). In dit hoofdstuk wordt verwezen naar een pagina over "DateTime parsing", dus het zal vast makkelijker/slimmer kunnen, link.

Encryptie, ook altijd een boeiend onderwerp. Op deze pagina worden de verschillende methodes en hun voorkeursgebied beschreven: link.

Voor het implementeren/gebruik van de GetHashCode wordt naar de volgende MSDN-pagina verwezen: link.

Als je zelf certificaten wilt aanmaken (om https-zaken te testen) kun je dat doen met makecert. In het boek wordt verwezen naar http://msdn.microsoft.com/en-us/library/bfsktky3(v=vs.110).aspx, die pagina is niet meer beschikbaar. Er wordt verwezen naar de volgende link.

Met Code Access Security kun je instellen wat je programma wel en niet mag. Meer uitleg is te vinden op deze pagina: link.

De debugger in Visual Studio. De tool om door je code heen te bladeren en je variabelen te inspecteren. Maar er zijn natuurlijk nog meer mogelijkheden. Welke dat zijn, die zijn beschreven op deze pagina: link.

Als je een applicatie build, dan worden er ook .PDB bestanden gemaakt. Daarmee kun je de live code debuggen. Daar wordt dan weer een Symbol Server voor gebruikt. Ik gebruik dit zelf niet (we gebruiken een ander logsysteem, waarbij we de locatie in de code beschikbaar hebben en de code in GIT controleren), maar mocht je zelf een eigen Symbol Server op willen zetten dan is hier meer informatie te vinden: link.

Het PDB bestand bevat zowel public als private data. Mocht je die private data eruit willen filteren, dan kun je daarvoor de PDBCopy-tool gebruiken, het gebruik daarvan is hier beschreven: link.

Als je performance-problemen hebt kun je de Profiler van Visual Studio gebruiken. Uitleg daarover kun je hier nalezen: link.

Hoofdstuk 4 gaat over input en output van data. Ook hier komt weer een design-pattern voorbij, er wordt verwezen naar het decorator pattern: link.

Ook wordt het werken met databases beschreven. Zo ook "disconnected" data, waarbij je onder andere via ADO.NET je de data in een DataSet of DataTable ingeladen hebt. Nu we steeds meer met het Entity Model werken, is dit misschien minder relevant. De link die genoemd wordt verwijst hiernaar, maar ook daar is informatie over onder andere het Entity Data Model te vinden, link.

Je maakt connectie met een Acces-database, SQL Server database, mySQL of misschien nog wel een ander type database. Die hebben allemaal hun eigen syntax qua connectiestring. In het boek wordt verwezen naar deze pagina waar je de syntax kunt vinden: link.

Met de web.config-transformation-syntax kun je een connectiestring instellen voor de DEV-omgeving en waarbij deze als je build en deployed naar productie de connectiestring voor de PROD-omgeving gebruikt wordt. De syntaxt daarvan kun je hier nalezen: link.

T-SQL. We gebruiken het allemaal om query's op te bouwen. Uitleg over de datatypes en structuren kun je hier vinden: link.

Als je iets moois bouwt zijn er altijd mensen die proberen er misbruik van te maken. Hier een kort artikel over SQL-injection: link.

Execution-plans, het bepalen van de optimale route in SQL. Soms levert dat problemen op, hier is meer informatie te vinden: link.

Als je aan de slag gaat met webservices en WCF, dan is dit een goed punt om te starten: link.

Voor communicatie beginnen we steeds meer gebruik te maken van JSON. Maar de standaard daarvoor (en wat nog wel gebruikt wordt) is XML. Informatie over XML en de mogelijkheden kun je hier nalezen: link.

LINQ is fantastisch. Je kunt er prima mee query-en, dynamisch door collecties bladeren en filteren. Maar waarschijnlijk gebruik ik maar een fractie van de mogelijkheden. In het boek wordt verwezen naar deze pagina waar 101 LINQ Samples te vinden zijn: link (met een k!). Ook wordt een coole tool benoemd, LinqPad. Hiermee kun je jouw SQL query omzetten naar LINQ of gewoon leren hoe LINQ werkt: link.

Ik noemde bij LINQ al de collecties. Daar heeft .NET er nogal wat van. De Dictionary, de List, de Queue. Elk met zijn eigen (handige) eigenschappen. Uitleg hierover kun je hier nalezen: link.

Daarmee zijn alle links die in het boek van Wouter de Kort genoemd worden behandeld. Doe er je voordeel mee!