Thuis
Contacten

    Hoofdpagina


Naam: Stefan de Vries

Dovnload 25.67 Kb.

Naam: Stefan de Vries



Datum13.11.2017
Grootte25.67 Kb.

Dovnload 25.67 Kb.

Onderzoek van

C#

Naam: Stefan de Vries



Vak: Concepten van Programmeren

Inhoudsopgave


Inhoudsopgave 2

2

Inleiding 3



1 Parameteroverdracht mechanismen 4

1.1 Value parameters 4

1.2 Reference parameters 5

1.3 Output parameters 6

1.4 Parameter Arrays 7

2 Overerving en dynamic-dispatching van methoden 8

2.1 Overerving 8

2.1.1 Virtual 8

2.1.2 Override 8

2.1.3 Abstract 8

2.1.4 New 8

2.2 Dynamic-dispatch 9

Literatuurlijst 10

Inleiding


Voor het vak “concepten van programmeren” hebben we de opdracht om een onderzoek te doen naar C#. Daarbij moeten we 2 onderdelen van C# beschrijven, namelijk:

  • Welke parameteroverdracht-mechanismen heeft en C# en hoe werken deze.

  • Op welke manier is in C# overerving en dynamisch-dispatch van methoden geregeld.

In het volgende hoofdstuk, hoofdstuk 1, worden de parameteroverdracht-meganismen kort beschreven, en verduidelijkt met een voorbeeld. In hoofdstuk 2 komt het 2e onderwerp aan bod, overerving en dynamisch-dispatch van methoden.

1 Parameteroverdracht mechanismen


Er zijn 4 soorten parameteroverdracht mechanismen in C#:


  • value paramaters

  • reference parameters

  • output parameters

  • arameter arrays

In de volgende paragrafen worden de mechanismen kort uitgelegd.



1.1 Value parameters


Een parameter zonder modifier is een value parameter. Een modifier geeft aan dat het een ander soort parameter is, een aangepaste parameter. Een aangepaste parameter werkt weer net iets anders dan de standaard parameter. De aangepaste parameters worden later beschreven. De standaard parameter is in dit geval de value parameter.
Een value parameter correspondeert met een lokale variabele. Deze lokale variabele krijgt dezelfde waarde als de value parameter. De waarde van de value parameter veranderd niet, dus is nog steeds hetzelfde nadat de methode is afgelopen. De lokale variabele die nu dus de zelfde waarde heeft als de value parameter kan wel veranderen, maar dat is alleen van invloed binnen de methode waarin de lokale variabele word gebruikt.
class Test

{

static void Doubles(int X)



{

X = X + X;

}

static void Main(string[] args)



{

Int i = 5;

Doubles(i);

Console.WriteLine("{0}", i); //Outputs “10”

}

}

Voorbeeld 1: Value parameter


De waarde van i is voor de methode waarde 5, tijdens de methode word de waarde verdubbeld en is i dus 1 en als de methode is afgelopen dan is gewoon weer 5.

1.2 Reference parameters


Een parameter die een “ref” modifier heeft is een refence parameter. Omdat deze parameter dus een modifier heeft is het een aangepaste parameter en verschilt de werking dus met de Value parameter. De basis van de parameter is wel hetzelfde gebeleven. Een reference parameter wordt gebruikt voor input en output. In het voorbeeld is duidelijk te zien hoe dit werkt. Het argument dat word meegegeven aan de reference parameter moet een variabele zijn.

class Test


{

static void Swap(ref int x, ref int y) {


int temp = x;
x = y;
y = temp;
}

static void Main()

{
int i = 1, j = 2;
Swap(ref i, ref j);
Console.WriteLine("{0} {1}", i, j); // Outputs "2 1"
}
}

Voorbeeld 2: Reference parameter
In het voorbeeld zie je de “ref” modifier staan, static void Swap(ref int x….). Dit houd dus in dat ‘int x’ de reference parameter is. Ref parameters moeten wel eerst geïnitialiseerd worden, dit in tegenstelling tot de output parameters. Je kan zien dat de reference parameters inderdaad worden gebruikt voor input en output. I en j hebben als waarder 1 en 2. Deze worden meegeven aan de methode “Swap”. Hierin worden de 2 waardes omgedraaid. Als de methode is afgelopen dan zijn de waardes van i en j respectievelijk 2 en 1.

1.3 Output parameters


Een parameter die een “out” modifier heeft is een output parameter. Een output parameter is vrijwel gelijk aan een reference parameter, alleen word, zoals de naam al doet vermoeden, de output parameter niet voor input gebruilt. Hieronder staat een voorbeeld van de out parameter.
class Test
{
static void Divide(int x, int y, out int result, out int remainder)

{
result = x / y;


remainder = x % y;
}

static void Main()

{
int res, rem;
Divide(10, 3, out res, out rem);
Console.WriteLine("{0} {1}", res, rem); //Outputs “3 1”
}
}

Voorbeeld 3: Output parameter.
Voor input bij deze methode worden gewoon de standaard value parameters gebruikt. Die zijn na afloop van de methode dan ook niet van waarde veranderd. De 2 out parameters, res en rem, hebben nu wel een waarde gekregen, deze hebben nu de waarde 3 en 1. De out parameters hoeven niet eerst geïnitialiseerd worden.

1.4 Parameter Arrays


Een parameter die de “param” modifier heeft is een paramater array. Met de parameter array kan je een methode een variabel aantal argumenten meegeven. Hoe er wel rekening mee dat alleen de laatste parameter van een methode de parameter array mag zijn. Het type array dat alleen gebruikt kan worden is een 1 dimensionale array. De Write en WriteLine methodes van de System.Console klasse zijn goeie voorbeelden van gebruik van de parameter array.
public class Console
{
public static void Write(string fmt, params object[] args) {...}

public static void WriteLine(string fmt, params object[] args) {...}


}

Voorbeeld 4: Write en WriteLine maken gebruik van de parameter array.
Binnen de methode gedraagt de parameter array zich als een normale parameter met het array type. Alleen in de methode aanroep kan de parameter array op 2 manieren worden genoteerd. Namelijk als volgt:
Console.WriteLine("x={0} y={1} z={2}", x, y, z);

Voorbeeld 5 : Parameter array notatie 1
In de manier als in voorbeeld 5 kunnen er een variabel aantal argumenten van hetzelfde type als de array worden meegegeven. In dit geval worden x, y en z meegegeven, gewoon als losse argumenten. Tijden het uitvoeren wordt er dan automatisch een array aangemaakt met daarin die argumenten. Wat in voorbeeld 6 staat is precies hetzelfde alleen dan een andere notatie. Nu wordt er gelijk een array meegegeven aan de methode.
object[] args = new object[3];
args[0] = x;
args[1] = y;
args[2] = z;
Console.WriteLine("x={0} y={1} z={2}", args);

Voorbeeld 6: Parameter array notatie 2

2 Overerving en dynamic-dispatching van methoden

2.1 Overerving


Overerving in C# werkt bijna hetzelfde als in de meeste andere OO talen. Om overerving in C# mogelijk te maken word er gebruik gemaakt van modifiers. Er zijn een aantal verschillende modifiers.

  • virtual

  • override

  • abstract

  • new

In de volgende paragrafen worden de verschillende modifiers kort beschreven.

2.1.1 Virtual


Als je de modifier “virtual” gebruikt in je methode declaratie, dan geef je hiermee aan dat een klasse die erft van de klasse waar de methode staat die methode mag overschrijven.

2.1.2 Override


De modifier “override” gebruik als je een methode van de klasse waarvan je erft wil overschrijven. Je kunt een methode overschrijven als die de modifier “virtual” heeft of de modifier abstract.

2.1.3 Abstract


Een methode word abstract verklaard als er geen implementatie is van die methode. Een abstracte methode is een virtuele methode. Dat betekend dat hij overschreven kan worden door een subklasse. Een abstracte methode mag alleen in een klassse die ook abstract is.

2.1.4 New


Een methode uit een subklasse met dezelfde naam als een methode uit de hoofdklasse kan je een modifier “new” meegegeven. Hiermee verstopt de methode de methode uit de hoofdklasse. Dit kan gedaan worden in het geval dat de subklasse een niewe methode krijgt. Maar dat er later in de hoofdklasse een methode komt met dezelfde naam.

2.2 Dynamic-dispatch

Dynamisch-disptach houd in dat er in run-time wordt bepaald welke methode van de instantie wordt aangeroepen. Er zijn 2 soorten types van instanties:



  • statisch

  • dynamisch

Bij het statische type is een methode virtueel gedeclareerd. Dit gebeurd met de modifier “virtual”. Met het dynamische type kan de methode opnieuw worden gedeclareerd. De statische methode kan dan worden overschreven, dit met behulp van de modifier “override”, of de statische methode word als nieuwe methode gezien, dit met behulp van de modifier “new”.



Literatuurlijst



CSharp Language Specificatie Version 1.2

  • 1 Parameteroverdracht mechanismen
  • 1.2 Reference parameters
  • 2 Overerving en dynamic-dispatching van methoden 2.1 Overerving

  • Dovnload 25.67 Kb.