Konstruktorentwurf
Aktualisiert: November 2007
Konstruktoren sind besondere Methoden zum Initialisieren von Typen und Erstellen von Instanzen von Typen. Mit einem Typkonstruktor werden statische Daten in einem Typ initialisiert. Ein Typkonstruktor wird von der Common Language Runtime (CLR) aufgerufen, bevor Instanzen des Typs erstellt werden. Typkonstruktoren sind static (Shared in Visual Basic) und können keine Parameter akzeptieren. Mit einem Instanzkonstruktor werden Instanzen eines Typs erstellt. Instanzkonstruktoren können Parameter akzeptieren, müssen dies jedoch nicht. Ein Instanzkonstruktor ohne Parameter wird als Standardkonstruktor bezeichnet.
Die folgenden Richtlinien beschreiben die empfohlenen Vorgehensweisen zum Erstellen von Konstruktoren.
Legen Sie Haupteigenschaften über Konstruktorparameter fest.
Das Festlegen von Eigenschaften mit dem Konstruktor sollte dem direkten Festlegen der Eigenschaften entsprechen. Im folgenden Codebeispiel wird eine EmployeeRecord-Klasse veranschaulicht, die durch den Aufruf eines Konstruktors oder durch direktes Festlegen von Eigenschaften initialisiert werden kann. Die EmployeeManagerConstructor-Klasse veranschaulicht das Initialisieren eines EmployeeRecord-Objekts mithilfe des Konstruktors. Die EmployeeManagerProperties-Klasse veranschaulicht das Initialisieren eines EmployeeRecord-Objekts mithilfe von Eigenschaften. Die Tester-Klasse veranschaulicht, dass die Objekte unabhängig vom verwendeten Verfahren denselben Zustand aufweisen.
Imports System
Imports System.Collections.ObjectModel
namespace Examples.DesignGuidelines.Constructors
' This Class can get its data either by setting
' properties or by passing the data to its constructor.
Public Class EmployeeRecord
private employeeIdValue as Integer
private departmentValue as Integer
Public Sub New()
End Sub
Public Sub New(id as Integer, department as Integer)
Me.employeeIdValue = id
Me.departmentValue = department
End Sub
Public Property Department as Integer
Get
Return departmentValue
End Get
Set
departmentValue = value
End Set
End Property
Public Property EmployeeId as Integer
Get
Return employeeIdValue
End Get
Set
employeeIdValue = value
End Set
End Property
Public Sub DisplayData()
Console.WriteLine("{0} {1}", EmployeeId, Department)
End Sub
End Class
' This Class creates Employee records by passing
' argumemnts to the constructor.
Public Class EmployeeManagerConstructor
Dim employees as Collection(Of EmployeeRecord) = _
new Collection(Of EmployeeRecord)()
Public Sub AddEmployee(employeeId as Integer, department as Integer)
Dim record as EmployeeRecord = new EmployeeRecord(employeeId, department)
employees.Add(record)
record.DisplayData()
End Sub
End Class
' This Class creates Employee records by setting properties.
Public Class EmployeeManagerProperties
Dim employees as Collection(Of EmployeeRecord)= _
new Collection(Of EmployeeRecord)()
Public Sub AddEmployee(employeeId as Integer, department as Integer)
Dim record as EmployeeRecord = new EmployeeRecord()
record.EmployeeId = employeeId
record.Department = department
employees.Add(record)
record.DisplayData()
End Sub
End Class
Public Class Tester
' The following method creates objects with the same state
' using the two different approaches.
Public Shared Sub Main()
Dim byConstructor as EmployeeManagerConstructor = _
new EmployeeManagerConstructor()
byConstructor.AddEmployee(102, 102)
Dim byProperties as EmployeeManagerProperties = _
new EmployeeManagerProperties()
byProperties.AddEmployee(102, 102)
End Sub
End Class
End Namespace
using System;
using System.Collections.ObjectModel;
namespace Examples.DesignGuidelines.Constructors
{
// This class can get its data either by setting
// properties or by passing the data to its constructor.
public class EmployeeRecord
{
private int employeeId;
private int department;
public EmployeeRecord()
{
}
public EmployeeRecord(int id, int department)
{
this.employeeId = id;
this.department = department;
}
public int Department
{
get {return department;}
set {department = value;}
}
public int EmployeeId
{
get {return employeeId;}
set {employeeId = value;}
}
public void DisplayData()
{
Console.WriteLine("{0} {1}", EmployeeId, Department);
}
}
// This class creates Employee records by passing
// argumemnts to the constructor.
public class EmployeeManagerConstructor
{
Collection<EmployeeRecord > employees = new Collection<EmployeeRecord>();
public void AddEmployee(int employeeId, int department)
{
EmployeeRecord record = new EmployeeRecord(employeeId, department);
employees.Add(record);
record.DisplayData();
}
}
// This class creates Employee records by setting properties.
public class EmployeeManagerProperties
{
Collection<EmployeeRecord > employees = new Collection<EmployeeRecord>();
public void AddEmployee(int employeeId, int department)
{
EmployeeRecord record = new EmployeeRecord();
record.EmployeeId = employeeId;
record.Department = department;
employees.Add(record);
record.DisplayData();
}
}
public class Tester
{
// The following method creates objects with the same state
// using the two different approaches.
public static void Main()
{
EmployeeManagerConstructor byConstructor =
new EmployeeManagerConstructor();
byConstructor.AddEmployee(102, 102);
EmployeeManagerProperties byProperties =
new EmployeeManagerProperties();
byProperties.AddEmployee(102, 102);
}
}
}
Beachten Sie, dass in diesen Beispielen und in einer gut entworfenen Bibliothek mit beiden Verfahren Objekte erstellt werden, die denselben Zustand aufweisen. Welche Vorgehensweise ein Entwickler bevorzugt, ist ohne Belang.
Verwenden Sie denselben Namen für Konstruktorparameter und eine Eigenschaft, wenn die Konstruktorparameter lediglich zum Festlegen der Eigenschaft verwendet werden. Diese Parameter und die Eigenschaften sollten sich nur durch die Groß-/Kleinschreibung unterscheiden.
Diese Richtlinie wird im vorherigen Beispiel veranschaulicht.
Lösen Sie ggf. Ausnahmen von Instanzkonstruktoren aus.
Konstruktoren sollten Ausnahmen wie jede Methode auslösen und behandeln. Insbesondere sollte ein Konstruktor keine Ausnahmen abfangen und verbergen, die er nicht behandeln kann. Weitere Informationen über Ausnahmen finden Sie unter Entwurfsrichtlinien für Ausnahmen.
Deklarieren Sie den öffentlichen Standardkonstruktor in Klassen explizit, sofern ein solcher Konstruktor erforderlich ist.
Die empfohlene Vorgehensweise ist das explizite Definieren eines Standardkonstruktors, wenn die Klasse dies unterstützt. Obwohl einige Compiler der Klasse automatisch einen Standardkonstruktor hinzufügen, wird die Codeverwaltung durch das explizite Hinzufügen des Standardkonstruktors vereinfacht. Hierdurch wird außerdem sichergestellt, dass der Standardkonstruktor definiert bleibt, selbst wenn er vom Compiler nicht mehr ausgegeben wird, weil Sie einen Konstruktor hinzufügen, der Parameter akzeptiert.
Vermeiden Sie Standardkonstruktoren für Strukturen.
Viele Compiler, z. B. der C#-Compiler, unterstützen keine parameterlosen Konstruktoren für Strukturen.
Rufen Sie in den Konstruktoren keine virtuellen Member für ein Objekt auf.
Der Aufruf eines virtuellen Members bewirkt, dass die Überschreibung mit den meisten Ableitungen aufgerufen wird, unabhängig davon, ob der Konstruktor für den Typ aufgerufen wurde, der die Überschreibung mit den meisten Ableitungen definiert. Dieses Problem wird im folgenden Codebeispiel veranschaulicht. Bei der Ausführung des Basisklassenkonstruktors ruft dieser den Member der abgeleiteten Klasse auf, obwohl der Konstruktor der abgeleiteten Klasse nicht aufgerufen wurde. In diesem Beispiel wird BadBaseClass ausgegeben, um zu zeigen, dass das state-Feld nicht vom DerivedFromBad-Konstruktor aktualisiert wurde.
Imports System
Namespace Examples.DesignGuidelines.MemberDesign
Public Class BadBaseClass
Protected state as String
Public Sub New()
state = "BadBaseClass"
SetState()
End Sub
Public Overridable Sub SetState()
End Sub
End Class
Public Class DerivedFromBad
Inherits BadBaseClass
Public Sub New()
state = "DerivedFromBad "
End Sub
Public Overrides Sub SetState()
Console.WriteLine(state)
End Sub
End Class
Public Class tester
Public Shared Sub Main()
Dim b as DerivedFromBad = new DerivedFromBad()
End Sub
End Class
End Namespace
using System;
namespace Examples.DesignGuidelines.MemberDesign
{
public class BadBaseClass
{
protected string state;
public BadBaseClass()
{
state = "BadBaseClass";
SetState();
}
public virtual void SetState()
{
}
}
public class DerivedFromBad : BadBaseClass
{
public DerivedFromBad()
{
state = "DerivedFromBad ";
}
public override void SetState()
{
Console.WriteLine(state);
}
}
public class tester
{
public static void Main()
{
DerivedFromBad b = new DerivedFromBad();
}
}
}
Copyright für einzelne Teile 2005 Microsoft Corporation. Alle Rechte vorbehalten.
Copyright für einzelne Teile Addison-Wesley Corporation. Alle Rechte vorbehalten.
Weitere Informationen zu Entwurfsrichtlinien finden Sie im Buch "Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries" von Krzysztof Cwalina und Brad Abrams, veröffentlicht von Addison-Wesley, 2005.