C#-constructor

In deze zelfstudie leren we over de C#-constructors en hun typen aan de hand van voorbeelden.

In C# is een constructor vergelijkbaar met een methode die wordt aangeroepen wanneer een object van de klasse wordt gemaakt.

Echter, in tegenstelling tot methoden, is een constructor:

• heeft dezelfde naam als die van de klas
• heeft geen retourtype

---

Maak een C#-constructor

Zo maken we een constructor in C#

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

}

Hier, Auto() is een constructeur. Het heeft dezelfde naam als zijn klasse.

Bel een constructeur

Zodra we een constructor hebben gemaakt, kunnen we deze aanroepen met de new trefwoord. Bijvoorbeeld,

new Car();

In C# wordt een constructor aangeroepen wanneer we proberen een object van een klasse te maken. Bijvoorbeeld,

Car car1 = new Car();

Hier noemen we de Car() constructor om een ​​object car1 te maken . Ga voor meer informatie over objecten naar C#-klasse en objecten.

---

Typen constructeurs

Er zijn de volgende typen constructeurs:

• Parameterloze constructor
• Geparameteriseerde constructor
• Standaardconstructor

---

1. Parameterloze constructor

Wanneer we een constructor zonder parameters maken, staat deze bekend als een parameterloze constructor. Bijvoorbeeld,

using System;

namespace Constructor {

  class Car {   

    // parameterless constructor
    Car() {
      Console.WriteLine("Car Constructor");
    }
 
    static void Main(string[] args) {

      // call constructor
      new Car();
      Console.ReadLine();
     
    }
  }
}

Uitvoer

Car Constructor

In het bovenstaande voorbeeld hebben we een constructor gemaakt met de naam Car() .

new Car();

We kunnen een constructor aanroepen door een new . toe te voegen trefwoord naar de naam van de constructor.

---

2. C# geparametriseerde constructor

In C# kan een constructor ook parameters accepteren. Het wordt een geparametriseerde constructor genoemd. Bijvoorbeeld,

using System;

namespace Constructor {

  class Car {   

    string brand;
    int price;

    // parameterized constructor
    Car(string theBrand, int thePrice) {

      brand = theBrand;
      price = thePrice;
    }
  
    static void Main(string[] args) {

      // call parameterized constructor
      Car car1 = new Car("Bugatti", 50000);

      Console.WriteLine("Brand: " + car1.brand);
      Console.WriteLine("Price: " + car1.price);
      Console.ReadLine();
     
    }
  }
}

Uitvoer

Brand: Bugatti
Price: 50000

In het bovenstaande voorbeeld hebben we een constructor gemaakt met de naam Car() . De constructor heeft twee parameters:theBrand en thePrice .

Let op de verklaring,

Car car1 = new Car("Bugatti", 50000);

Hier geven we de twee waarden door aan de constructor.

De waarden die aan de constructor worden doorgegeven, worden argumenten genoemd. We moeten hetzelfde aantal en type waarden doorgeven als parameters.

---

3. Standaardconstructor

Als we geen constructor in onze klasse hebben gedefinieerd, maakt de C# automatisch een standaardconstructor met een lege code en zonder parameters. Bijvoorbeeld,

using System;

namespace Constructor {

  class Program {  

    int a;

    static void Main(string[] args) {

      // call default constructor
      Program p1 = new Program();

      Console.WriteLine("Default value of a: " + p1.a);
      Console.ReadLine();
     
    }
  }
}

Uitvoer

Default value of a: 0

In het bovenstaande voorbeeld hebben we geen enkele constructor gemaakt in het Programma klas. Tijdens het maken van een object roepen we echter de constructor aan.

Program p1 = new Program();

Hier maakt C# automatisch een standaardconstructor aan. De standaardconstructor initialiseert elke niet-geïnitialiseerde variabele met de standaardwaarde.

Daarom krijgen we 0 als de waarde van de int variabele a .

Opmerking :In de standaardconstructor worden alle numerieke velden geïnitialiseerd op 0, terwijl tekenreeks en object worden geïnitialiseerd als null.

---

4. Constructor kopiëren in C#

We gebruiken een kopieerconstructor om een ​​object te maken door gegevens van een ander object te kopiëren. Bijvoorbeeld,

using System;

namespace Constructor {

  class Car {  
    string brand;

    // constructor
    Car (string theBrand) {
      brand = theBrand;
    }

    // copy constructor
    Car(Car c1) {
      brand = c1.brand;
    }

    static void Main(string[] args) {
      // call constructor
      Car car1 = new Car("Bugatti");

      Console.WriteLine("Brand of car1: " + car1.brand);

      // call the copy constructor
      Car car2 = new Car(car1);
      Console.WriteLine("Brand of car2: " + car2.brand);

      Console.ReadLine();
     
    }
  }
}

Uitvoer

Brand of car1: Bugatti
Brand of car2: Bugatti

In het bovenstaande programma hebben we een kopieerconstructor gebruikt.

Car(Car c1) {
  brand = c1.brand;
}

Hier accepteert deze constructor een object van Car als zijn parameter. Dus bij het maken van de car2 object, zijn we geslaagd voor de car1 object als argument voor de kopieerconstructor.

Car car2 = new Car(car1);

Binnen de kopieerconstructor hebben we de waarde van het merk . toegewezen voor auto1 bezwaar maken tegen het merk variabele voor car2 object. Beide objecten hebben dus dezelfde waarde van het merk .

---

5. Particuliere aannemer

We kunnen een privéconstructor maken met behulp van de private toegangsspecificatie. Dit staat bekend als een private constructor in C#.

Als de constructor eenmaal privé is verklaard, kunnen we geen objecten van de klasse in andere klassen maken.

Voorbeeld 1:privéconstructeur

using System;

namespace Constructor {

  class Car {  
  
   // private constructor
   private Car () {
    Console.WriteLine("Private Constructor");    
    }
  }
    
    class CarDrive {

      static void Main(string[] args) {

      // call private constructor
      Car car1 = new Car();
      Console.ReadLine();
    }
  }
}

In het bovenstaande voorbeeld hebben we een privéconstructor gemaakt Car() . Aangezien privéleden niet toegankelijk zijn buiten de klas, wanneer we proberen een object van Car te maken,

// inside CarDrive class
Car car1 = new Car();

we krijgen een foutmelding

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

Opmerking :Als een constructor privé is, kunnen we geen objecten van de klasse maken. Daarom moeten alle velden en methoden van de klasse statisch worden verklaard, zodat ze toegankelijk zijn met de klassenaam.

---

6. C# Statische Constructor

In C# kunnen we onze constructor ook statisch maken. We gebruiken de static trefwoord om een ​​statische constructor te maken. Bijvoorbeeld,

using System;

namespace Constructor {

  class Car {  
  
   // static constructor
   static Car () {
    Console.WriteLine("Static Constructor");    
   }

    // parameterless constructor
    Car() {
     Console.WriteLine("Default Constructor");
   } 

    static void Main(string[] args) {

      // call parameterless constructor
      Car car1 = new Car();

      // call parameterless constructor again
      Car car2 = new Car();

      Console.ReadLine();
    }
  }
}

In het bovenstaande voorbeeld hebben we een statische constructor gemaakt.

static Car () {
  Console.WriteLine("Static Constructor");    
}

We kunnen een statische constructor niet rechtstreeks aanroepen. Wanneer we echter een reguliere constructor aanroepen, wordt de statische constructor automatisch aangeroepen.

Car car1 = new Car();

Hier noemen we de Car() aannemer. Je kunt zien dat de statische constructor ook samen met de reguliere constructor wordt aangeroepen.

Uitvoer

Static Constructor
Default Constructor
Default Constructor

De statische constructor wordt slechts één keer aangeroepen tijdens de uitvoering van het programma. Dat is de reden waarom wanneer we de constructor opnieuw aanroepen, alleen de reguliere constructor wordt aangeroepen.

Opmerking :We kunnen slechts één statische constructor in een klasse hebben. Het kan geen parameters of toegangsmodificaties hebben.

---

C# Constructor Overload

In C# kunnen we twee of meer constructors in een klasse maken. Het staat bekend als constructor overloading. Bijvoorbeeld,

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with no parameter
    Car() {
      Console.WriteLine("Car constructor");
    }
     
    // constructor with one parameter
    Car(string brand) {
      Console.WriteLine("Car constructor with one parameter");
      Console.WriteLine("Brand: " + brand);
    }

    static void Main(string[] args) {

      // call constructor with no parameter
      Car car = new Car();

      Console.WriteLine();

      // call constructor with parameter
      Car car2 =  new Car("Bugatti");
     
      Console.ReadLine();
    }
  }
}

Uitvoer

Car constructor

Car constructor with one parameter
Brand: Bugatti

In het bovenstaande voorbeeld hebben we de Auto . overbelast constructeur:

• één constructor heeft één parameter
• een andere heeft twee parameters

Op basis van het nummer van het argument dat is doorgegeven tijdens de constructor-aanroep, wordt de corresponderende constructor aangeroepen.

Hier,

• Object auto - roept constructor aan met één parameter
• Object car2 - roept constructor aan met twee parameters

Ga voor meer informatie naar C# Constructor Overloading.