C# Constructors

Ontdek hoe constructors objecten initialiseren in C#, alle constructor types, patronen en best practices.

In C# is een constructor een speciale methode die automatisch aangeroepen wordt wanneer een nieuwe instantie van een klasse wordt aangemaakt. In tegenstelling tot reguliere methodes:

• delen ze dezelfde naam als de klasse
• retourneren ze geen waarde

Een C# Constructor Aanmaken

Definieer een constructor binnen een klasse door de klassenaam te matchen:

class Car {
    // constructor
    Car() {
        // initialisatie code
    }
}

Hier is Car() de constructor. Het wordt aangeroepen met het new trefwoord:

new Car();

Bijvoorbeeld:

Car car1 = new Car();

Zie ook: C# Class and Objects.

Types van Constructors

Typische constructor categorieën zijn:

• Parameterloze (default) constructor
• Geparameteriseerde constructor
• Copy constructor
• Private constructor
• Static constructor

1. Parameterloze Constructor

Een constructor zonder parameters heet een parameterloze of default constructor. Voorbeeld:

using System;
namespace ConstructorDemo {
    class Car {
        // parameterloze constructor
        Car() {
            Console.WriteLine("Car Constructor");
        }
        static void Main(string[] args) {
            new Car();
            Console.ReadLine();
        }
    }
}

Output

Car Constructor

2. Geparameteriseerde Constructor

Constructors kunnen argumenten accepteren om instantievelden te initialiseren:

using System;
namespace ConstructorDemo {
    class Car {
        string brand;
        int price;
        // geparameteriseerde constructor
        Car(string theBrand, int thePrice) {
            brand = theBrand;
            price = thePrice;
        }
        static void Main(string[] args) {
            Car car1 = new Car("Bugatti", 50000);
            Console.WriteLine("Merk: " + car1.brand);
            Console.WriteLine("Prijs: " + car1.price);
            Console.ReadLine();
        }
    }
}

Output

Merk: Bugatti
Prijs: 50000

3. Default Constructor

Als u een constructor weglaat, levert de compiler een impliciete parameterloze constructor die velden initialiseert op hun default waarden. Voorbeeld:

using System;
namespace ConstructorDemo {
    class Program {
        int a;
        static void Main(string[] args) {
            Program p1 = new Program();
            Console.WriteLine("Default waarde van a: " + p1.a);
            Console.ReadLine();
        }
    }
}

Output

Default waarde van a: 0

Numerieke velden default naar 0, strings en objecten naar null.

4. Copy Constructor

Een copy constructor creëert een nieuwe instantie door een ander object's state te kopiëren:

using System;
namespace ConstructorDemo {
    class Car {
        string brand;
        // primaire constructor
        Car(string theBrand) {
            brand = theBrand;
        }
        // copy constructor
        Car(Car c1) {
            brand = c1.brand;
        }
        static void Main(string[] args) {
            Car car1 = new Car("Bugatti");
            Console.WriteLine("Merk van car1: " + car1.brand);
            Car car2 = new Car(car1);
            Console.WriteLine("Merk van car2: " + car2.brand);
            Console.ReadLine();
        }
    }
}

Output

Merk van car1: Bugatti
Merk van car2: Bugatti

5. Private Constructor

Een constructor markeren als private voorkomt externe instantiëring, nuttig voor singleton patronen of utility klassen.

Voorbeeld

using System;
namespace ConstructorDemo {
    class Car {
        private Car() {
            Console.WriteLine("Private Constructor");
        }
    }
    class CarDrive {
        static void Main(string[] args) {
            // Car car1 = new Car(); // compileerfout
            Console.ReadLine();
        }
    }
}

De fout:

error CS0122: 'Car.Car()' is inaccessible due to its protection level

Let op: Wanneer een constructor private is, moeten alle klasselidmaat statisch zijn om toegang via de klassenaam toe te staan.

6. Static Constructor

Een static constructor draait één keer per type, voordat elke instantie of static lid wordt benaderd. Het kan niet direct aangeroepen worden en mag geen parameters hebben.

using System;
namespace ConstructorDemo {
    class Car {
        static Car() {
            Console.WriteLine("Static Constructor");
        }
        Car() {
            Console.WriteLine("Default Constructor");
        }
        static void Main(string[] args) {
            Car car1 = new Car();
            Car car2 = new Car();
            Console.ReadLine();
        }
    }
}

Output

Static Constructor
Default Constructor
Default Constructor

Let op: Slechts één static constructor per klasse; het kan geen parameters of access modifiers hebben.

C# Constructor Overloading

Definieer meerdere constructors met verschillende parameterlijsten voor flexibele objectcreatie. Voorbeeld:

using System;
namespace ConstructorOverloadDemo {
    class Car {
        Car() {
            Console.WriteLine("Car constructor");
        }
        Car(string brand) {
            Console.WriteLine("Car constructor met één parameter");
            Console.WriteLine("Merk: " + brand);
        }
        static void Main(string[] args) {
            Car car = new Car();
            Console.WriteLine();
            Car car2 = new Car("Bugatti");
            Console.ReadLine();
        }
    }
}

Output

Car constructor
Car constructor met één parameter
Merk: Bugatti

De compiler selecteert de passende constructor op basis van argumentaantal en types. Meer leren op C# Constructor Overloading.