Overloading in C#
Inleiding
We zien bij deze post een plaatje met drie afbeeldingen van dezelfde dame. We zien dat het om dezelfde dame gaat, maar als we langer naar de afbeelding kijken dan zien we dat de dame elke keer een andere lichaamshouding aanneemt. M.a.w. ze doet elke keer weer wat anders door elke keer weer een andere lichaamshouding aan te nemen.
Een soortgelijk principe vind je ook in C# terug bij methoden en men noemt die techniek Overloading. Net zoals de dame van de uitgelichte afbeelding verschillende lichaamshoudingen aanneemt, zo gaat het bij overloading om één en dezelfde methode dat verschillende dingen doet. En wat de methode precies moet doen, dat kan je sturen met de parameters die meegegeven worden bij de aanroep van de methode (je “overlaadt” de methode met parameters).
Deze post gaat verder met het voorbeeld dat in de post over object oriëntatie is besproken. Het verdient de aanbeveling eerst de desbetreffende post te lezen alvorens verder te gaan met deze post.
Constructor – overloading
Een constructor is een methode dat automatisch wordt gestart bij de instantiatie van een object. Een constructor is ook maar een methode en het enige wat hem van andere methoden onderscheidt is dat een constructor automatisch wordt gestart bij de instantiatie van een object. We passen in dit voorbeeld het overload principe toe op de constructor, maar het kan op willekeurig elke andere methode toegepast worden.
We hebben in een eerdere post een Auto-klasse gedefinieerd en we zagen dat de Auto-objecten bij hun “geboorte” een merk en een kleur milieusticker meekrijgen. We zagen in de eerdere post ook dat de constructor ervoor zorgt dat via een aantal backing variables de object eigenschappen van waarden worden voorzien.
We kunnen de onderstaande drie varianten definiëren voor de constructor. We definiëren drie varianten waarbij het onderscheid zit in de parameters die worden meegegeven. We hebben een variant:
- met twee parameters: public Auto(string merk, int milieusticker) { … }
- met één parameter: public Auto(string merk) { .. }
- zonder parameter: public Auto() { …}
// Constructor
// als 2 parameters zijn opgegeven
public Auto(string merk, int milieusticker)
{
_milieusticker = milieusticker;
_merk = merk;
_vervuilingsgraad = OverJeAuto(milieusticker);
}
// Constructor
// als 1 parameter is opgegeven
public Auto(string merk)
{
_milieusticker = (int)Kleur.Groen;
_merk = merk;
_vervuilingsgraad = OverJeAuto(_milieusticker);
}
// Constructor
// als geen parameters zijn opgegeven
public Auto()
{
_milieusticker = (int)Kleur.Groen;
_merk = "GHB (GuanggongHunnenburgBetrieb)";
_vervuilingsgraad = OverJeAuto(_milieusticker);
}
De compiler ziet dat de methode bij de aanroep met parameters wordt “over laden” en het kan aan de hand van de parameters (de signatuur) zien welke variant precies opgestart moet worden. We hebben in dit voorbeeld drie varianten gedefinieerd waarbij elke variant een eigen signatuur heeft (twee, één of geen parameters).
Als we bijvoorbeeld instantiëren zonder parameters dan ziet de compiler dat. De compiler ziet ook dat er een constructor-variant aanwezig is met een signatuur dat overeenkomt (in dit geval een variant zonder parameters) en de compiler zal op grond daarvan de constructor variant zonder parameters opstarten.
Ook de intellisense van Visual Studio ziet de overload varianten van een bepaalde methode en er zijn in dit voorbeeld drie varianten voor handen:
Object instantiëren
We kiezen ervoor om te instantiëren zonder parameters waardoor bij het instantiëren de constructor-zonder-parameter-variant wordt opgestart. De desbetreffende variant zorgt ervoor dat default waarden worden ingevuld voor het nieuwe object:
class MainClass
{
public static void Main(string[] args)
{
// instantieer
Auto mijnAuto = new Auto();
// En we hebben..
Console.WriteLine(
"Je bent in het trotse bezit van:");
Console.WriteLine(
"- een {0}.", mijnAuto.Merk);
Console.WriteLine(
"- En de Milieusticker van je bolide is {0}." +
Environment.NewLine,
(Kleur)mijnAuto.MilieuSticker);
Console.WriteLine(
"Over de vervuilingsgraad van je auto:" +
Environment.NewLine +
"{0}" + Environment.NewLine,
mijnAuto.Vervuilingsgraad);
}
}
Waarmee een echte GHB (GuanggongHunnenburgBetrieb) voertuig object met een groene milieusticker het levenslicht ziet:
Je bent in het trotse bezit van:
- een GHB (GuanggongHunnenburgBetrieb).
- En de Milieusticker van je bolide is Groen.
Over de vervuilingsgraad van je auto:
- Je voertuig is momenteel de milieuvriendelijkste.
Press any key to continue...
Slot
We hebben in het voorbeeld in deze post het overloaden toegepast op de constructor. Voor de constructor hebben we drie varianten gedefinieerd waarbij elke variant een verschillende signatuur heeft (in dit voorbeeld twee, één of geen parameters).
Als een object bijvoorbeeld zonder parameters wordt geïnstantieerd dan wordt de constructor variant zonder parameters gestart waarbij die variant defaultwaarden invult voor het merk en de mileusticker kleur. In dit geval leggen de constructor varianten zich alleen maar toe op het vullen van defaultwaarden voor het merk en de mileusticker kleur, maar de functionaliteit hoeft zich niet te beperken tot alleen maar dat.
Als het alleen maar zou gaan om het toekennen van defaultwaarden door de constructor dan zou constructor chaining een betere techniek zijn omdat je met constructor chaining alleen maar in de constructor met de meeste parameters dingen hoeft te doen met backing variables terwijl je in het voorbeeld in deze post je in alle constructor varianten dingen met backing variables moet doen.
Hopelijk ben je met deze posting weer wat wijzer geworden en ik hoop je weer terug te zien in één van mijn volgende blog posts. Wil je weten wat ik nog meer over C# heb geschreven? Hit the C# button…
Voorbeeldprogramma
using System;
public enum Kleur
{
Groen,
Paars,
Geel,
Oranje,
Rood,
Grijs
}
class Auto
{
// Backing variables - fields
private string _merk;
private int _milieusticker;
private string _vervuilingsgraad;
// Property Merk
public string Merk
{
get { return _merk; }
set { _merk = value; }
}
// Property MilieuSticker
public int MilieuSticker
{
get { return _milieusticker; }
set { _milieusticker = value; }
}
// Property Vervuilingsgraad
public string Vervuilingsgraad
{
get { return _vervuilingsgraad; }
}
// Constructor
// als 2 parameters zijn opgegeven
public Auto(string merk, int milieusticker)
{
_milieusticker = milieusticker;
_merk = merk;
_vervuilingsgraad = OverJeAuto(milieusticker);
}
// Constructor
// als 1 parameters is opgegeven
public Auto(string merk)
{
_milieusticker = (int)Kleur.Groen;
_merk = merk;
_vervuilingsgraad = OverJeAuto(_milieusticker);
}
// Constructor
// als geen parameters zijn opgegeven
public Auto()
{
_milieusticker = (int)Kleur.Groen;
_merk = "GHB (GuanggongHunnenburgBetrieb)";
_vervuilingsgraad = OverJeAuto(_milieusticker);
}
// Methode OverjeAuto
public string OverJeAuto(int kleur)
{
string resultaat = "";
switch (kleur)
{
case (int)Kleur.Groen:
resultaat =
"- Je voertuig is momenteel de milieuvriendelijkste.";
break;
case (int)Kleur.Paars:
resultaat =
"- Je voertuig zit iets onder de norm, maar voldoet.";
break;
case (int)Kleur.Geel:
resultaat =
"- Je voertuig is al wat ouder en iets minder schoon.";
break;
case (int)Kleur.Oranje:
resultaat =
"- Je voertuig is tamelijk oud en relatief vervuilend.";
break;
case (int)Kleur.Rood:
resultaat =
"- Je voertuig zeer vervuilend!";
break;
case (int)Kleur.Grijs:
resultaat =
"- Je voertuig is ultra vervuilend!!";
break;
default:
resultaat =
"- Geen gegevens bekend over de vervuilingsgraad.";
break;
}
return resultaat;
}
}
class MainClass
{
public static void Main(string[] args)
{
// instantieer
Auto mijnAuto = new Auto();
// En we hebben..
Console.WriteLine(
"Je bent in het trotse bezit van:");
Console.WriteLine(
"- een {0}.", mijnAuto.Merk);
Console.WriteLine(
"- En de Milieusticker van je bolide is {0}." +
Environment.NewLine,
(Kleur)mijnAuto.MilieuSticker);
Console.WriteLine(
"Over de vervuilingsgraad van je auto:" +
Environment.NewLine +
"{0}" + Environment.NewLine,
mijnAuto.Vervuilingsgraad);
}
}