Instanzkonstruktoren (C#-Programmierhandbuch)Instance Constructors (C# Programming Guide)

Instanzkonstruktoren werden zum Erstellen und Initialisieren von Instanzmembervariablen verwendet, wenn Sie die Ausdruck new verwenden, um ein Objekt einer Klasse zu erstellen.Instance constructors are used to create and initialize any instance member variables when you use the new expression to create an object of a class. Sie müssen einen statischen Konstruktor definieren um eine statische Klasse oder eine statische Variable in einer nicht statischen Klasse zu initialisieren.To initialize a static class, or static variables in a non-static class, you must define a static constructor. Weitere Informationen finden Sie unter Statische Konstruktoren.For more information, see Static Constructors.

Im folgenden Beispiel wird die Verwendung eines Instanzkonstruktors veranschaulicht:The following example shows an instance constructor:

class CoOrds
{
    public int x, y;

    // constructor
    public CoOrds()
    {
        x = 0;
        y = 0;
    }
}

Hinweis

Der Deutlichkeit halber enthält diese Klasse öffentliche Felder.For clarity, this class contains public fields. Das Verwenden von öffentlichen Felder wird beim Programmieren nicht empfohlen, da so jede Methode im Programm uneingeschränkten und ungeprüften Zugriff auf das Innenleben eines Objekts erhält.The use of public fields is not a recommended programming practice because it allows any method anywhere in a program unrestricted and unverified access to an object's inner workings. Datenmember sollten im Allgemeinen privat sein. Außerdem sollte auf sie nur über Klassenmethoden und Eigenschaften zugegriffen werden.Data members should generally be private, and should be accessed only through class methods and properties.

Dieser Instanzkonstruktor wird aufgerufen, wenn ein Objekt basierend auf der CoOrds-Klasse erstellt wird.This instance constructor is called whenever an object based on the CoOrds class is created. Ein derartiger Konstruktor, der keine Argumente akzeptiert, wird als Standardkonstruktor bezeichnet.A constructor like this one, which takes no arguments, is called a default constructor. Es kann jedoch oft hilfreich sein, weitere Konstruktoren bereitzustellen.However, it is often useful to provide additional constructors. Sie können beispielsweise einen Konstruktor in die CoOrds-Klasse einfügen, mit dem Sie die Anfangswerte der Datenmember angeben können:For example, we can add a constructor to the CoOrds class that allows us to specify the initial values for the data members:

// A constructor with two arguments:
public CoOrds(int x, int y)
{
    this.x = x;
    this.y = y;
}

Damit können CoOrd-Objekte mit Standard- oder spezifischen Anfangswerten erstellt werden. Dies geschieht wie folgt:This allows CoOrd objects to be created with default or specific initial values, like this:

CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);

Wenn eine Klasse über keinen Konstruktor verfügt, wird automatisch ein Standardkonstruktor generiert, und die Objektfelder werden mit Standardwerte initialisiert.If a class does not have a constructor, a default constructor is automatically generated and default values are used to initialize the object fields. Ein int-Objekt wird beispielsweise auf 0 (null) initialisiert.For example, an int is initialized to 0. Weitere Informationen zu Standardwerten finden Sie unter Tabelle für Standardwerte.For more information on default values, see Default Values Table. Da der Standardkonstruktor der CoOrds-Klasse alle Datenmember auf 0 (null) initialisiert, kann er komplett entfernt werden, ohne dass die Arbeitsweise der Klasse geändert wird.Therefore, because the CoOrds class default constructor initializes all data members to zero, it can be removed altogether without changing how the class works. Unter Beispiel 1 weiter unten in diesem Thema finden Sie ein vollständiges Beispiel mit mehreren Konstruktoren. Unter Beispiel 2 finden Sie ein Beispiel für einen automatisch generierten Konstruktor.A complete example using multiple constructors is provided in Example 1 later in this topic, and an example of an automatically generated constructor is provided in Example 2.

Instanzkonstruktoren können ebenfalls dazu verwendet werden, die Instanzkonstruktoren von Basisklassen aufzurufen.Instance constructors can also be used to call the instance constructors of base classes. Der Klassenkonstruktor kann den Konstruktor der Basisklasse mit dem Initialisierer wie folgt aufrufen:The class constructor can invoke the constructor of the base class through the initializer, as follows:

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {
    }
}

In diesem Beispiel übergibt die Circle-Klasse die Werte des Radius und der Höhe an den Konstruktor, der von Shape bereitgestellt wird, von dem Circle abgeleitet wird.In this example, the Circle class passes values representing radius and height to the constructor provided by Shape from which Circle is derived. Unter Beispiel 3 in diesem Thema finden Sie ein vollständiges Beispiel mit Shape und Circle.A complete example using Shape and Circle appears in this topic as Example 3.

Beispiel 1Example 1

Das folgende Beispiel veranschaulicht eine Klasse mit zwei Klassenkonstruktoren. Einer der Konstruktoren hat kein Argument und der andere verfügt über zwei.The following example demonstrates a class with two class constructors, one without arguments and one with two arguments.

class CoOrds
{
    public int x, y;

    // Default constructor:
    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    // A constructor with two arguments:
    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    // Override the ToString method:
    public override string ToString()
    {
        return (String.Format("({0},{1})", x, y));
    }
}

class MainClass
{
    static void Main()
    {
        CoOrds p1 = new CoOrds();
        CoOrds p2 = new CoOrds(5, 3);

        // Display the results using the overriden ToString method:
        Console.WriteLine("CoOrds #1 at {0}", p1);
        Console.WriteLine("CoOrds #2 at {0}", p2);
        Console.ReadKey();
    }
}
/* Output:
 CoOrds #1 at (0,0)
 CoOrds #2 at (5,3)        
*/

Beispiel 2Example 2

In diesem Beispiel hat die Person-Klasse keine Konstruktoren. In einem solchen Fall wird automatisch ein Standardkonstruktor bereitgestellt, und die Felder werden auf ihre Standardwerte initialisiert.In this example, the class Person does not have any constructors, in which case, a default constructor is automatically provided and the fields are initialized to their default values.

public class Person
{
    public int age;
    public string name;
}

class TestPerson
{
    static void Main()
    {
        Person person = new Person();

        Console.WriteLine("Name: {0}, Age: {1}", person.name, person.age);
        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output:  Name: , Age: 0

Beachten Sie, dass der Standardwert von age 0 ist, und der Standardwert von name ist null.Notice that the default value of age is 0 and the default value of name is null. Weitere Informationen zu Standardwerten finden Sie unter Tabelle für Standardwerte.For more information on default values, see Default Values Table.

Beispiel 3Example 3

Im folgenden Beispiel wird die Verwendung vom Basisklasseninitialisierer veranschaulicht.The following example demonstrates using the base class initializer. Die Circle-Klasse wird von der allgemeinen Klasse Shape abgeleitet, und die Cylinder-Klasse wird von der Circle-Klasse abgeleitet.The Circle class is derived from the general class Shape, and the Cylinder class is derived from the Circle class. Der Konstruktor von jeder abgeleiteten Klasse verwendet deren Basisklasseninitialisierer.The constructor on each derived class is using its base class initializer.

abstract class Shape
{
    public const double pi = Math.PI;
    protected double x, y;

    public Shape(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public abstract double Area();
}

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {
    }
    public override double Area()
    {
        return pi * x * x;
    }
}

class Cylinder : Circle
{
    public Cylinder(double radius, double height)
        : base(radius)
    {
        y = height;
    }

    public override double Area()
    {
        return (2 * base.Area()) + (2 * pi * x * y);
    }
}

class TestShapes
{
    static void Main()
    {
        double radius = 2.5;
        double height = 3.0;

        Circle ring = new Circle(radius);
        Cylinder tube = new Cylinder(radius, height);

        Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
        Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area of the circle = 19.63
    Area of the cylinder = 86.39
*/

Weitere Beispiele für das Aufrufen des Basisklassenkonstruktors finden Sie unter virtual, override und base.For more examples on invoking the base class constructors, see virtual, override, and base.

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Klassen und StrukturenClasses and Structs
KonstruktorenConstructors
FinalizerFinalizers
staticstatic