C#-Konstruktor

In diesem Tutorial lernen wir die C#-Konstruktoren und ihre Typen anhand von Beispielen kennen.

In C# ähnelt ein Konstruktor einer Methode, die aufgerufen wird, wenn ein Objekt der Klasse erstellt wird.

Im Gegensatz zu Methoden ist ein Konstruktor jedoch:

hat denselben Namen wie die Klasse
hat keinen Rückgabetyp

Erstellen Sie einen C#-Konstruktor

So erstellen wir einen Konstruktor in C#

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

}

Hier, Auto() ist ein Konstrukteur. Sie hat denselben Namen wie ihre Klasse.

Aufruf eines Konstruktors

Sobald wir einen Konstruktor erstellt haben, können wir ihn mit new aufrufen Stichwort. Zum Beispiel

new Car();

In C# wird ein Konstruktor aufgerufen, wenn wir versuchen, ein Objekt einer Klasse zu erstellen. Zum Beispiel

Car car1 = new Car();

Hier rufen wir Car() auf -Konstruktor, um ein Objekt car1 zu erstellen . Weitere Informationen zu Objekten finden Sie unter C#-Klassen und -Objekte.

Typen von Konstruktoren

Es gibt die folgenden Arten von Konstruktoren:

Parameterloser Konstruktor
Parametrisierter Konstruktor
Standardkonstruktor

1. Parameterloser Konstruktor

Wenn wir einen Konstruktor ohne Parameter erstellen, wird er als parameterloser Konstruktor bezeichnet. Zum Beispiel

using System;

namespace Constructor {

  class Car {   

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

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

Ausgabe

Car Constructor

Im obigen Beispiel haben wir einen Konstruktor namens Car() erstellt .

new Car();

Wir können einen Konstruktor aufrufen, indem wir eine new hinzufügen Schlüsselwort zum Konstruktornamen.

2. C#-parametrisierter Konstruktor

In C# kann ein Konstruktor auch Parameter akzeptieren. Er wird als parametrisierter Konstruktor bezeichnet. Zum Beispiel

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();
     
    }
  }
}

Ausgabe

Brand: Bugatti
Price: 50000

Im obigen Beispiel haben wir einen Konstruktor namens Car() erstellt . Der Konstruktor benötigt zwei Parameter:theBrand und derPreis .

Beachten Sie die Anweisung,

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

Hier übergeben wir die beiden Werte an den Konstruktor.

Die an den Konstruktor übergebenen Werte werden als Argumente bezeichnet. Wir müssen dieselbe Anzahl und denselben Typ von Werten als Parameter übergeben.

3. Standardkonstruktor

Wenn wir in unserer Klasse keinen Konstruktor definiert haben, erstellt C# automatisch einen Standardkonstruktor mit leerem Code und ohne Parameter. Zum Beispiel

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();
     
    }
  }
}

Ausgabe

Default value of a: 0

Im obigen Beispiel haben wir keinen Konstruktor im Programm erstellt Klasse. Beim Erstellen eines Objekts rufen wir jedoch den Konstruktor auf.

Program p1 = new Program();

Hier erstellt C# automatisch einen Standardkonstruktor. Der Standardkonstruktor initialisiert jede nicht initialisierte Variable mit dem Standardwert.

Daher erhalten wir 0 als Wert von int Variable a .

Hinweis :Im Standardkonstruktor werden alle numerischen Felder mit 0 initialisiert, während String und Objekt mit null initialisiert werden.

4. Konstruktor in C# kopieren

Wir verwenden einen Kopierkonstruktor, um ein Objekt zu erstellen, indem wir Daten von einem anderen Objekt kopieren. Zum Beispiel

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();
     
    }
  }
}

Ausgabe

Brand of car1: Bugatti
Brand of car2: Bugatti

Im obigen Programm haben wir einen Kopierkonstruktor verwendet.

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

Hier akzeptiert dieser Konstruktor ein Objekt von Car als seinen Parameter. Beim Erstellen von car2 Objekt haben wir das car1 passiert Objekt als Argument für den Kopierkonstruktor.

Car car2 = new Car(car1);

Innerhalb des Kopierkonstruktors haben wir den Wert der Marke zugewiesen für auto1 der Marke widersprechen Variable für car2 Objekt. Daher haben beide Objekte den gleichen Wert der Marke .

5. Privater Konstrukteur

Wir können einen privaten Konstruktor mit private erstellen Zugriffsbezeichner. Dies wird in C# als privater Konstruktor bezeichnet.

Sobald der Konstruktor als privat deklariert ist, können wir keine Objekte der Klasse in anderen Klassen erstellen.

Beispiel 1:Privater Konstruktor

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();
    }
  }
}

Im obigen Beispiel haben wir einen privaten Konstruktor Car() erstellt . Da auf private Member außerhalb der Klasse nicht zugegriffen wird, wenn wir versuchen, ein Objekt von Car zu erstellen

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

wir erhalten eine Fehlermeldung

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

Hinweis :Wenn ein Konstruktor privat ist, können wir keine Objekte der Klasse erstellen. Daher sollten alle Felder und Methoden der Klasse als statisch deklariert werden, damit sie über den Klassennamen angesprochen werden können.

6. Statischer C#-Konstruktor

In C# können wir unseren Konstruktor auch statisch machen. Wir verwenden den static -Schlüsselwort zum Erstellen eines statischen Konstruktors. Zum Beispiel

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();
    }
  }
}

Im obigen Beispiel haben wir einen statischen Konstruktor erstellt.

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

Wir können einen statischen Konstruktor nicht direkt aufrufen. Wenn wir jedoch einen regulären Konstruktor aufrufen, wird der statische Konstruktor automatisch aufgerufen.

Car car1 = new Car();

Hier rufen wir Car() auf Konstrukteur. Wie Sie sehen, wird neben dem regulären Konstruktor auch der statische Konstruktor aufgerufen.

Ausgabe

Static Constructor
Default Constructor
Default Constructor

Der statische Konstruktor wird nur einmal während der Ausführung des Programms aufgerufen. Deshalb wird beim erneuten Aufruf des Konstruktors nur der reguläre Konstruktor aufgerufen.

Hinweis :Wir können nur einen statischen Konstruktor in einer Klasse haben. Es darf keine Parameter oder Zugriffsmodifikatoren haben.

Überladen des C#-Konstruktors

In C# können wir zwei oder mehr Konstruktoren in einer Klasse erstellen. Dies wird als Konstruktorüberladung bezeichnet. Zum Beispiel

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();
    }
  }
}

Ausgabe

Car constructor

Car constructor with one parameter
Brand: Bugatti

Im obigen Beispiel haben wir Car überladen Konstruktor:

ein Konstruktor hat einen Parameter
ein anderer hat zwei Parameter

Basierend auf der Nummer des beim Konstruktoraufruf übergebenen Arguments wird der entsprechende Konstruktor aufgerufen.

Hier,

Objekt Auto - ruft den Konstruktor mit einem Parameter auf
Objekt car2 - ruft Konstruktor mit zwei Parametern auf

Weitere Informationen finden Sie unter Überladen von C#-Konstruktoren.

C#-Variablenbereich C# dieses Schlüsselwort

C Sprache