C# Academy · Les

Combineren met eigenschappen en basistypen

Geef parameters door aan basistypen en eigenschappen.

Les 4 van 413 stappen

Combineren met eigenschappen en basistypen is een gratis C# Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Primaire constructors combineren met overerving

Een afgeleide klasse met een primaire constructor kan de parameters doorgeven aan een basisklasse met de syntaxis : Base(args) in de kop.

using System;

class Animal(string name) {
    public string Name => name;
}

class Dog(string name) : Animal(name) {
    public string Speak() => Name + " says Woof";
}

Console.WriteLine(new Dog("Rex").Speak()); // Rex says Woof

Een deel van de parameters doorgeven

De afgeleide klasse kan meer parameters accepteren dan de basisklasse en alleen de relevante parameters doorgeven.

using System;

class Shape(string color) {
    public string Color => color;
}

class Box(string color, int size) : Shape(color) {
    public int Size => size;
}

var b = new Box("red", 5);
Console.WriteLine(b.Color + " " + b.Size); // red 5

Argumenten voor de basisklasse omvormen

Je kunt argumenten voor de constructor van de basisklasse inline in de kop berekenen uit de parameters van de afgeleide klasse.

using System;

class Label(string text) {
    public string Text => text;
}

class UpperLabel(string text) : Label(text.ToUpper()) {
}

Console.WriteLine(new UpperLabel("hi").Text); // HI

Eigenschappen ernaast toevoegen

Een primaire constructor en expliciete eigenschappen kunnen naast elkaar bestaan. Initialiseer de eigenschappen bij de declaratie vanuit de parameters.

using System;

class Product(string name, decimal price) {
    public string Name { get; } = name;
    public decimal Price { get; set; } = price;
}

var p = new Product("Book", 12m);
p.Price = 10m;
Console.WriteLine(p.Name + " " + p.Price); // Book 10

Parameters van de basisklasse en gebruik in de afgeleide klasse

Ook nadat een parameter aan de basisklasse is doorgegeven, kan een parameter van de primaire constructor nog steeds in de body van de afgeleide klasse worden gebruikt.

using System;

class Base(int id) {
    public int Id => id;
}

class Item(int id, string label) : Base(id) {
    public string Describe() => "#" + id + ": " + label;
}

Console.WriteLine(new Item(7, "Widget").Describe()); // #7: Widget

Records en primaire constructors

Records gebruiken primaire constructors om automatisch openbare eigenschappen te genereren die alleen met init kunnen worden ingesteld. Een positioneel record is het beknoptste geval.

using System;

record Person(string First, string Last) {
    public string Full => First + " " + Last;
}

Console.WriteLine(new Person("Ada", "Lovelace").Full); // Ada Lovelace

Overerving van records

Afgeleide records geven parameters positioneel door aan een basisrecord en genereren zo de gecombineerde verzameling eigenschappen.

using System;

record Vehicle(string Make);
record Car(string Make, int Doors) : Vehicle(Make);

var c = new Car("Toyota", 4);
Console.WriteLine(c.Make + " " + c.Doors); // Toyota 4

Valideren vóór de aanroep van de basisklasse

Als je validatie nodig hebt, voer je die uit in een eigenschapsinitializer met een throw-expressie; de aanroep van de basisklasse wordt nog steeds als eerste uitgevoerd.

using System;

class Base(string tag) { public string Tag => tag; }

class Node(string tag) : Base(tag) {
    public string Tag2 { get; } =
        tag.Length > 0 ? tag : throw new ArgumentException("empty");
}

Console.WriteLine(new Node("a").Tag); // a

Vastgelegde parameters en eigenschappen combineren

Je kunt sommige parameters als vastgelegde private toestand behouden en andere als eigenschappen beschikbaar maken, zodat je de openbare interface kunt afstemmen.

using System;

class Order(int id, decimal total) {
    public decimal Total { get; } = total; // public
    public string Reference() => "ORD-" + id;   // id stays private
}

var o = new Order(42, 99m);
Console.WriteLine(o.Reference() + " " + o.Total); // ORD-42 99

Standaardwaarden voor eigenschappen

Eigenschappen die niet aan parameters zijn gekoppeld, kunnen nog steeds standaardinitialisaties krijgen en vrij worden gecombineerd met parameters van een primaire constructor.

using System;

class Session(string user) {
    public string User { get; } = user;
    public bool Active { get; set; } = true;
}

var s = new Session("kai");
Console.WriteLine(s.User + " " + s.Active); // kai True

Alles samenbrengen

Een afgeleide klasse die parameters doorgeeft aan een basisklasse, een eigenschap toevoegt en een berekend lid beschikbaar maakt.

using System;

class Employee(string name) {
    public string Name => name;
}

class Manager(string name, int teamSize) : Employee(name) {
    public int TeamSize { get; } = teamSize;
    public string Title => Name + " (manages " + TeamSize + ")";
}

Console.WriteLine(new Manager("Sam", 5).Title); // Sam (manages 5)

Korte controle

Controleer hoe primaire constructors parameters doorgeven aan basisklassen.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je primaire constructors combineert met eigenschappen en basisklassen.

class D(...) : Base(args) geeft parameters door aan de basisklasse.
Argumenten voor de basisklasse kunnen inline worden berekend.
Eigenschappen kunnen bij de declaratie vanuit parameters worden geïnitialiseerd.
Records genereren openbare eigenschappen die alleen met init kunnen worden ingesteld vanuit positionele parameters.

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Combineren met eigenschappen en basistypen” gratis?

Ja — de volledige tekst van “Combineren met eigenschappen en basistypen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Combineren met eigenschappen en basistypen”?

Geef parameters door aan basistypen en eigenschappen. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Combineren met eigenschappen en basistypen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Primaire constructors voor klassen
Parameters vastleggen in leden
Primaire constructors voor structs
Combineren met eigenschappen en basistypen

← Terug naar C# Academy