En we beginnen met de voorbereiding voor het examen. De eerste video, dat was de "prep-talk". Die kun je dus overslaan, alleen maar "what a good question" e.d., daarin wordt niets nuttigs verteld.
Hierna door met de tweede video, programmeren in C# Jump Start. Twee mensen die denken dat ze grappig zijn, dus ook hier kun je weer wat skippen. Eerst naar 3:20, hierna krijg je te zien welke onderwerpen behandeld gaan worden. Daarna wordt er weer gepraat, je kunt doorskippen naar 5:35. Volgens de mannen gaan ze in vliegende vaart door een stuk code / voorbeelden / behandeling wat anders 5 dagen in beslag neemt. Het is wat verouderd, want de code die genoemd wordt voor korting verloopt op 29 maart 2013.
Rond 8:00 wordt verwezen naar locaties om codevoorbeelden te downloaden, http://xaml.codeplex.com. Klik onderaan op de pagina op "Download C Sharp Demos". Inmiddels heet het daar "get the code", is ook materiaal van volgende jaren beschikbaar en wordt verwezen naar deze pagina waar ook de filmpjes staan. Wacht eens, rechtsboven staat de knop "download archive". Hiermee download je in 1x 204 MB (zip-bestand) aan materiaal.
De cursus begint om 9:05. OOP, Object Oriënted Programming. Wat is een object? Het is iets (een order, een product), het heeft data (voornaam, productcode) en voert acties uit (je kunt een order op betaald zetten, je kunt een product een prijs geven). OOP is een taal die op basis van het concept van objecten gebaseerd is. Wat kan deze "taal" dan? Deze bevat ondersteuning voor encapsulation, inheritance en polymorphism. Encapsulation is het afschermen van je objecten . Inheritance, het erven van gedrag van andere objecten. Polymorphism, "veel vormen". Een aardbei en een perzik erven van "fruit" en kunnen op die manier gebruikt worden.
Een Managed Language. Deze is beschikbaar gesteld via een "runtime omgeving". In .NET is dat de Common Language Runtime (CLR). Automatisch geheugenbeheer, excepties afvangen, standaard types en beveiliging.
Waarom standaard types? Je hebt meta-data, het beschrijft wat voor geheugen het in beslag neemt, welke eigenschappen het heeft. De compiler kan zo bepalen wat een type wel kan en wat niet. Intellisense, compile-time controle. Alles erft van Object. Deze defineert ToString(), dus elk type heeft die eigenschap beschikbaar. Je hebt 3 categorieën, value type: rechtstreeks opslaan, reference type of object, bevatten een referentie naar data en pointer types, alleen beschikbaar in "onveilige code". Als je wilt, kun je die code in je project ook gebruiken (wat natuurlijk niet het advies is). Er wordt genoemd dat je bijvoorbeeld wat met een bitmap wilt gaan doen.
Waarom C# gebruiken? Het is voor algemeen gebruik gemaakt, is object georienteerd en heeft de focus op productiviteit voor ontwikkelaars. De ontwikkelaar was ook de ontwikkelaar van Pascal en Delphi (hey, dat hebben we bij Hogere Informatica gehad!). Er zijn steeds nieuwe features toegevoegd. We krijgen een historisch overzicht van de eigenschappen. In 2005 de generics, partial classes, anonymous, nullable. In 2007 var, linq. lambda, initializers, auto props, extensions, partial methods, In 2010 dynamics, optional args, covariance, in 2012 C# 5 met async en caller attr. Als ik dit zo zie, loop ik zelf nog een beetje op .NET 3.5, 2007. Dat moeten we verbeteren.
Encapsulation, het afschermen van je objecten. C# ondersteunt dit via Unified Type System (via het CLR systeem), Classes en Interfaces, met Properties, Methods en Events.
Overerving. Een class mag van 1 basis-class overerven. Een class kan nul of meer interfaces implementeren. Er zijn programmeertalen waarbij je wel van meerdere classes kunt overerven. Juist vanwege het polymorphisme moet de compiler consistent kunnen bepalen wat de basis-klasse is, dat is de reden waarom dit zo gedaan is. Via interfaces kun je wel aangeven dat een klasse bepaalde eigenschappen moet implementeren.
Polymorphism. Een class kan als zijn eigen type gebruikt worden, of omgezet worden naar een basistype of interface. Een methode kun je virtual maken op het basisniveau. Cast je een afgeleide class terug naar het basistype, dan wordt de implementatie van de afgeleide class weer gebruikt. Dus de persoon geeft bij toString "person" terug, en de developer geeft bij toString "the myth, the legend" terug, cast je die developer naar een person, dan geeft toString nog steeds "the myth, the legend" terug.
C# probeert alles makkelijker te maken voor developers. Voorbeelden zijn:
var: gauw je resultaat opvragen zonder je druk te hoeven maken om het type
LINQ: query's uitvoeren in de "taal"
Lambas: anonieme methodes in LINQ gebruiken
C# is gebaseerd op C en C++. Identifiers zijn namen van classes, methodes, variabelen. Keywords zijn gereserveerde woorden voor de compiler (public, class, string, get).
Code decoration is het gebruik van attributen. Metadata koppelen aan types en members. Via reflectie tijdens runtime beschikbaar maken. Commentaar kun je geven via block comments, single comments en XML documentatie (tijdens compileren in losse XML bestanden plaatsen), ook om formele documentatie te genereren. (Sandcastle - linkje?).
Wat is een "anonymous type"? Dat is wat hierboven een "var" genoemd wordt. Niet de hele class opbouwen, maar snel een var object vullen en gebruiken. Veelvuldig bij LINQ gebruikt. Compiler inferred types. Ze zijn niet "portable", ze blijven binnen de scope.
Wat zijn lambda expressies? Een uitbreiding van anonieme methoden. Een "inline" gebruikte methode. Een alternatief voor een delegate. Tijdens compileren kan een lambda expressie omgezet worden naar een instance of een delegete of een "expression tree".
Expressions worden gevalideerd tijdens het compileren, maar geevalueerd tijdens runtime. Dynamic expression trees worden ondersteund.
Extension Methods. Hiermee kun je types uitbreiden zonder de originele code aan te passen. Erg handig als het niet jouw type is of een sealed class. Worden gedefinieerd als static methods in een statische class. Eerste parameter is this. Het type van de eerste parameter is het type wat uitgebreid wordt.
Dynamics. Geeft de compiler de instructie om tijdens compile-tijd het type checking te negeren. Stelt die controle uit tot runtime. Versimpelt de interactie met COM-objecten, un-typed en externe objecten. Waarom zou je dit niet altijd gebruiken? Omdat het gevaarlijk is. Strong typing is juist om te zorgen dat je betrouwbare code hebt.
We zien nog een klein stukje console-applicatie. Hier wordt nog even uitgelegd wat namespaces zijn, om jouw code af te schermen van andere code die misschien een class heeft met een naam die jij ook gebruikt hebt. Maar als het in een eigen namespace staat, kan de compiler zijn belofte dat het "strong typed" is behouden. Veel namespaces zijn opgezet als Bedrijfsnaam.Applicatienaam.Extra