Inleiding tot klassen

  • Artikel

Verwijzingstypen

Een type dat is gedefinieerd als een classverwijzingstype. Wanneer u tijdens runtime een variabele van een verwijzingstype declareert, bevat de variabele de waarde null totdat u expliciet een exemplaar van de klasse maakt met behulp van de new operator of een object toewijst van een compatibel type dat ergens anders is gemaakt, zoals wordt weergegeven in het volgende voorbeeld:

//Declaring an object of type MyClass.
MyClass mc = new MyClass();

//Declaring another object of the same type, assigning it the value of the first object.
MyClass mc2 = mc;

Wanneer het object wordt gemaakt, wordt er voldoende geheugen toegewezen aan de beheerde heap voor dat specifieke object en bevat de variabele alleen een verwijzing naar de locatie van dat object. Het geheugen dat door een object wordt gebruikt, wordt vrijgemaakt door de functionaliteit voor automatisch geheugenbeheer van de CLR, ook wel garbagecollection genoemd. Zie Automatisch geheugenbeheer en garbagecollection voor meer informatie over garbagecollection.

Klassen declareren

Klassen worden gedeclareerd met behulp van het class trefwoord gevolgd door een unieke id, zoals wordt weergegeven in het volgende voorbeeld:

//[access modifier] - [class] - [identifier]
public class Customer
{
   // Fields, properties, methods and events go here...
}

Een optionele wijzigingsfunctie voor toegang voorafgaat aan het class trefwoord. Omdat public in dit geval wordt gebruikt, kan iedereen exemplaren van deze klasse maken. De naam van de klasse volgt het class trefwoord. De naam van de klasse moet een geldige C# -id-naam zijn. De rest van de definitie is de hoofdtekst van de klasse, waarbij het gedrag en de gegevens worden gedefinieerd. Velden, eigenschappen, methoden en gebeurtenissen in een klasse worden gezamenlijk klasseleden genoemd.

Objecten maken

Hoewel ze soms door elkaar worden gebruikt, zijn een klasse en een object verschillende dingen. Een klasse definieert een type object, maar het is geen object zelf. Een object is een concrete entiteit op basis van een klasse en wordt ook wel een instantie van een klasse genoemd.

Objecten kunnen worden gemaakt met behulp van het new trefwoord gevolgd door de naam van de klasse, zoals deze:

Customer object1 = new Customer();

Wanneer een exemplaar van een klasse wordt gemaakt, wordt een verwijzing naar het object doorgegeven aan de programmeur. In het vorige voorbeeld object1 is een verwijzing naar een object dat is gebaseerd op Customer. Deze verwijzing verwijst naar het nieuwe object, maar bevat niet de objectgegevens zelf. U kunt zelfs een objectverwijzing maken zonder dat u een object hoeft te maken:

Customer object2;

Het is niet raadzaam om objectverwijzingen te maken die niet naar een object verwijzen, omdat het openen van een object via een dergelijke verwijzing tijdens runtime mislukt. U kunt verwijzen naar een object door een nieuw object te maken of door een bestaand object toe te wijzen, zoals:

Customer object3 = new Customer();
Customer object4 = object3;

Met deze code worden twee objectverwijzingen gemaakt die beide naar hetzelfde object verwijzen. Daarom worden eventuele wijzigingen in het object dat door het object object3 is aangebracht, weerspiegeld in volgende toepassingen van object4. Omdat naar objecten wordt verwezen op basis van klassen, worden klassen ook wel referentietypen genoemd.

Constructors en initialisatie

In de voorgaande secties is de syntaxis geïntroduceerd om een klassetype te declareren en een exemplaar van dat type te maken. Wanneer u een exemplaar van een type maakt, wilt u ervoor zorgen dat de velden en eigenschappen worden geïnitialiseerd tot nuttige waarden. Er zijn verschillende manieren om waarden te initialiseren:

  • Standaardwaarden accepteren
  • Initialisatiefunctie voor velden
  • Constructorparameters
  • Object-initialisatiefuncties

Elk .NET-type heeft een standaardwaarde. Normaal gesproken is die waarde 0 voor getaltypen en null voor alle referentietypen. U kunt vertrouwen op die standaardwaarde wanneer deze redelijk is in uw app.

Wanneer de standaardwaarde van .NET niet de juiste waarde is, kunt u een initiële waarde instellen met behulp van een veld-initialisatiefunctie:

public class Container
{
    // Initialize capacity field to a default value of 10:
    private int _capacity = 10;
}

U kunt vereisen dat bellers een initiële waarde opgeven door een constructor te definiëren die verantwoordelijk is voor het instellen van die initiële waarde:

public class Container
{
    private int _capacity;

    public Container(int capacity) => _capacity = capacity;
}

Vanaf C# 12 kunt u een primaire constructor definiëren als onderdeel van de klassedeclaratie:

public class Container(int capacity)
{
    private int _capacity = capacity;
}

Door parameters toe te voegen aan de klassenaam wordt de primaire constructor gedefinieerd. Deze parameters zijn beschikbaar in de hoofdtekst van de klasse, die de leden bevat. U kunt ze gebruiken om velden of ergens anders waar ze nodig zijn te initialiseren.

U kunt de required wijzigingsfunctie ook gebruiken voor een eigenschap en bellers toestaan een object-initialisatiefunctie te gebruiken om de initiële waarde van de eigenschap in te stellen:

public class Person
{
    public required string LastName { get; set; }
    public required string FirstName { get; set; }
}

De toevoeging van de required trefwoordmandaten die aanroepers moeten instellen als onderdeel van een new expressie:

var p1 = new Person(); // Error! Required properties not set
var p2 = new Person() { FirstName = "Grace", LastName = "Hopper" };

Overname van klassen

Klassen ondersteunen overname volledig, een fundamenteel kenmerk van objectgeoriënteerd programmeren. Wanneer u een klasse maakt, kunt u overnemen van elke andere klasse die niet is gedefinieerd als sealed. Andere klassen kunnen overnemen van uw klasse en virtuele methoden van klasse overschrijven. Bovendien kunt u een of meer interfaces implementeren.

Overname wordt bereikt met behulp van een afleiding, wat betekent dat een klasse wordt gedeclareerd met behulp van een basisklasse waaruit gegevens en gedrag worden overgenomen. Een basisklasse wordt opgegeven door een dubbele punt en de naam van de basisklasse toe te voegen volgens de naam van de afgeleide klasse, zoals deze:

public class Manager : Employee
{
    // Employee fields, properties, methods and events are inherited
    // New Manager fields, properties, methods and events go here...
}

Wanneer een klassedeclaratie een basisklasse bevat, neemt deze alle leden van de basisklasse over, behalve de constructors. Zie Overname voor meer informatie.

Een klasse in C# kan slechts rechtstreeks overnemen van één basisklasse. Omdat een basisklasse echter zelf kan overnemen van een andere klasse, kan een klasse indirect meerdere basisklassen overnemen. Bovendien kan een klasse rechtstreeks een of meer interfaces implementeren. Zie Interfaces voor meer informatie.

Een klasse kan worden gedeclareerd als abstract. Een abstracte klasse bevat abstracte methoden die een handtekeningdefinitie hebben, maar geen implementatie. Abstracte klassen kunnen niet worden geïnstantieerd. Ze kunnen alleen worden gebruikt via afgeleide klassen die de abstracte methoden implementeren. Een verzegelde klasse staat daarentegen niet toe dat andere klassen ermee worden afgeleid. Zie Abstracte en verzegelde klassen en klasseleden voor meer informatie.

Klassedefinities kunnen worden gesplitst tussen verschillende bronbestanden. Zie Gedeeltelijke klassen en methoden voor meer informatie.

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.