Constructors gebruiken (C#-programmeerhandleiding)
Wanneer een klasse of struct wordt geïnstantieerd, roept de runtime de constructor aan. Constructors hebben dezelfde naam als de klasse of struct en initialiseren meestal de gegevensleden van het nieuwe object.
In het volgende voorbeeld wordt een klasse met de naam Taxi gedefinieerd met behulp van een eenvoudige constructor. Deze klasse wordt vervolgens geïnstantieerd met de operator new. De runtime roept de Taxi constructor onmiddellijk aan nadat het geheugen is toegewezen voor het nieuwe object.
public class Taxi
{
private string taxiTag;
public Taxi(string tag) => taxiTag = tag;
public override string ToString() => $"Taxi: {taxiTag}";
}
class TestTaxi
{
static void Main()
{
Taxi t = new Taxi("Tag1345");
Console.WriteLine(t);
}
}
Een constructor die geen parameters gebruikt, wordt een parameterloze constructorgenoemd. De runtime roept de parameterloze constructor aan wanneer een object wordt geïnstantieerd met behulp van de operator new en er geen argumenten worden opgegeven voor new. C# 12 heeft primaire constructors geïntroduceerd. Een primaire constructor geeft parameters op die moeten worden opgegeven om een nieuw object te initialiseren. Zie Exemplaarconstructorsvoor meer informatie.
Tenzij de klasse is statische, krijgen klassen zonder constructors een openbare parameterloze constructor van de C#-compiler om instantiëring van klassen mogelijk te maken. Zie statische klassen en statische klasseledenvoor meer informatie.
U kunt voorkomen dat een klasse wordt geïnstantieerd door de constructor als volgt privé te maken:
class NLog
{
// Private Constructor:
private NLog() { }
public static double e = Math.E; //2.71828...
}
Zie Private Constructorsvoor meer informatie.
Constructors voor struct typen lijken op klasseconstructors. Wanneer een structtype wordt geïnstantieerd met new, roept de runtime een constructor aan. Wanneer een struct is ingesteld op de default waarde, initialiseert de runtime alle geheugen in de struct op 0. Als u veld initialisaties declareert in een struct type, moet u een parameterloze constructor opgeven. Zie voor meer informatie de sectie Struct-initialisatie en standaardwaarden van het Structuurtypen artikel.
De volgende code maakt gebruik van de parameterloze constructor voor Int32, zodat u zeker weet dat het gehele getal wordt geïnitialiseerd:
int i = new int();
Console.WriteLine(i);
De volgende code veroorzaakt echter een compilerfout omdat deze geen gebruik maakt van newen omdat er wordt geprobeerd een object te gebruiken dat niet is geïnitialiseerd:
int i;
Console.WriteLine(i);
U kunt ook sommige struct typen (inclusief alle ingebouwde numerieke typen) initialiseren of toewijzen en vervolgens gebruiken zoals in het volgende voorbeeld:
int a = 44; // Initialize the value type...
int b;
b = 33; // Or assign it before using it.
Console.WriteLine("{0}, {1}", a, b);
Zowel klassen als structs kunnen constructors definiëren die parameters accepteren, waaronder primaire constructors. Constructors die parameters aannemen, moeten worden aangeroepen via een new instructie of een basis- instructie. Klassen en structs kunnen ook meerdere constructors definiëren en geen van beide is vereist om een parameterloze constructor te definiëren. Bijvoorbeeld:
public class Employee
{
public int Salary;
public Employee() { }
public Employee(int annualSalary) => Salary = annualSalary;
public Employee(int weeklySalary, int numberOfWeeks) => Salary = weeklySalary * numberOfWeeks;
}
Deze klasse kan worden gemaakt met behulp van een van de volgende instructies:
Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);
Een constructor kan het base trefwoord gebruiken om de constructor van een basisklasse aan te roepen. Bijvoorbeeld:
public class Manager : Employee
{
public Manager(int annualSalary)
: base(annualSalary)
{
//Add further instructions here.
}
}
In dit voorbeeld wordt de constructor van de basisklasse aangeroepen voordat het constructorblok wordt uitgevoerd. Het base trefwoord kan worden gebruikt met of zonder parameters. Parameters voor de constructor kunnen worden gebruikt als parameters voor baseof als onderdeel van een expressie. Zie basisvoor meer informatie.
Als in een afgeleide klasse een constructor met basisklassen niet expliciet wordt aangeroepen met behulp van het trefwoord base, wordt de parameterloze constructor impliciet aangeroepen als er een is. De volgende constructordeclaraties zijn in feite hetzelfde:
public Manager(int initialData)
{
//Add further instructions here.
}
public Manager(int initialData)
: base()
{
//Add further instructions here.
}
Als een basisklasse geen parameterloze constructor biedt, moet de afgeleide klasse een expliciete aanroep naar een basisconstructor maken met behulp van base.
Een constructor kan een andere constructor in hetzelfde object aanroepen met behulp van het trefwoord this. Net als basekunnen this worden gebruikt met of zonder parameters en zijn parameters in de constructor beschikbaar als parameters voor thisof als onderdeel van een expressie. De tweede constructor in het vorige voorbeeld kan bijvoorbeeld opnieuw worden geschreven met behulp van this:
public Employee(int weeklySalary, int numberOfWeeks)
: this(weeklySalary * numberOfWeeks)
{
}
Het gebruik van het this trefwoord in het vorige voorbeeld zorgt ervoor dat de volgende constructor wordt aangeroepen:
public Employee(int annualSalary) => Salary = annualSalary;
Constructors kunnen worden gemarkeerd als public, private, protected, interne, beveiligde interne of private protected. Deze toegangsaanpassingen definiëren hoe gebruikers van de klasse de klasse kunnen samenstellen. Zie Toegangsmodifiersvoor meer informatie.
Een constructor kan statisch worden gedeclareerd met behulp van het trefwoord static. Statische constructors worden automatisch aangeroepen, voordat statische velden worden geopend en worden gebruikt om statische klasseleden te initialiseren. Voor meer informatie, zie Statische Constructors.
C#-taalspecificatie
Zie Exemplaarconstructies en Statische constructies in de C#-taalspecificatievoor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.
