C# Academy · Les

Constanten en readonly-velden

Maak onderscheid tussen const en static readonly.

Les 3 van 413 stappen

Constanten en readonly-velden is een gratis C# Academy-les op CoddyKit. Dit is les 3 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 manieren om waarden vast te zetten

C# biedt const en readonly voor waarden die niet mogen veranderen. Ze lijken op elkaar, maar gedragen zich heel verschillend. In deze les vergelijk je ze.

using System;

class Config
{
    public const double Pi = 3.14159;
    public static readonly DateTime StartedAt = DateTime.Now;
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Pi = " + Config.Pi);
    }
}

const: constante tijdens het compileren

Een const moet bij de declaratie een letterlijke waarde krijgen en wordt tijdens het compileren vastgelegd. Deze is impliciet statisch.

using System;

class Circle
{
    public const double Pi = 3.14159;

    public static double Area(double r) => Pi * r * r;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Circle.Area(2).ToString("0.00"));
    }
}

const moet een letterlijke waarde zijn

Omdat de waarde tijdens het compileren wordt bepaald, kan een const alleen een constante expressie bevatten: getallen, tekenreeksen, booleaanse waarden of andere constanten.

using System;

class Limits
{
    public const int MaxRetries = 3;
    public const int Timeout = MaxRetries * 1000;   // const expression OK
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Limits.MaxRetries + ", " + Limits.Timeout);
    }
}

readonly: constante tijdens uitvoering

Een readonly-veld wordt één keer ingesteld, bij de declaratie of in een constructor, en kan daarna niet meer veranderen. De waarde kan tijdens uitvoering worden berekend.

using System;

class Session
{
    public readonly string Id;

    public Session(string id)
    {
        Id = id;   // allowed: inside constructor
    }
}

class Program
{
    static void Main()
    {
        var s = new Session("abc-123");
        Console.WriteLine("Session: " + s.Id);
    }
}

readonly kan uitvoeringswaarden gebruiken

In tegenstelling tot const kan een readonly-veld een waarde bevatten die pas tijdens het uitvoeren van het programma bekend is, zoals een gegenereerde id of de huidige tijd.

using System;

class Order
{
    public readonly Guid OrderId;

    public Order()
    {
        OrderId = Guid.NewGuid();
    }
}

class Program
{
    static void Main()
    {
        var o = new Order();
        Console.WriteLine("Has id: " + (o.OrderId != Guid.Empty));
    }
}

static readonly

Combineer static readonly voor een klassenbrede waarde die tijdens uitvoering één keer wordt berekend. Dit is de gebruikelijke vervanging voor een const wanneer de waarde geen letterlijke waarde is.

using System;

class AppInfo
{
    public static readonly string[] Roles = { "admin", "user", "guest" };
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Roles: " + Roles());
    }

    static int Roles() => AppInfo.Roles.Length;
}

Waarom const riskant kan zijn tussen assembly's

Omdat const-waarden tijdens het compileren in de aanroepende code worden ingevuld, moet je alle aanroepen opnieuw compileren wanneer je een public const in een bibliotheek wijzigt. static readonly voorkomt dit.

using System;

class Lib
{
    public const int Version = 2;              // inlined into callers
    public static readonly int Build = 100;     // read at runtime
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lib.Version + "." + Lib.Build);
    }
}

Geen van beide kan opnieuw worden toegewezen

Na de initialisatie kan noch een const-veld, noch een readonly-veld worden gewijzigd. Als je dat probeert, krijg je een compilatiefout.

using System;

class Demo
{
    public const int A = 10;
    public readonly int B;

    public Demo() { B = 20; }
    // A = 11;  // would not compile
    // B = 21;  // would not compile outside constructor
}

class Program
{
    static void Main()
    {
        var d = new Demo();
        Console.WriteLine(Demo.A + ", " + d.B);
    }
}

Kiezen tussen beide

Gebruik const voor echte letterlijke waarden die nooit veranderen, zoals Pi en MaxInt. Gebruik readonly wanneer de waarde tijdens de uitvoering wordt berekend of per instantie kan verschillen.

using System;

class Physics
{
    public const double Gravity = 9.81;          // universal literal
    public readonly double Mass;                  // per object

    public Physics(double mass) { Mass = mass; }
    public double Weight() => Mass * Gravity;
}

class Program
{
    static void Main()
    {
        var p = new Physics(10);
        Console.WriteLine("Weight: " + p.Weight());
    }
}

Kanttekening bij readonly-verwijzingen

readonly vergrendelt het veld, niet het object waarnaar het verwijst. Een readonly-verwijzing naar een lijst kan niet opnieuw worden toegewezen, maar de inhoud ervan kan nog steeds veranderen.

using System;
using System.Collections.Generic;

class Cart
{
    public readonly List<string> Items = new List<string>();
}

class Program
{
    static void Main()
    {
        var c = new Cart();
        c.Items.Add("Pen");   // allowed: mutating the object
        c.Items.Add("Book");
        Console.WriteLine("Items: " + c.Items.Count);
    }
}

Alles samenbrengen

Een typische klasse gebruikt const voor vaste letterlijke waarden en readonly voor waarden die per instantie tijdens het maken ervan worden vastgelegd.

using System;

class Account
{
    public const decimal MinBalance = 0m;
    public readonly string Owner;

    public Account(string owner)
    {
        Owner = owner;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("Rin");
        Console.WriteLine(a.Owner + " min=" + Account.MinBalance);
    }
}

Korte controle

Test je begrip van const en readonly.

Beantwoord dit in de interactieve les

Samenvatting

const is een letterlijke waarde uit de compileertijd, is impliciet static en wordt in aanroepen ingevuld. readonly wordt één keer ingesteld bij de declaratie of in een constructor en kan waarden uit de uitvoeringstijd gebruiken. Gebruik const voor echte letterlijke waarden en static readonly voor tijdens de uitvoering berekende gedeelde waarden. Onthoud dat readonly de verwijzing vergrendelt, niet het object.

using System;

class Demo
{
    public const int Max = 100;
    public readonly int Created;
    public Demo(int c) { Created = c; }
}

class Program
{
    static void Main()
    {
        var d = new Demo(7);
        Console.WriteLine(Demo.Max + ", " + d.Created);
    }
}

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 “Constanten en readonly-velden” gratis?

Ja — de volledige tekst van “Constanten en readonly-velden” 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 “Constanten en readonly-velden”?

Maak onderscheid tussen const en static readonly. 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 3 van 4.

Hoe lang duurt de les “Constanten en readonly-velden”?

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