KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C#

Boxing en unboxing van waarden in C#

Leer wanneer C# een waarde naar een object kopieert, waarom het type bij unboxing moet overeenkomen en welke uitzondering bij elke fout hoort.

Versie: C# 12 and .NET 8; later runtimes may add compatible features

Syntax

object boxed = value;       // value has a boxable value type T
T copy = (T)boxed;          // T is the original non-nullable value type
T? optional = (T?)boxed;    // also accepts null and yields an empty T?

Boxing zet een waarde zoals int impliciet om naar object of naar een interfacetype dat het waardetype implementeert. De runtime maakt daarvoor normaal gesproken op de beheerde heap een object aan waarin een kopie van de waarde wordt opgeslagen. Als je daarna de oorspronkelijke variabele wijzigt, blijft die kopie gelijk. Veelvuldig boxen kan de garbagecollector extra belasten; List<int> slaat elementen op zonder ze te boxen.

Unboxing is een expliciete conversie die het type van de opgeslagen waarde controleert en de waarde uit het object kopieert. Voor een niet-nullable waardetype als bestemming vereist C# een exacte typeovereenkomst. Bevat boxed een int, dan slaagt (int)boxed, maar (long)boxed gooit InvalidCastException, zelfs als het getal in een long past. In long widened = (int)boxed; wordt eerst de int uitgepakt, waarna de toewijzing deze impliciet omzet naar long.

Bij het uitpakken van een null-referentie naar een niet-nullable type zoals int treedt NullReferenceException op. Is de referentie niet null maar verwijst deze niet naar een compatibel object, dan treedt InvalidCastException op.

Voor T? werkt boxing anders: als HasValue waar is, wordt de onderliggende T geboxed en niet de T?-instantie. Anders levert de conversie een null-referentie op zonder een object aan te maken. Unboxing naar T? geeft een lege waarde voor null, of een waarde met daarin T voor een geboxte T. Een incompatibel object leidt nog steeds tot InvalidCastException.

Voorbeelden

#nullable enable
using System;

int source = 42;
object boxed = source;
source = 7;

Console.WriteLine(FormattableString.Invariant($"source={source}; boxed={(int)boxed}"));
long widened = (int)boxed;
Console.WriteLine(FormattableString.Invariant($"widened={widened}"));

try
{
    _ = (long)boxed;
}
catch (InvalidCastException)
{
    Console.WriteLine(nameof(InvalidCastException));
}

object? empty = (int?)null;
try
{
    _ = (int)empty!;
}
catch (NullReferenceException)
{
    Console.WriteLine(nameof(NullReferenceException));
}

int? present = (int?)boxed;
int? absent = (int?)empty;
Console.WriteLine(FormattableString.Invariant($"nullable value={present}; empty HasValue={absent.HasValue}"));

Resultaat

source=7; boxed=42
widened=42
InvalidCastException
NullReferenceException
nullable value=42; empty HasValue=False

Als je `source` wijzigt in `7`, blijft de geboxte `42` onveranderd. De `!` in `empty!` onderdrukt alleen de compilerwaarschuwing over een mogelijke `null`; het teken verandert de waarde niet en voorkomt de uitzondering niet.

Gerelateerde lessen

  • C# · Les 37 · Gemiddeld · Versie: 2

Bronnen