Boksen en Uitpakken (C#-programmeerhandleiding)

Boksen is het proces van het converteren van een waardetype naar het type object of naar een interfacetype dat door dit waardetype wordt geïmplementeerd. Wanneer de COMMON Language Runtime (CLR) een waardetype insluit, wordt de waarde in een System.Object exemplaar verpakt en opgeslagen in de beheerde heap. Als u de vakken uitpakt, wordt het waardetype uit het object geëxtraheerd. Boksen is impliciet; het uitpakken is expliciet. Het concept van boksen en uitpakken onder de C#-uniforme weergave van het typesysteem waarin een waarde van elk type kan worden behandeld als een object.

In het volgende voorbeeld wordt de variabele i geheel getal in het vak geplaatst en toegewezen aan objecto.

int i = 123;
// The following line boxes i.
object o = i;

Het object o kan vervolgens worden uitgepakt en toegewezen aan een variabele igeheel getal:

o = 123;
i = (int)o;  // unboxing

In de volgende voorbeelden ziet u hoe boksen wordt gebruikt in C#.

// String.Concat example.
// String.Concat has many versions. Rest the mouse pointer on
// Concat in the following statement to verify that the version
// that is used here takes three object arguments. Both 42 and
// true must be boxed.
Console.WriteLine(String.Concat("Answer", 42, true));

// List example.
// Create a list of objects to hold a heterogeneous collection
// of elements.
List<object> mixedList = new List<object>();

// Add a string element to the list.
mixedList.Add("First Group:");

// Add some integers to the list.
for (int j = 1; j < 5; j++)
{
    // Rest the mouse pointer over j to verify that you are adding
    // an int to a list of objects. Each element j is boxed when
    // you add j to mixedList.
    mixedList.Add(j);
}

// Add another string and more integers.
mixedList.Add("Second Group:");
for (int j = 5; j < 10; j++)
{
    mixedList.Add(j);
}

// Display the elements in the list. Declare the loop variable by
// using var, so that the compiler assigns its type.
foreach (var item in mixedList)
{
    // Rest the mouse pointer over item to verify that the elements
    // of mixedList are objects.
    Console.WriteLine(item);
}

// The following loop sums the squares of the first group of boxed
// integers in mixedList. The list elements are objects, and cannot
// be multiplied or added to the sum until they are unboxed. The
// unboxing must be done explicitly.
var sum = 0;
for (var j = 1; j < 5; j++)
{
    // The following statement causes a compiler error: Operator
    // '*' cannot be applied to operands of type 'object' and
    // 'object'.
    //sum += mixedList[j] * mixedList[j];

    // After the list elements are unboxed, the computation does
    // not cause a compiler error.
    sum += (int)mixedList[j] * (int)mixedList[j];
}

// The sum displayed is 30, the sum of 1 + 4 + 9 + 16.
Console.WriteLine("Sum: " + sum);

// Output:
// Answer42True
// First Group:
// 1
// 2
// 3
// 4
// Second Group:
// 5
// 6
// 7
// 8
// 9
// Sum: 30

Prestaties

In relatie tot eenvoudige toewijzingen zijn boksen en uitpakken rekenkracht dure processen. Wanneer een waardetype in een vak wordt geplaatst, moet een nieuw object worden toegewezen en samengesteld. In mindere mate is de cast die nodig is voor het opheffen van de vakken ook kostbaar. Zie Prestaties voor meer informatie.

Boksen

Boksen wordt gebruikt voor het opslaan van waardetypen in de verzamelde afval heap. Boksen is een impliciete conversie van een waardetype naar het type object of naar een interfacetype dat door dit waardetype wordt geïmplementeerd. Als u een waardetype opgeeft, wijst u een objectexemplaren toe aan de heap en kopieert u de waarde naar het nieuwe object.

Overweeg de volgende declaratie van een waardetypevariabele:

int i = 123;

De volgende instructie past impliciet de boksbewerking op de variabele itoe:

// Boxing copies the value of i into object o.
object o = i;

Het resultaat van deze instructie is het maken van een objectverwijzing oop de stapel, die verwijst naar een waarde van het type int, op de heap. Deze waarde is een kopie van de waardetypewaarde die is toegewezen aan de variabele i. Het verschil tussen de twee variabelen en iowordt geïllustreerd in de volgende afbeelding van boksconversie:

Het is ook mogelijk om de boksen expliciet uit te voeren zoals in het volgende voorbeeld, maar expliciet boksen is nooit vereist:

int i = 123;
object o = (object)i;  // explicit boxing

Opmerking

In dit voorbeeld wordt een variabele i voor een geheel getal geconverteerd naar een object o met behulp van boksen. Vervolgens wordt de waarde die in de variabele i is opgeslagen, gewijzigd van 123 in 456. In het voorbeeld ziet u dat het oorspronkelijke waardetype en het boxed-object afzonderlijke geheugenlocaties gebruiken en daarom verschillende waarden kunnen opslaan.

class TestBoxing
{
    static void Main()
    {
        int i = 123;

        // Boxing copies the value of i into object o.
        object o = i;

        // Change the value of i.
        i = 456;

        // The change in i doesn't affect the value stored in o.
        System.Console.WriteLine("The value-type value = {0}", i);
        System.Console.WriteLine("The object-type value = {0}", o);
    }
}
/* Output:
    The value-type value = 456
    The object-type value = 123
*/

Unboxing

Het uitpakken van postvakken is een expliciete conversie van het type object naar een waardetype of van een interfacetype naar een waardetype waarmee de interface wordt geïmplementeerd. Een uitbox-bewerking bestaat uit:

• Controleer of het objectexemplaren een waarde in een vak van het opgegeven waardetype zijn.

• De waarde van het exemplaar kopiëren naar de variabele van het waardetype.

In de volgende instructies ziet u bewerkingen voor boksen en uitpakken:

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;   // unboxing

In de volgende afbeelding ziet u het resultaat van de vorige instructies:

Voor het ongedaan maken van het inpakken van waardetypen tijdens runtime moet het item dat wordt uitgepakt, een verwijzing zijn naar een object dat eerder is gemaakt door een exemplaar van dat waardetype in te boksen. Als u het Postvak null UIT probeert uit te schakelen, wordt een NullReferenceException. Als u een verwijzing naar een incompatibel waardetype probeert uit te schakelen, wordt een InvalidCastException.

Opmerking

In het volgende voorbeeld ziet u een geval van ongeldige uitboxing en het resulterende geval InvalidCastException. catchEr try wordt een foutbericht weergegeven wanneer de fout optreedt.

class TestUnboxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // implicit boxing

        try
        {
            int j = (short)o;  // attempt to unbox

            System.Console.WriteLine("Unboxing OK.");
        }
        catch (System.InvalidCastException e)
        {
            System.Console.WriteLine("{0} Error: Incorrect unboxing.", e.Message);
        }
    }
}

Dit programma voert het volgende uit:

Specified cast is not valid. Error: Incorrect unboxing.

Als u de instructie wijzigt:

int j = (short)o;

in:

int j = (int)o;

de conversie wordt uitgevoerd en u krijgt de uitvoer:

Unboxing OK.

C#-taalspecificatie

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

Zie ook

• Referentietypen
• Waardetypen