Constructor overloading in C# onder de knie

Ontdek hoe je flexibele klassen in C# ontwerpt door constructors te overloaden – variërend in parameteraantal, types en volgorde – complete met praktische voorbeelden.

Constructor overloading in C# lijkt op method overloading: een klasse kan meerdere constructors declareren die dezelfde naam delen maar verschillen in handtekening. De compiler selecteert de juiste constructor op basis van de argumenten die bij instantiëring van een object worden meegegeven.

• Verschillend aantal parameters
• Verschillende parameter types
• Verschillende parametervolgorde

Voordat je in overloading duikt, zorg dat je basis C#-constructors begrijpt.

1. Variërend in het aantal parameters

Je kunt een constructor overloaden door verschillende aantallen argumenten aan te bieden.

class Car { // Constructor zonder parameters Car() { ... } // Constructor met één parameter Car(string brand) { ... } // Constructor met twee parameters Car(string brand, int price) { ... } }

In deze Car-klas bestaan de drie constructors naast elkaar omdat elke handtekening uniek is. De compiler kiest de passende constructor runtime op basis van het argumentaantal.

Voorbeeld: Overloading op parameteraantal

using System; namespace ConstructorOverload { class Car { // Constructor zonder parameters Car() { Console.WriteLine("Car constructor"); } // Constructor met één parameter Car(string brand) { Console.WriteLine("Car constructor with one parameter"); Console.WriteLine("Brand: " + brand); } static void Main(string[] args) { // Roept constructor zonder parameters aan Car car = new Car(); Console.WriteLine(); // Roept constructor met één parameter aan Car car2 = new Car("Bugatti"); Console.ReadLine(); } } }

Output

Car constructor Car constructor with one parameter Brand: Bugatti

De compiler roept de juiste constructor aan op basis van de meegegeven argumenten.

2. Verschillende parameter types

Constructors kunnen ook overgeladen worden wanneer ze evenveel parameters accepteren maar van verschillende types.

class Car { Car(string brand) { ... } Car(int price) { ... } }

Hier accepteren beide constructors één argument, doch de types – string versus int – differentiëren ze.

Voorbeeld: Overloading op parameter type

using System; namespace ConstructorOverload { class Car { // Constructor met een string Car(string brand) { Console.WriteLine("Brand: " + brand); } // Constructor met een int Car(int price) { Console.WriteLine("Price: " + price); } static void Main(string[] args) { Car car = new Car("Lamborghini"); Console.WriteLine(); Car car2 = new Car(50000); Console.ReadLine(); } } }

Output

Brand: Lamborghini Price: 50000

3. Parametervolgorde wijzigen

Wanneer constructors hetzelfde aantal en types parameters hebben, kun je nog steeds overloaden door hun volgorde te veranderen.

class Car { Car(string brand, int price) { ... } Car(int speed, string color) { ... } }

De handtekeningen verschillen omdat de volgorde van types uniek is.

Voorbeeld: Overloading op parametervolgorde

using System; namespace ConstructorOverload { class Car { // String eerst, dan int Car(string brand, int price) { Console.WriteLine("Brand: " + brand); Console.WriteLine("Price: " + price); } // Int eerst, dan string Car(int speed, string color) { Console.WriteLine("Speed: " + speed + " km/hr"); Console.WriteLine("Color: " + color); } static void Main(string[] args) { Car car = new Car("Bugatti", 50000); Console.WriteLine(); Car car2 = new Car(60, "Red"); Console.ReadLine(); } } }

Output

Brand: Bugatti Price: 50000 Speed: 60 km/hr Color: Red