Volgende sectie is grotendeels gebaseerd op het volgende artikel.
Named parameters
Wanneer je een methode aanroept is de volgorde van je argumenten belangrijk: deze moeten meegeven worden in de volgorde zoals de methode parameters ze verwachten.
Met behulp van named parameters kan je echter expliciet aangeven welke argument aan welke methode-parameter moet meegegeven worden.
Stel dat we een methode hebben met volgende signatuur:
Zonder named parameters zou een aanroep van deze methode als volgt kunnen zijn:
We kunnen named parameters aangeven door de naam van de parameter gevolg door een dubbel punt en de waarde. Als we dus bovenstaande methode willen aanroepen kan dat ook als volgt met named parameters:
of ook:
Volgorde van named parameters belangrijk
Je mag ook een combinatie doen van named en gewone parameters, maar dan is de volgorde belangrijk: je moet je dan houden aan de volgorde van de methode-volgorde. Je verbeterd hiermee de leesbaarheid van je code dus (maar krijgt niet het voordeel van een eigen volgorde te hanteren). Enkele voorbeelden:
Enkele NIET GELDIGE voorbeelden:
Optionele parameters
Soms wil je dat een methode een standaard waarde voor een parameter gebruikt indien de programmeur in z'n aanroep geen waarde meegaf. Dat kan met behulp van optionele of default parameters.
Je geef aan dat een parameter optioneel is door deze een default waarde te geven in de methode-signatuur. Deze waarde zal dan gebruikt worden indien de parameter geen waarde van de aanroeper heeft gekregen.
Optionele parameters worden steeds achteraan de parameterlijst van de methode geplaatst .
In het volgende voorbeeld maken we een nieuwe methode aan en geven aan dat de laatste twee parameters (optionalstr en age) optioneel zijn:
Volgende manieren zijn nu geldige manieren om de methode aan te roepen:
Je mag enkel de optionele parameters van achter naar voor weglaten. Volgende aanroepen zijn dus niet geldig:
Met optionele parameters kunnen we dit indien gewenst omzeilen. Volgende aanroep is wel geldig:
Method overloading
Method overloading wil zeggen dat je een methode met dezelfde naam en returntype meerdere keren definieert maar met andere parameters qua type en aantal. De compiler zal dan zelf bepalen welke methode moet aangeroepen worden gebaseerd op het aantal en type parameters dat je meegeeft.
Volgende methoden zijn overloaded:
Afhankelijk van de aanroep zal dus de ene of andere uitgevoerd worden. Volgende code zal dus werken:
Betterness rule
Indien de compiler twijfelt tijdens de overload resolution (welke versie moet aangeroepen worden) zal de betterness rule worden gehanteerd: de best 'passende' methode zal aangeroepen worden. Stel dat we volgende overloaded methoden hebben:
Volgende aanroepen zullen dus als volgt uitgevoerd worden:
De betterness rule is als volgt:
Als je dus bijvoorbeeld een parameter van het type int meegeeft bij een methode aanroep (eerste kolom), dan zal een long geprefereerd worden boven een float, enz.
Indien de betterness regel niet werkt, dan zal de eerste parameter bepalen wat er gebruikt wordt. Dat zien we in volgende voorbeeld:
Indien ook die regel niet werkt dan zal een error optreden zoals hier wat zal resulteren in een Ambigious overload error:
static void ExampleMethod(int required, string optionalstr = "default string", int age = 10)
ExampleMethod(15, "tim", 25); //klassieke aanroep
ExampleMethod(20, "dams"); //age zal 10 zijn
ExampleMethod(35); //optionalstr zal "default string" en age zal 10 zijn
ExampleMethode(3, 4); //daar de tweede param een string moet zijn
ExampleMethode(3, ,4);
ExampleMethod(3, age: 4);
static int ComputeArea(int lengte, int breedte)
{
int opp = lengte*breedte;
return opp;
}
static int ComputeArea(int radius)
{
int opp = (int)(Math.PI*radius*radius);
return opp;
}
static int ComputeArea(int radius) //versie A
{
int opp = (int)(Math.PI*radius*radius);
return opp;
}
static int ComputeArea(double radius) //versie B
{
int opp = (int)(Math.PI * radius * radius);
return opp;
}
Console.WriteLine($"Circle 1: {ComputeArea(7)}"); //versie A
Console.WriteLine($"Circle 2: {ComputeArea(7.5)}"); //versie B
Console.WriteLine($"Circle 3: {ComputeArea(7.3f)}"); //versie B
static void Main(string[] args)
{
Toonverhouding(5, 3.4); //versie A
Toonverhouding(6.2, 3); //versie B
}
static void Toonverhouding(int a, double b) //versie A
{
Console.WriteLine($"{a}/{b}");
}
static void Toonverhouding(double a, int b) //versie B
{
Console.WriteLine($"{a}/{b}");
}
static void Main(string[] args)
{
Toonverhouding(5.6, 3.4);
}
static void Toonverhouding(int a, double b)
{
Console.WriteLine("{0}/{1}", a, b);
}
static void Toonverhouding(double a, int b)
{
Console.WriteLine("{0}/{1}", a, b);
}
Uitbreidingsoefeningen
Film Default
Maak een methode FilmRuntime() die 3 parameters accepteert:
Een string die de naam van de film bevat
Een integer die duur in minuten van de film bevat
Een enum-type die het genre van de film bevat (Drama, Actie, etc.)
Indien de duur van de film niet wordt meegeven wordt een standaard lengte van 90 minuten ingesteld. Indien het genre niet wordt meegeven dan wordt deze default op Onbekend ingesteld.
De methode geeft niets terug maar toont eenvoudigweg de film op het scherm, gevolgd door z’n duur en genre in volgende formaat.
Toon aan in je main dat de methode werkt met zowel 1, 2 als 3 parameters. Toon ook aan dat je met ‘named arguments’ de methode kan aanroepen.
Opwarmers met geavanceerde methoden
Zorg ervoor dat de opwarmers uit Deel 0 oefeningen hiervoor steeds minstens 1 optionele parameter hebben. Roep deze methoden aan via named parameters.
Bekijk terug jouw (of mijn) oplossing van de vaardigheidsproef of de in deze cursus.
Kan je deze code leesbaarder maken door methoden (en loops) toe te voegen?
Verhaalgenerator
Bekijk het all-one-project : kan jij dit project afwerken zoals onderaan de opgave wordt voorgesteld?
Muziek en methoden
Muziek maken (Wikipedia) [] leert ons dat de grondtonen do-re-mi-fa-sol-la-si-do de frequenties : 264-297-330-352-396-440-495-528 hz behelsen (excuses indien dit jargon niet klopt. Ik ken even veel van muziek als van metsen).
De Console.Beep() methode laat ons toe om tonen te genereren op een bepaalde frequentie (in Hz) en van een bepaalde duur (in milliseconden, i.e. 1/1000 van een seconde).
We kunnen dus de computer de toonladder afspelen, elke noot 1 seconde lang, als volgt:
Opgave 1
Zorg ervoor dat je bovenstaande als volgt kunt aanroepen:
Iedere methode zal dus de correcte toon afspelen gedurende 1s (je mag dit ook sneller instellen naar keuze).
Extra: plaats ieder noot in een andere tekstkleur (m.b.v. Console.ForeGroundColor)
Opgave 3
Door een de frequentie van een toon te vermenigvuldigen of te delen met veelvouden van 2 krijg je de tonen op andere octaven. Pas de ‘noot-methoden’ aan zodat 2 parameters kunnen meegeven worden: 1. De lengte in milliseconden dat de toon moet aangehouden worden 2. De octaaf van de toon: 1 = basis octaaf die we al hadden, 2= 2e octaaf (dus frequentie x2) 3= 3e octaaf (frequentie x 3) etc.
Als je dus de 2e octaaf wil spelen, iedere toon om de 500ms moet je deze als volgt kunnen aanroepen:
Opgave 4
Maak minstens 2 methoden naar keuze: iedere methode zal een liedje beginnen spelen dat je zelf hebt gemaakt (bv. een bestaand kinderliedje). Hier bijvoorbeeld het begin van "You are my sunshine":
De methoden als naam SpeelX met X de titel van het liedje, bijvoorbeeld SpeelYouAreMySunshine.
Extra: De Lyrics verschijnen op de juiste momenten op het scherm (dus vlak voor het afspelen van de bijhorende noot).
Opgave 5
Bij het opstarten van het programma krijg je een menu te zien waaruit de gebruiker een liedje kan kiezen dat gespeeld moet worden. Vervolgens wordt dit liedje gespeeld en nadien wordt de vraag terug gesteld (oneindige loop).
Opgave 6
Wanneer een liedje werd afgespeeld dan dient de methode terug te geven (als double) hoe lang het liedje heeft geduurd. Het hoofdmenu toont dit aan het einde van het afspelen.
Je kan de duur van een methode heel eenvoudig meten als volgt, gebruikmakende van de StopWatch:
totaleTijd zal de totaal verstreken tijd in seconden bevatten.
Opgave 7
Toon je muzikale skills en zorg voor uitbreidingen naar keuze (meer songs, complexere songs, meer kleurtjes, stoerdere timings, zotte functionaliteit, animaties, etc. The sky is the limit!).
Sommige oefeningen zijn van de vorm "Maak een methode die...". Het is steeds de bedoeling dat je de werking van je methode ook test in je Main door deze aan te roepen.
Schrijf een hele reeks methodes die je samen test:
Methode Square die het kwadraat van een ingevoerd getal berekent.
Methode Radius die de straal van een cirkel kan berekenen waarvan je de diameter meegeeft.
Methodes Circumference en Surface (in de formule gebruik je Math.PI).
Methode Largest die het grootste van 2 getallen teruggeeft.
Methode IsEven die bepaalt of een getal even of oneven is (geeft een bool terug die true is indien even).
Methode ShowOdd die alle oneven getallen van 1 tot n toont waarbij n als parameter wordt meegegeven.
Technische analyse
Schrijf een voorbeeldprogramma dat in de Main-methode elke methode kort demonstreert. Toon alle getallen tot op twee cijfers na de komma. Voor ShowOddNumbers kan je nog geen resultaat teruggeven, maar je kan het wel afprinten.
UI
console applicatie
voorbeeldinteractie(s)
Oefening: H6-voorstellen
Leerdoelen
methodes
Functionele analyse
Maak een methode die jezelf voorstelt op het scherm in de vorm van "Ik ben Tim Dams, ik ben 18 jaar oud en woon in de Lambrisseringsstraat 666".
Technische analyse
Je persoonlijke informatie mag hardcoded in je methode staan. Bedoeling is dat je de methode kan aanroepen als volgt:
Deze methode voert een taak uit, maar geeft geen antwoord dat je verder zou kunnen gebruiken. Het return type is dan ook void.
UI
console applicatie
voorbeeldinteractie(s)
Oefening: H6-voorstellen-plus
Leerdoelen
methodes-met-parameters
Functionele analyse
Maak een flexibelere versie van H6-voorstellen, die je persoonlijke gegevens als argumenten meekrijgt.
Schrijf een methode die drie ints aanvaardt en de grootste als resultaat teruggeeft.
Technische analyse
Aangezien het maar om 3 argumenten gaat, kan je dit oplossen met ifs die het eerste en het tweede argument vergelijken, het eerste en het derde argument,... Test je methode uit in een voorbeeldprogrammaatje.
UI
console applicatie
voorbeeldinteractie(s)
Oefening: H6-paswoord-generator
Leerdoelen
methodes
Functionele analyse
Maak een paswoord generator die paswoorden van bepaalde lengte genereert en bestaat uit willekeurige letters, hoofdletters en cijfers. Plaats deze code in een methode met 1 parameter, namelijk de lengte van het paswoord dat gemaakt moet worden. De methode geeft het gegenereerde paswoord terug als resultaat.
Technische analyse
Maak gebruik van Random en een for-lus. Een Random genereert normaal alleen getallen, maar via casting kan je die getallen omzetten in chars. Raadpleeg een Unicode tabel voor de juiste getallen of (iets sneller) cast eerst 'a' en 'z' naar getallen en gebruik die om te bepalen welke willekeurige resultaten je mag genereren. Demonstreer je methode met een kort programma.
UI
console applicatie
voorbeeldinteractie(s)
Oefening: H6-film-default
Leerdoelen
methodes met default argumenten
Functionele analyse
Maak een methode FilmRuntime met 3 parameters:
Een string die de naam van de film bevat
Een integer die duur in minuten van de film bevat
Een enum-type FilmGenre die het genre van de film bevat. Deze enum heeft de mogelijke waarden Drama, Action, Comedy en Uncategorized.
Deze methode toont dan een samenvatting van de film op het scherm, gevolgd door zijn duur en genre in volgend formaat:
Indien de duur niet gespecifieerd wordt, wordt gezegd dat hij 90 minuten duurt. Indien het genre niet wordt meegegeven, wordt "Uncategorized" vermeld op het scherm.
Technische analyse
Schrijf je methode met drie parameters, maar geef de duur en het genre een default waarde. Toon aan in je main dat de methode werkt met zowel 1, 2 als 3 parameters. Toon ook aan dat je met "named arguments" de methode kan aanroepen.
UI
console applicatie
voorbeeldinteractie(s)
Oefening: H6-rekenmachine
Leerdoelen
werken met verschillende methodes
Functionele analyse
Rekenmachine
Maak de methoden TelOp, TrekAf, VermenigVuldig en Deel.
Aan deze methoden worden twee doubles meegeven als parameter. Het returntype is de bewerking met die twee parameters.
Maak een eenvoudig programma'tje waarin je deze methoden test a.h.v. een keuze die gemaakt moet worden.
Technische analyse
Schrijf je vier methoden, telkens met twee parameters.
//Start
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
//Voer te meten code uit
//Stop
stopwatch.Stop();
double totaletijd = stopwatch.Elapsed.TotalSeconds;
Wat moet ik kwadrateren?
> 2
4
Wat is de diameter?
> 6
3
Wat is de diameter?
> 2
De omtrek is 6.28
De oppervlakte is 3.14
Welke twee getallen wil je vergelijken?
> 3
> 9
9 is het grootste getal
Geef een getal en ik zeg of het even is:
> 4
Het getal is even.
Geef een getal en ik zoek de oneven getallen:
> 7
1
3
5
7
MyIntro();
Ik ben Tim Dams, ik ben 18 jaar oud en woon in de Lambrisseringsstraat 666
Maak een keuze uit
1. Optellen
2. Aftrekken
3. Vermenigvuldingen
4. Delen
Geef het overeenstemmende nummer als keuze in: 1
Geef het eerste nummer in: 2
Geef het tweede nummer in: 3
Resultaat: (2 + 3) = 5
TelOp(number1, number2)
Wat is een methode
Een methode, ook vaak functie genoemd, is in C# een stuk code ('block') bestaande uit een 0, 1 of meerdere statements. De methode kan herhaaldelijk opgeroepen worden, al dan niet met extra parameters, en kan ook een resultaat terug geven.
De basis-syntax van een methode is de volgende indien je een methode in je hoofdprogramma wenst te schrijven (de werking van het keyword static zien we later):
Vervolgens kan je deze methode elders oproepen als volgt, indien de methode geen parameters vereist:
Indien er wel parameters nodig zijn dan geef je die mee als volgt, het is belangrijk dat de volgorde van de parameters gehanteerd wordt zoals je in de methode zelf hebt beschreven.
Returntypes
Het returntype van een methode geeft aan wat het type is van de data die de methode als resultaat teruggeeft bij het beëindigen ervan. Eender welk type dat je kent kan hiervoor gebruikt worden, zoals int, string, char, float, etc. Maar ook klassen (zie later) zoals Student, Canvas, etc.
Het is belangrijk dat in je methode het resultaat ook effectief wordt teruggegeven, dit doe je met het keyword return gevolgd door de variabele die moet teruggeven worden. Denk er dus aan dat deze variabele van het type is dat je hebt opgegeven als zijnde het returntype. Van zodra je return gebruikt zal je op die plek uit de methode 'vliegen'.
Volgend voorbeeld bestaat uit een methode die de naam van de auteur van je programma teruggeeft:
Mogelijke manieren om deze methode in je programma te gebruiken zouden kunnen zijn:
Of bijvoorbeeld ook:
Hier een voorbeeld van een methode die de faculteit van 5 berekent. De oproep van de methode gebeurt vanuit de Main-methode:
Void returntype
Indien je methode niets teruggeeft wanneer de methode eindigt (bijvoorbeeld indien de methode enkel tekst op het scherm toont) dan dien je dit ook aan te geven. Hiervoor gebruik je het keyword void. Een voorbeeld:
Parameters doorgeven
Parameters kunnen op 2 manieren worden doorgegeven aan een methode:
Wanneer een parameter by value wordt meegegeven aan een methode, dan wordt een kopie gemaakt van de huidige waarde die wordt meegegeven.
Wanneer echter een parameter by reference wordt meegegeven dan zal een pointer worden meegegeven aan de methode. Deze pointer bevat het adres van de eigenlijke variabele die we meegeven. Aanpassingen aan de parameters zullen daardoor ook zichtbaar zijn binnen de scope van de originele variabele.
Parameters doorgeven by value
Je methode definitie kan ook 1 of meerdere parameters bevatten. Hierbij gebruik je volgende syntax:
Deze parameters zijn nu beschikbaar binnen de methode om mee te werken naar believen.
Stel bijvoorbeeld dat we onze FaculteitVan5 willen veralgemenen naar een methode die voor alle getallen werkt, dan zou je volgende methode kunnen schrijven:
Dit geeft als uitvoer: Faculteit van 5 is 120.
Je zou nu echter de waarde van getal kunnen aanpassen (door bijvoorbeeld aan de gebruiker te vragen welke faculteit moet berekend worden) en je code zal nog steeds werken.
Stel bijvoorbeeld dat je de faculteiten wenst te kennen van alle getallen tussen 1 en 10, dan zou je schrijven:
De volgorde waarin je je parameters meegeeft bij de aanroep van een methode is belangrijk. De eerste variabele wordt aan de eerste parameter toegekend, en zo voort.
Het volgende voorbeeld toont dit. Stel dat je een methode hebt:
Stel dat we nu in onze main volgende aanroep doen:
Dit zal een ander resultaat geven dan wanneer we volgende code zouden uitvoeren:
Ook de volgorde is belangrijk zeker wanneer je met verschillende types als parameters werkt:
Deze aanroep is correct:
Deze is FOUT en zal niet compileren:
Commentaar toevoegen
Het is aan te raden om steeds boven een methode een Block-commentaar te plaatsen als volgt (dit werkt enkel bij methoden): ///
Visual Studio zal dan automatisch de parameters verwerken van je methode zodat je vervolgens enkel nog het doel van iedere parameter moet plaatsen.
Stel dat we een methode hebben geschreven die de macht van een getal berekend. We zouden dan volgende commentaar toevoegen:
Wanneer we nu elders de methode Macht gebruiken dan krijgen we automatische extra informatie:
Een eenvoudig voorbeeld (bron: handboek Visual C# 2008, Dirk Louis) waar het gebruik van methoden onmiddellijk duidelijk wordt. Stel, je hebt 15000 euro op een spaarrekening vastgezet waarvoor de bank u een rente geeft van 3,5%. Nu wil je natuurlijk weten hoe je kapitaal van jaar tot jaar groeit. Stel dat je aan de verleiding weerstaat en de jaarlijkse rente niet opneemt, maar op de spaarrekening laat staan. Je berekent dan je kapitaal na n jaren met de volgende formule:
(^ is tot de macht in pseudocode)
Nu kan je berekenen hoeveel geld je de volgende zeven jaren verdient, het bijhorende programma ziet er zo uit:
Dit geeft als uitvoer:
Het programma werkt naar behoren, maar zoals je zelf kan zien wordt er aardig wat code herhaalt, op enkele kleine details na. Bij iedere berekening en het tonen van de interest verandert enkel de macht en het aantal jaar. Als er nu een fout in je interestberekening zou staan dan zal je die op 7 plaatsen telkens moeten veranderen.
Rente berekenen verbeterd, versie 1
We kunnen nu terug naar onze rente-berekenaar en dit programma aanzienlijk vereenvoudigen door gebruik te maken van methoden. Namelijk als volgt:
Je code opdelen in methoden is een zeer goede eerste stap naar modulair programmeren: kleine stukken code die ieder een eigen verantwoordelijkheid hebben. Om perfect modulair te zijn moet een methode zo praktisch en algemeen mogelijk blijven, zodat de methode herbruikbaar is in andere projecten.
In het vorige voorbeeld is de methode van de renteberekening niet perfect modulair. Stel dat je later in het programma opnieuw de rente wil berekening maar niet het resultaat op het scherm wil tonen. Of stel dat je de rente wil berekenen met een andere percentage, dan kunnen we de eerder geschreven methode dus niet gebruiken.
Modulair programmeren: indien je modulair wenst te programmeren moet je je aan volgende zaken houden:
Beperk de methode strikt tot het uitvoeren van de opgedragen taak. Dus in het voorbeeld: alleen de renteberekening en geen verdere verwerking van de resultaten.
Als de methode een waarde teruggeeft, declareer hiervoor dan een passende returnwaarde.
Geef alle grootheden waarmee je de werkwijze van de methode wilt aanpassen mee aan de methode als parameter. In dit voorbeeld zijn dat dus de variabelen startkapitaal, rentepercentage en looptijd.
De nieuwe algemene, verbeterde methode wordt dan:
De aanroep van deze methode in de main wordt dan de volgende:
Een Nuttige methode
Vaak moet je code schrijven van volgende vorm:
Waarbij je eerst een zinnetje toont aan de gebruiker en dan z'n input omzet naar een werkbaar getal.
Als deze constructie op meerdere plekken in een project voorkomt dan is het nuttig om deze twee lijnen naar een methode te verhuizen die er dan zo kan uitzien:
De code van zonet kan je dan nu herschrijven naar:
static returntype MethodeNaam(parameters)
{
//code van methode
}
Console.WriteLine("This program is written by "+ GetNameAuthor());
partial class Program
{
static int FaculteitVan5()
{
int resultaat = 1;
for (int i = 1; i <= 5; i++)
{
resultaat *= i;
}
return resultaat;
}
static void Main(string[] args)
{
Console.WriteLine("Faculteit van 5 is {0}", FaculteitVan5());
}
}
static void ShowProgramVersion()
{
Console.Write("The version of this program is: ");
Console.Write(2.16 + "\n");
}
static returntype MethodeNaam(type parameter1, type parameter2)
{
//code van methode
}
static int BerekenFaculteit(int grens)
{
int resultaat = 1;
for (int i = 1; i <= grens; i++)
{
resultaat *= i;
}
return resultaat;
}
static void Main(string[] args)
{
int getal = 5;
Console.WriteLine("Faculteit van {0} is {1}", getal, BerekenFaculteit(getal));
}
for (int i = 1; i < 11; i++)
{
Console.WriteLine("Faculteit van {0} is {1}", i, BerekenFaculteit(i));
}
Faculteit van 1 is 1
Faculteit van 2 is 2
Faculteit van 3 is 6
Faculteit van 4 is 24
Faculteit van 5 is 120
Faculteit van 6 is 720
Faculteit van 7 is 5040
Faculteit van 8 is 40320
Faculteit van 9 is 362880
Faculteit van 10 is 3628800
static void ToonInfo(string name, int age)
{
Console.WriteLine($"{name} is {age} old");
}
ToonInfo("Tim", 37);
ToonInfo(37, "Tim");
/// <summary>
/// Berekent de macht van een getal.
/// </summary>
/// <param name="grondtal">Het getal dat je tot een bepaalde macht wilt verheffen</param>
/// <param name="exponent">De exponent van de macht</param>
/// <returns></returns>
static int Macht(int grondtal, int exponent)
{
int result = grondtal;
for (int i = 1; i < exponent; i++)
{
result *= grondtal;
}
return result;
}
eindkapitaal = startkapitaal x (1 + (rentepercentage/100))^n
Je herkent een methode aan de ronde haakjes na de methodenaam. Je hebt dus reeds een aantal methoden gebruikt zonder dat je het wist, denk maar aan WriteLine(), ReadLine() en Parse().
Dit zijn dus alle 3 methoden: stukken code die een specifieke taak uitvoeren.
Sommige methoden, zoals WriteLine(), vereisen dat je een aantal parameters meegeeft. De parameters dien je tussen de ronde haakjes te zetten. Hierbij is het uiterst belangrijk dat je de volgorde respecteert die de ontwikkelaar van de methode heeft gebruikt. Indien je niet weet wat deze volgorde is kan je altijd Intellisense gebruiken. Typ gewoon de methode in je code en stop met typen na het eerste ronde haakje, vervolgens verschijnen alle mogelijke manieren waarop je deze methoden kan oproepen.
Tussen de haakjes zien we welke parameters en hun type je mag meegeven aan de methode, gevolgd door het return-type van de methode en een eventuele beschrijving (merk dus op dat je de WriteLine-methode ook mag aanroepen zonder parameters, dit zal resulteren in een lege lijn in de console).
Met behulp van de F1-toets kunnen meer info over de methode in kwestie tonen. Hiervoor dien je je cursor op de Methode in je code te plaatsen, en vervolgens op F1 te drukken.
Voor WriteLine geeft dit:
In de overload list zien we de verschillende manieren waarop je de methode in kwestie kan aanroepen. Je kan op iedere methode klikken voor meer informatie en een codevoorbeeld.
Intellisense
"Hoe kan je deze methode nu gebruiken?" is een veelgestelde vraag. Zeker wanneer je de basis van C# onder knie hebt en je stilletjes aan met bestaande .NET bibliotheken wil gaan werken. Wat volgt is een essentieel onderdeel van VS dat veel gevloek en tandengeknars zal voorkomen.
De help-files van VS zijn zeer uitgebreid en dankzij IntelliSense krijg je ook aardig wat informatie tijdens het typen van de code zelf.
Type daarom onder vorige WriteLine-zin het volgende:
Wacht nu even en er zal na het punt (.) een lijst komen van methoden en fields die beschikbaar zijn. Je kan hier met de muis doorheen scrollen en zo zien welke methoden allemaal bij de Console klasse horen.
Scroll maar eens naar de WriteLine-methode en klik er op. Je krijgt dan extra informatie over die methode te zien:
De Math.Pow methode vereist dus bijvoorbeeld 2 parameters van het type double. Wanneer je nu begint te typen dan zal intellisense tonen waarvoor iedere parameter staat wanneer je aan die parameter gaat beginnen typen:
