Cursus c#: methoden

Methoden worden steeds gedeclareerd binnen een klasse, voor ons dus binnen de accolades:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }
}

De algemene syntax om een methode te declareren gaat als volgt:

returnType methodeNaam (parameterLijst)
{
   //statements binnen de methode
}

Methode ToonNaam

Maak een methode die je naam in een berichtvenster toont:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

	void ToonNaam()
	{
		MessageBox.Show("William Schokkelé");
	}

}

de nieuwe methode heeft de naam ToonNaam
ToonNaam retourneert niks: sleutelwoord void
ToonNaam ontvangt geen parameters: lege ronde haken na de naam van de methode.

Een methode aanroepen

Een methode aanroepen gebeurt door de naam van de methode te noteren gevolgd door ronde haakjes met daarbinnen de eventuele parameters:

public MainWindow()
{
	InitializeComponent();
	ToonNaam();
}

Hier roep je ToonNaam aan vanuit de constructor (zie later) van Window1. Voorlopig is het voldoende te weten dat de code binnen dit codeblok steeds wordt uitgevoerd bij het starten van de toepassing.
Merk op dat je eigen methode onmiddellijk ter beschikking is met Visual Studio Intellisense.

Daar we een grafische toepassing maken in WPF is het natuurlijk leuker de methode te laten aanroepen via bv. een druk op een knop.

Plaats een Button op het Window
Geef de button de Name toonNaam en Content Toon Naam
Dubbelklik toonNaam, een event-handlermethode wordt automatisch aangemaakt:
```
private void toonNaam_Click(object sender, RoutedEventArgs e)
{

}
```

Vanuit deze methode kan je je eigen methode toonNaam aanroepen:

private void toonNaam_Click(object sender, RoutedEventArgs e)
{
   toonNaam();
}

Verwijder de aanroep van ToonNaam uit de constructor voor Window1.

Methode BerekenSom

Onze toepassing wordt dynamisch: het is de bedoeling dat de gebruiker twee getallen kan intikken, een druk op een knop toont de som van deze getallen.

Voeg een methode toe:
```
int BerekenSom(int getalL, int getalR)
{
	return getalL + getalR;
}
```
- De methode heeft als naam BerekenSom
- BerekenSom retourneert een geheel getal naar de plaats van aanroep:
```
int BerekenSom(int getalL, int getalR)
{
	return getalL + getalR;
}
```
- BerekenSom ontvangt twee gehele getallen als parameters:
```
int BerekenSom(int getalL, int getalR)
{
	return getalL + getalR;
}
```
- Binnen de methode worden de twee ontvangen gehele getallen opgeteld:
```
int BerekenSom(int getalL, int getalR)
{
	return getalL + getalR;
}
```
Samengevat: de methode BerekenSom ontvangt twee gehele getallen, de som van deze getallen wordt geretourneerd.
Voeg een TextBox getalLinks toe aan Window1
Voeg een TextBox getalRechts toe aan Window1
Voeg een Button berekenSom met Content Bereken Som toe aan Window1
Zorg voor een gelijkaardige layout:

Dubbelklik som: een eventhandlermethode wordt automatisch aangemaakt:

private void berekenSom_Click(object sender, RoutedEventArgs e)
{

}

Voorzie de methode-statments:

private void berekenSom_Click(object sender, RoutedEventArgs e)
{
	int links = int.Parse(getalLinks.Text);
	int rechts = int.Parse(getalRechts.Text);
	int som = BerekenSom(links, rechts);
	MessageBox.Show("De som van " +links +" en " +rechts +" is " +som,"Som berekenen");
}

Scope

Binnen de methdoe berekenSom_Click werden drie variabelen links, rechts en som gedeclareerd.

Variabelen die gedeclareerd werden binnen een methode hebben deze methode als bereik of scope.
Dit wil zeggen dat deze variabelen buiten deze methode totaal ongekend zijn en dus onbruikbaar.
Voorzie een methode ScopeTest:

void ScopeTest()
{
	MessageBox.Show("De som was: " + som);
}

Wanneer je de toepassing wil uitvoeren krijg je een compileerfout: The name 'som' does not exist in the current context
som is dus ongekend binnen de methode ScopeTest.
Je kan som natuurlijk opnieuw declareren en de berekening opnieuw doen, maar dit kan natuurlijk niet de bedoeling zijn.

Wanneer je de variabele som wenst te gebruiken buiten de methode berekenSom_Click kan je deze declareren op klasseniveau: buiten elke methode, maar binnen de accolades van de klasse.
Pas de toepassing als volgt aan:

public partial class MainWindow : Window
{
	int som;

	private void berekenSom_Click(object sender, RoutedEventArgs e)
	{
		int links = int.Parse(getalLinks.Text);
		int rechts = int.Parse(getalRechts.Text);
		som = BerekenSom(links, rechts);
		MessageBox.Show("De som van " +links +" en " +rechts +" is " +som,"Som berekenen");
		ScopeTest();
	}
	
	...

}

De variabele som is nu gekend in de ganse klasse Window1.

Overloading

Als twee identifiers (variabelen, methoden, ...) binnen dezelfde scope, dezelfde naam hebben zeggen we dat ze overloaded zijn.
Dikwijls is overloading niet de bedoeling (zoals twee keer dezelfde variabele declareren binnen dezelfde methode) en krijg je een compile-time error (een fout tijdens het compileren).
Soms is overloading echter extreem nuttig, dit fenomeen zien we vaak bij het gebruik van methoden.

We willen de tekstwaarden uit de tekstvakken onmiddellijk kunnen doorgeven aan BerekenSom.
De omzetting in een geheel getal moet nu dus gebeuren in de methode BerekenSom.
Vanzelfsprekend willen we de methode BerekenSom die twee gehele getallen ontvangt niet verliezen, we maken dus een bijkomende methode BerekenSom:

int BerekenSom(int getalL, int getalR)
{
	return getalL + getalR;
}

int BerekenSom(string getalL, string getalR)
{
	int links = int.Parse(getalL);
	int rechts = int.Parse(getalR);
	return BerekenSom(links, rechts);
}

private void berekenSom_Click(object sender, RoutedEventArgs e)
{
	string links = getalLinks.Text;
	string rechts = getalRechts.Text;
	som = BerekenSom(links,rechts);
	MessageBox.Show("De som van " +links +" en " +rechts +" is " +som,"Som berekenen");
}

Let op de Visual Studio Intellisense bij het aanroepen van de methode BerekenSom.
Bekijk eens het aantal overloads voor Console.WriteLine()

Toepassing

Toepassing: Kostprijs

Voeg aan WpfMethoden een nieuw Window Kostprijs toe (rechtsklik WpfMethoden, add, Window...).
Stel in App.xaml in: StartupUri="Kostprijs.xaml"
Wanneer op de knop geklikt wordt, wordt de totaalprijs op het scherm getoond.
Maak in je toepassing een methode BerekenTotaalPrijs die een double retourneert en een double en een int ontvangt.
Extra: experimenteer met de Visual Studio Debugger.

Toon /verberg

 

private void berekenTotaalprijs_Click(object sender, RoutedEventArgs e)
{
	double dagprijs = double.Parse(txtDagprijs.Text);
	int aantalDagen = int.Parse(txtAantalDagen.Text);
	double totaalPrijs = BerekenTotaalPrijs(dagprijs, aantalDagen);
	lblTotaalprijs.Content = "€ " +totaalPrijs;
}

private double BerekenTotaalPrijs(double dagprijs, int aantalDagen)
{
	return dagprijs * aantalDagen;
}

c# : methoden