C# Academy · Les

Waardetypen versus referentietypen

Bekijk hoe beide worden opgeslagen en gekopieerd.

Les 1 van 413 stappen

Waardetypen versus referentietypen is een gratis C# Academy-les op CoddyKit. Dit is les 1 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.

Twee typenfamilies

C#-typen vallen uiteen in waardetypen (int, double, bool, structs) en referentietypen (klassen, tekenreeksen, arrays). Ze verschillen in de manier waarop ze worden opgeslagen en gekopieerd.

using System;

class Program
{
    static void Main()
    {
        int valueType = 5;          // value type
        int[] referenceType = { 1, 2, 3 };  // reference type
        Console.WriteLine(valueType + ", length " + referenceType.Length);
    }
}

Waardetypen bevatten de gegevens

Een variabele van een waardetype bevat de gegevens rechtstreeks. Meestal staan deze op de stack of inline in het object waarin ze zijn opgenomen.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        double b = 3.14;
        bool c = true;
        Console.WriteLine(a + ", " + b + ", " + c);
    }
}

Referentietypen bevatten een adres

Een variabele van een referentietype bevat een referentie (adres) naar gegevens die op de heap zijn opgeslagen. De variabele en het object zijn afzonderlijk.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box b = new Box();   // b refers to a heap object
        b.Value = 42;
        Console.WriteLine(b.Value);
    }
}

Kopieerse mantiek: waardetypen

Bij het toewijzen van een waardetype worden de gegevens gekopieerd. Als je de kopie wijzigt, heeft dat nooit invloed op het origineel.

using System;

class Program
{
    static void Main()
    {
        int a = 1;
        int b = a;   // copy
        b = 99;
        Console.WriteLine("a=" + a + ", b=" + b);
    }
}

Kopieergedrag: referentietypen

Bij het toewijzen van een referentietype wordt de verwijzing gekopieerd, niet het object. Beide variabelen verwijzen daarna naar hetzelfde object.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box a = new Box { Value = 1 };
        Box b = a;   // same object
        b.Value = 99;
        Console.WriteLine("a.Value=" + a.Value + ", b.Value=" + b.Value);
    }
}

Structs zijn waardetypen

Een door je gedefinieerde struct is een waardetype en wordt bij toewijzing dus gekopieerd, net als int.

using System;

struct Point { public int X, Y; }

class Program
{
    static void Main()
    {
        Point p1 = new Point { X = 1, Y = 2 };
        Point p2 = p1;   // full copy
        p2.X = 99;
        Console.WriteLine("p1.X=" + p1.X + ", p2.X=" + p2.X);
    }
}

Doorgeven aan methoden

Standaard worden waardetypen als kopie doorgegeven en geven referentietypen een kopie van de verwijzing door. Een methode kan dus een klasseobject wijzigen dat de aanroeper ziet, maar geen gewone int.

using System;

class Counter { public int N; }

class Program
{
    static void BumpInt(int x) { x++; }
    static void BumpObj(Counter c) { c.N++; }

    static void Main()
    {
        int i = 0;
        BumpInt(i);
        var c = new Counter();
        BumpObj(c);
        Console.WriteLine("i=" + i + ", c.N=" + c.N);
    }
}

null en referentietypen

Alleen referentietypen kunnen null zijn (de afwezigheid van een object). Waardetypen bevatten altijd een waarde, tenzij je ze nullable declareert met ?.

using System;

class Program
{
    static void Main()
    {
        string text = null;        // reference type can be null
        int? maybe = null;          // nullable value type
        Console.WriteLine((text == null) + ", " + (maybe == null));
    }
}

Verschillen in gelijkheid

Bij waardetypen vergelijkt == de gegevens. Bij referentietypen vergelijkt == meestal de identiteit (hetzelfde object), tenzij je dit overschrijft.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 5;
        Console.WriteLine("ints: " + (a == b));   // True - same value

        object o1 = new object();
        object o2 = new object();
        Console.WriteLine("objects: " + (o1 == o2));   // False - different identity
    }
}

Standaardwaarden

Waardetypen hebben een standaardwaarde die op nul lijkt (0, false); referentietypen krijgen standaard null.

using System;

class Program
{
    static void Main()
    {
        int defaultInt = default;
        bool defaultBool = default;
        string defaultString = default;
        Console.WriteLine(defaultInt + ", " + defaultBool + ", null? " + (defaultString == null));
    }
}

Alles bij elkaar

Als je weet of een type een waarde- of referentietype is, kun je het kopieergedrag, null-toegestaan-zijn en de manier waarop methoden het type kunnen wijzigen voorspellen. Dat helpt je correcte code zonder fouten te schrijven.

using System;

struct Money { public decimal Amount; }
class Wallet { public decimal Amount; }

class Program
{
    static void Main()
    {
        Money m1 = new Money { Amount = 10 };
        Money m2 = m1; m2.Amount = 99;

        Wallet w1 = new Wallet { Amount = 10 };
        Wallet w2 = w1; w2.Amount = 99;

        Console.WriteLine("Money copy: " + m1.Amount + " (independent)");
        Console.WriteLine("Wallet ref: " + w1.Amount + " (shared)");
    }
}

Korte test

Test je begrip van waarde- en referentietypen.

Beantwoord dit in de interactieve les

Samenvatting

Waardetypen (int, double, bool, structs) slaan gegevens rechtstreeks op en worden bij toewijzing gekopieerd; referentietypen (klassen, tekenreeksen, arrays) slaan een verwijzing naar een object op de heap op en kopiëren de verwijzing. Alleen referentietypen mogen standaard null zijn, en toewijzingsgedrag en gelijkheidsvergelijking verschillen tussen deze twee families.

using System;

struct V { public int N; }
class R { public int N; }

class Program
{
    static void Main()
    {
        V v1 = new V { N = 1 }; V v2 = v1; v2.N = 9;
        R r1 = new R { N = 1 }; R r2 = r1; r2.N = 9;
        Console.WriteLine(v1.N + " vs " + r1.N);
    }
}

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 “Waardetypen versus referentietypen” gratis?

Ja — de volledige tekst van “Waardetypen versus referentietypen” 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 “Waardetypen versus referentietypen”?

Bekijk hoe beide worden opgeslagen en gekopieerd. 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 1 van 4.

Hoe lang duurt de les “Waardetypen versus referentietypen”?

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

← Terug naar C# Academy