C# Konstruktoren: Typen, Beispiele und fortgeschrittene Muster

C# Konstruktoren

Entdecken Sie, wie Konstruktoren Objekte in C# initialisieren, alle Konstruktortypen, Muster und Best Practices abdeckend.

In C# ist ein Konstruktor eine spezielle Methode, die automatisch aufgerufen wird, wenn eine neue Instanz einer Klasse erstellt wird. Im Gegensatz zu regulären Methoden:

• teilen sie den gleichen Namen wie die Klasse
• geben sie keinen Wert zurück

---

C# Konstruktor erstellen

Definieren Sie einen Konstruktor innerhalb einer Klasse, indem Sie den Klassennamen verwenden:

class Car {
    // Konstruktor
    Car() {
        // Initialisierungscode
    }
}

Hier ist Car() der Konstruktor. Er wird mit dem new Schlüsselwort aufgerufen:

new Car();

Zum Beispiel:

Car car1 = new Car();

Siehe auch: C# Klasse und Objekte.

---

Konstruktortypen

Typische Konstruktor-Kategorien umfassen:

• Parameterloser (Standard-) Konstruktor
• Parameterisierter Konstruktor
• Kopierkonstruktor
• Privater Konstruktor
• Statischer Konstruktor

---

1. Parameterloser Konstruktor

Ein Konstruktor ohne Parameter wird parameterloser oder Standardkonstruktor genannt. Beispiel:

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

Ausgabe

Car Constructor

---

2. Parameterisierter Konstruktor

Konstruktoren können Argumente akzeptieren, um Instanzfelder zu initialisieren:

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

Ausgabe

Brand: Bugatti Price: 50000

---

3. Standardkonstruktor

Wenn Sie keinen Konstruktor angeben, stellt der Compiler einen impliziten parameterlosen Konstruktor bereit, der Felder auf ihre Standardwerte initialisiert. Beispiel:

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

Ausgabe

Default value of a: 0

Numerische Felder erhalten standardmäßig 0, Strings und Objekte null.

---

4. Kopierkonstruktor

Ein Kopierkonstruktor erstellt eine neue Instanz, indem er den Zustand eines anderen Objekts kopiert:

using System;
namespace ConstructorDemo {
    class Car {
        string brand;
        // primärer Konstruktor
        Car(string theBrand) {
            brand = theBrand;
        }
        // Kopierkonstruktor
        Car(Car c1) {
            brand = c1.brand;
        }
        static void Main(string[] args) {
            Car car1 = new Car("Bugatti");
            Console.WriteLine("Brand of car1: " + car1.brand);
            Car car2 = new Car(car1);
            Console.WriteLine("Brand of car2: " + car2.brand);
            Console.ReadLine();
        }
    }
}

Ausgabe

Brand of car1: Bugatti Brand of car2: Bugatti

---

5. Privater Konstruktor

Einen Konstruktor als private zu kennzeichnen, verhindert externe Instanziierung, nützlich für Singleton-Muster oder Utility-Klassen.

Beispiel

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

Der Fehler:

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

Hinweis: Wenn ein Konstruktor privat ist, sollten alle Klassenmember statisch sein, um Zugriff über den Klassennamen zu ermöglichen.

---

6. Statischer Konstruktor

Ein statischer Konstruktor läuft einmal pro Typ, bevor eine Instanz oder ein statisches Member zugegriffen wird. Er kann nicht direkt aufgerufen werden und darf keine Parameter haben.

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

Ausgabe

Static Constructor Default Constructor Default Constructor

Hinweis: Nur ein statischer Konstruktor pro Klasse; er kann keine Parameter oder Zugriffsmodifizierer haben.

---

C# Konstruktorüberladung

Definieren Sie mehrere Konstruktoren mit unterschiedlichen Parameterlisten für flexible Objekterstellung. Beispiel:

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

Ausgabe

Car constructor
Car constructor with one parameter
Brand: Bugatti

Der Compiler wählt den passenden Konstruktor basierend auf Argumentanzahl und -typen. Mehr unter C# Konstruktorüberladung.